aboutsummaryrefslogtreecommitdiffhomepage
path: root/vendor/github.com/golang/protobuf
diff options
context:
space:
mode:
authorNathan Dench <ndenc2@gmail.com>2019-05-24 15:16:44 +1000
committerNathan Dench <ndenc2@gmail.com>2019-05-24 15:16:44 +1000
commit107c1cdb09c575aa2f61d97f48d8587eb6bada4c (patch)
treeca7d008643efc555c388baeaf1d986e0b6b3e28c /vendor/github.com/golang/protobuf
parent844b5a68d8af4791755b8f0ad293cc99f5959183 (diff)
downloadterraform-provider-statuscake-107c1cdb09c575aa2f61d97f48d8587eb6bada4c.tar.gz
terraform-provider-statuscake-107c1cdb09c575aa2f61d97f48d8587eb6bada4c.tar.zst
terraform-provider-statuscake-107c1cdb09c575aa2f61d97f48d8587eb6bada4c.zip
Upgrade to 0.12
Diffstat (limited to 'vendor/github.com/golang/protobuf')
-rw-r--r--vendor/github.com/golang/protobuf/proto/decode.go1
-rw-r--r--vendor/github.com/golang/protobuf/proto/deprecated.go63
-rw-r--r--vendor/github.com/golang/protobuf/proto/equal.go3
-rw-r--r--vendor/github.com/golang/protobuf/proto/extensions.go78
-rw-r--r--vendor/github.com/golang/protobuf/proto/lib.go38
-rw-r--r--vendor/github.com/golang/protobuf/proto/message_set.go137
-rw-r--r--vendor/github.com/golang/protobuf/proto/pointer_reflect.go5
-rw-r--r--vendor/github.com/golang/protobuf/proto/pointer_unsafe.go15
-rw-r--r--vendor/github.com/golang/protobuf/proto/properties.go31
-rw-r--r--vendor/github.com/golang/protobuf/proto/table_marshal.go45
-rw-r--r--vendor/github.com/golang/protobuf/proto/table_unmarshal.go72
-rw-r--r--vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go2887
-rw-r--r--vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.proto883
-rw-r--r--vendor/github.com/golang/protobuf/ptypes/any/any.pb.go45
-rw-r--r--vendor/github.com/golang/protobuf/ptypes/any/any.proto21
-rw-r--r--vendor/github.com/golang/protobuf/ptypes/duration.go2
-rw-r--r--vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go26
-rw-r--r--vendor/github.com/golang/protobuf/ptypes/timestamp.go6
-rw-r--r--vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go34
-rw-r--r--vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto8
20 files changed, 4095 insertions, 305 deletions
diff --git a/vendor/github.com/golang/protobuf/proto/decode.go b/vendor/github.com/golang/protobuf/proto/decode.go
index d9aa3c4..63b0f08 100644
--- a/vendor/github.com/golang/protobuf/proto/decode.go
+++ b/vendor/github.com/golang/protobuf/proto/decode.go
@@ -186,7 +186,6 @@ func (p *Buffer) DecodeVarint() (x uint64, err error) {
186 if b&0x80 == 0 { 186 if b&0x80 == 0 {
187 goto done 187 goto done
188 } 188 }
189 // x -= 0x80 << 63 // Always zero.
190 189
191 return 0, errOverflow 190 return 0, errOverflow
192 191
diff --git a/vendor/github.com/golang/protobuf/proto/deprecated.go b/vendor/github.com/golang/protobuf/proto/deprecated.go
new file mode 100644
index 0000000..35b882c
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/proto/deprecated.go
@@ -0,0 +1,63 @@
1// Go support for Protocol Buffers - Google's data interchange format
2//
3// Copyright 2018 The Go Authors. All rights reserved.
4// https://github.com/golang/protobuf
5//
6// Redistribution and use in source and binary forms, with or without
7// modification, are permitted provided that the following conditions are
8// met:
9//
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
15// distribution.
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.
19//
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.
31
32package proto
33
34import "errors"
35
36// Deprecated: do not use.
37type Stats struct{ Emalloc, Dmalloc, Encode, Decode, Chit, Cmiss, Size uint64 }
38
39// Deprecated: do not use.
40func GetStats() Stats { return Stats{} }
41
42// Deprecated: do not use.
43func MarshalMessageSet(interface{}) ([]byte, error) {
44 return nil, errors.New("proto: not implemented")
45}
46
47// Deprecated: do not use.
48func UnmarshalMessageSet([]byte, interface{}) error {
49 return errors.New("proto: not implemented")
50}
51
52// Deprecated: do not use.
53func MarshalMessageSetJSON(interface{}) ([]byte, error) {
54 return nil, errors.New("proto: not implemented")
55}
56
57// Deprecated: do not use.
58func UnmarshalMessageSetJSON([]byte, interface{}) error {
59 return errors.New("proto: not implemented")
60}
61
62// Deprecated: do not use.
63func RegisterMessageSetType(Message, int32, string) {}
diff --git a/vendor/github.com/golang/protobuf/proto/equal.go b/vendor/github.com/golang/protobuf/proto/equal.go
index d4db5a1..f9b6e41 100644
--- a/vendor/github.com/golang/protobuf/proto/equal.go
+++ b/vendor/github.com/golang/protobuf/proto/equal.go
@@ -246,7 +246,8 @@ func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool {
246 return false 246 return false
247 } 247 }
248 248
249 m1, m2 := e1.value, e2.value 249 m1 := extensionAsLegacyType(e1.value)
250 m2 := extensionAsLegacyType(e2.value)
250 251
251 if m1 == nil && m2 == nil { 252 if m1 == nil && m2 == nil {
252 // Both have only encoded form. 253 // Both have only encoded form.
diff --git a/vendor/github.com/golang/protobuf/proto/extensions.go b/vendor/github.com/golang/protobuf/proto/extensions.go
index 816a3b9..fa88add 100644
--- a/vendor/github.com/golang/protobuf/proto/extensions.go
+++ b/vendor/github.com/golang/protobuf/proto/extensions.go
@@ -185,9 +185,25 @@ type Extension struct {
185 // extension will have only enc set. When such an extension is 185 // extension will have only enc set. When such an extension is
186 // accessed using GetExtension (or GetExtensions) desc and value 186 // accessed using GetExtension (or GetExtensions) desc and value
187 // will be set. 187 // will be set.
188 desc *ExtensionDesc 188 desc *ExtensionDesc
189
190 // value is a concrete value for the extension field. Let the type of
191 // desc.ExtensionType be the "API type" and the type of Extension.value
192 // be the "storage type". The API type and storage type are the same except:
193 // * For scalars (except []byte), the API type uses *T,
194 // while the storage type uses T.
195 // * For repeated fields, the API type uses []T, while the storage type
196 // uses *[]T.
197 //
198 // The reason for the divergence is so that the storage type more naturally
199 // matches what is expected of when retrieving the values through the
200 // protobuf reflection APIs.
201 //
202 // The value may only be populated if desc is also populated.
189 value interface{} 203 value interface{}
190 enc []byte 204
205 // enc is the raw bytes for the extension field.
206 enc []byte
191} 207}
192 208
193// SetRawExtension is for testing only. 209// SetRawExtension is for testing only.
@@ -334,7 +350,7 @@ func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) {
334 // descriptors with the same field number. 350 // descriptors with the same field number.
335 return nil, errors.New("proto: descriptor conflict") 351 return nil, errors.New("proto: descriptor conflict")
336 } 352 }
337 return e.value, nil 353 return extensionAsLegacyType(e.value), nil
338 } 354 }
339 355
340 if extension.ExtensionType == nil { 356 if extension.ExtensionType == nil {
@@ -349,11 +365,11 @@ func GetExtension(pb Message, extension *ExtensionDesc) (interface{}, error) {
349 365
350 // Remember the decoded version and drop the encoded version. 366 // Remember the decoded version and drop the encoded version.
351 // That way it is safe to mutate what we return. 367 // That way it is safe to mutate what we return.
352 e.value = v 368 e.value = extensionAsStorageType(v)
353 e.desc = extension 369 e.desc = extension
354 e.enc = nil 370 e.enc = nil
355 emap[extension.Field] = e 371 emap[extension.Field] = e
356 return e.value, nil 372 return extensionAsLegacyType(e.value), nil
357} 373}
358 374
359// defaultExtensionValue returns the default value for extension. 375// defaultExtensionValue returns the default value for extension.
@@ -488,7 +504,7 @@ func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error
488 } 504 }
489 typ := reflect.TypeOf(extension.ExtensionType) 505 typ := reflect.TypeOf(extension.ExtensionType)
490 if typ != reflect.TypeOf(value) { 506 if typ != reflect.TypeOf(value) {
491 return errors.New("proto: bad extension value type") 507 return fmt.Errorf("proto: bad extension value type. got: %T, want: %T", value, extension.ExtensionType)
492 } 508 }
493 // nil extension values need to be caught early, because the 509 // nil extension values need to be caught early, because the
494 // encoder can't distinguish an ErrNil due to a nil extension 510 // encoder can't distinguish an ErrNil due to a nil extension
@@ -500,7 +516,7 @@ func SetExtension(pb Message, extension *ExtensionDesc, value interface{}) error
500 } 516 }
501 517
502 extmap := epb.extensionsWrite() 518 extmap := epb.extensionsWrite()
503 extmap[extension.Field] = Extension{desc: extension, value: value} 519 extmap[extension.Field] = Extension{desc: extension, value: extensionAsStorageType(value)}
504 return nil 520 return nil
505} 521}
506 522
@@ -541,3 +557,51 @@ func RegisterExtension(desc *ExtensionDesc) {
541func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc { 557func RegisteredExtensions(pb Message) map[int32]*ExtensionDesc {
542 return extensionMaps[reflect.TypeOf(pb).Elem()] 558 return extensionMaps[reflect.TypeOf(pb).Elem()]
543} 559}
560
561// extensionAsLegacyType converts an value in the storage type as the API type.
562// See Extension.value.
563func extensionAsLegacyType(v interface{}) interface{} {
564 switch rv := reflect.ValueOf(v); rv.Kind() {
565 case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
566 // Represent primitive types as a pointer to the value.
567 rv2 := reflect.New(rv.Type())
568 rv2.Elem().Set(rv)
569 v = rv2.Interface()
570 case reflect.Ptr:
571 // Represent slice types as the value itself.
572 switch rv.Type().Elem().Kind() {
573 case reflect.Slice:
574 if rv.IsNil() {
575 v = reflect.Zero(rv.Type().Elem()).Interface()
576 } else {
577 v = rv.Elem().Interface()
578 }
579 }
580 }
581 return v
582}
583
584// extensionAsStorageType converts an value in the API type as the storage type.
585// See Extension.value.
586func extensionAsStorageType(v interface{}) interface{} {
587 switch rv := reflect.ValueOf(v); rv.Kind() {
588 case reflect.Ptr:
589 // Represent slice types as the value itself.
590 switch rv.Type().Elem().Kind() {
591 case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
592 if rv.IsNil() {
593 v = reflect.Zero(rv.Type().Elem()).Interface()
594 } else {
595 v = rv.Elem().Interface()
596 }
597 }
598 case reflect.Slice:
599 // Represent slice types as a pointer to the value.
600 if rv.Type().Elem().Kind() != reflect.Uint8 {
601 rv2 := reflect.New(rv.Type())
602 rv2.Elem().Set(rv)
603 v = rv2.Interface()
604 }
605 }
606 return v
607}
diff --git a/vendor/github.com/golang/protobuf/proto/lib.go b/vendor/github.com/golang/protobuf/proto/lib.go
index 75565cc..fdd328b 100644
--- a/vendor/github.com/golang/protobuf/proto/lib.go
+++ b/vendor/github.com/golang/protobuf/proto/lib.go
@@ -341,26 +341,6 @@ type Message interface {
341 ProtoMessage() 341 ProtoMessage()
342} 342}
343 343
344// Stats records allocation details about the protocol buffer encoders
345// and decoders. Useful for tuning the library itself.
346type Stats struct {
347 Emalloc uint64 // mallocs in encode
348 Dmalloc uint64 // mallocs in decode
349 Encode uint64 // number of encodes
350 Decode uint64 // number of decodes
351 Chit uint64 // number of cache hits
352 Cmiss uint64 // number of cache misses
353 Size uint64 // number of sizes
354}
355
356// Set to true to enable stats collection.
357const collectStats = false
358
359var stats Stats
360
361// GetStats returns a copy of the global Stats structure.
362func GetStats() Stats { return stats }
363
364// A Buffer is a buffer manager for marshaling and unmarshaling 344// A Buffer is a buffer manager for marshaling and unmarshaling
365// protocol buffers. It may be reused between invocations to 345// protocol buffers. It may be reused between invocations to
366// reduce memory usage. It is not necessary to use a Buffer; 346// reduce memory usage. It is not necessary to use a Buffer;
@@ -960,13 +940,19 @@ func isProto3Zero(v reflect.Value) bool {
960 return false 940 return false
961} 941}
962 942
963// ProtoPackageIsVersion2 is referenced from generated protocol buffer files 943const (
964// to assert that that code is compatible with this version of the proto package. 944 // ProtoPackageIsVersion3 is referenced from generated protocol buffer files
965const ProtoPackageIsVersion2 = true 945 // to assert that that code is compatible with this version of the proto package.
946 ProtoPackageIsVersion3 = true
947
948 // ProtoPackageIsVersion2 is referenced from generated protocol buffer files
949 // to assert that that code is compatible with this version of the proto package.
950 ProtoPackageIsVersion2 = true
966 951
967// ProtoPackageIsVersion1 is referenced from generated protocol buffer files 952 // ProtoPackageIsVersion1 is referenced from generated protocol buffer files
968// to assert that that code is compatible with this version of the proto package. 953 // to assert that that code is compatible with this version of the proto package.
969const ProtoPackageIsVersion1 = true 954 ProtoPackageIsVersion1 = true
955)
970 956
971// InternalMessageInfo is a type used internally by generated .pb.go files. 957// InternalMessageInfo is a type used internally by generated .pb.go files.
972// This type is not intended to be used by non-generated code. 958// This type is not intended to be used by non-generated code.
diff --git a/vendor/github.com/golang/protobuf/proto/message_set.go b/vendor/github.com/golang/protobuf/proto/message_set.go
index 3b6ca41..f48a756 100644
--- a/vendor/github.com/golang/protobuf/proto/message_set.go
+++ b/vendor/github.com/golang/protobuf/proto/message_set.go
@@ -36,13 +36,7 @@ package proto
36 */ 36 */
37 37
38import ( 38import (
39 "bytes"
40 "encoding/json"
41 "errors" 39 "errors"
42 "fmt"
43 "reflect"
44 "sort"
45 "sync"
46) 40)
47 41
48// errNoMessageTypeID occurs when a protocol buffer does not have a message type ID. 42// errNoMessageTypeID occurs when a protocol buffer does not have a message type ID.
@@ -145,46 +139,9 @@ func skipVarint(buf []byte) []byte {
145 return buf[i+1:] 139 return buf[i+1:]
146} 140}
147 141
148// MarshalMessageSet encodes the extension map represented by m in the message set wire format. 142// unmarshalMessageSet decodes the extension map encoded in buf in the message set wire format.
149// It is called by generated Marshal methods on protocol buffer messages with the message_set_wire_format option.
150func MarshalMessageSet(exts interface{}) ([]byte, error) {
151 return marshalMessageSet(exts, false)
152}
153
154// marshaMessageSet implements above function, with the opt to turn on / off deterministic during Marshal.
155func marshalMessageSet(exts interface{}, deterministic bool) ([]byte, error) {
156 switch exts := exts.(type) {
157 case *XXX_InternalExtensions:
158 var u marshalInfo
159 siz := u.sizeMessageSet(exts)
160 b := make([]byte, 0, siz)
161 return u.appendMessageSet(b, exts, deterministic)
162
163 case map[int32]Extension:
164 // This is an old-style extension map.
165 // Wrap it in a new-style XXX_InternalExtensions.
166 ie := XXX_InternalExtensions{
167 p: &struct {
168 mu sync.Mutex
169 extensionMap map[int32]Extension
170 }{
171 extensionMap: exts,
172 },
173 }
174
175 var u marshalInfo
176 siz := u.sizeMessageSet(&ie)
177 b := make([]byte, 0, siz)
178 return u.appendMessageSet(b, &ie, deterministic)
179
180 default:
181 return nil, errors.New("proto: not an extension map")
182 }
183}
184
185// UnmarshalMessageSet decodes the extension map encoded in buf in the message set wire format.
186// It is called by Unmarshal methods on protocol buffer messages with the message_set_wire_format option. 143// It is called by Unmarshal methods on protocol buffer messages with the message_set_wire_format option.
187func UnmarshalMessageSet(buf []byte, exts interface{}) error { 144func unmarshalMessageSet(buf []byte, exts interface{}) error {
188 var m map[int32]Extension 145 var m map[int32]Extension
189 switch exts := exts.(type) { 146 switch exts := exts.(type) {
190 case *XXX_InternalExtensions: 147 case *XXX_InternalExtensions:
@@ -222,93 +179,3 @@ func UnmarshalMessageSet(buf []byte, exts interface{}) error {
222 } 179 }
223 return nil 180 return nil
224} 181}
225
226// MarshalMessageSetJSON encodes the extension map represented by m in JSON format.
227// It is called by generated MarshalJSON methods on protocol buffer messages with the message_set_wire_format option.
228func MarshalMessageSetJSON(exts interface{}) ([]byte, error) {
229 var m map[int32]Extension
230 switch exts := exts.(type) {
231 case *XXX_InternalExtensions:
232 var mu sync.Locker
233 m, mu = exts.extensionsRead()
234 if m != nil {
235 // Keep the extensions map locked until we're done marshaling to prevent
236 // races between marshaling and unmarshaling the lazily-{en,de}coded
237 // values.
238 mu.Lock()
239 defer mu.Unlock()
240 }
241 case map[int32]Extension:
242 m = exts
243 default:
244 return nil, errors.New("proto: not an extension map")
245 }
246 var b bytes.Buffer
247 b.WriteByte('{')
248
249 // Process the map in key order for deterministic output.
250 ids := make([]int32, 0, len(m))
251 for id := range m {
252 ids = append(ids, id)
253 }
254 sort.Sort(int32Slice(ids)) // int32Slice defined in text.go
255
256 for i, id := range ids {
257 ext := m[id]
258 msd, ok := messageSetMap[id]
259 if !ok {
260 // Unknown type; we can't render it, so skip it.
261 continue
262 }
263
264 if i > 0 && b.Len() > 1 {
265 b.WriteByte(',')
266 }
267
268 fmt.Fprintf(&b, `"[%s]":`, msd.name)
269
270 x := ext.value
271 if x == nil {
272 x = reflect.New(msd.t.Elem()).Interface()
273 if err := Unmarshal(ext.enc, x.(Message)); err != nil {
274 return nil, err
275 }
276 }
277 d, err := json.Marshal(x)
278 if err != nil {
279 return nil, err
280 }
281 b.Write(d)
282 }
283 b.WriteByte('}')
284 return b.Bytes(), nil
285}
286
287// UnmarshalMessageSetJSON decodes the extension map encoded in buf in JSON format.
288// It is called by generated UnmarshalJSON methods on protocol buffer messages with the message_set_wire_format option.
289func UnmarshalMessageSetJSON(buf []byte, exts interface{}) error {
290 // Common-case fast path.
291 if len(buf) == 0 || bytes.Equal(buf, []byte("{}")) {
292 return nil
293 }
294
295 // This is fairly tricky, and it's not clear that it is needed.
296 return errors.New("TODO: UnmarshalMessageSetJSON not yet implemented")
297}
298
299// A global registry of types that can be used in a MessageSet.
300
301var messageSetMap = make(map[int32]messageSetDesc)
302
303type messageSetDesc struct {
304 t reflect.Type // pointer to struct
305 name string
306}
307
308// RegisterMessageSetType is called from the generated code.
309func RegisterMessageSetType(m Message, fieldNum int32, name string) {
310 messageSetMap[fieldNum] = messageSetDesc{
311 t: reflect.TypeOf(m),
312 name: name,
313 }
314}
diff --git a/vendor/github.com/golang/protobuf/proto/pointer_reflect.go b/vendor/github.com/golang/protobuf/proto/pointer_reflect.go
index b6cad90..94fa919 100644
--- a/vendor/github.com/golang/protobuf/proto/pointer_reflect.go
+++ b/vendor/github.com/golang/protobuf/proto/pointer_reflect.go
@@ -79,10 +79,13 @@ func toPointer(i *Message) pointer {
79 79
80// toAddrPointer converts an interface to a pointer that points to 80// toAddrPointer converts an interface to a pointer that points to
81// the interface data. 81// the interface data.
82func toAddrPointer(i *interface{}, isptr bool) pointer { 82func toAddrPointer(i *interface{}, isptr, deref bool) pointer {
83 v := reflect.ValueOf(*i) 83 v := reflect.ValueOf(*i)
84 u := reflect.New(v.Type()) 84 u := reflect.New(v.Type())
85 u.Elem().Set(v) 85 u.Elem().Set(v)
86 if deref {
87 u = u.Elem()
88 }
86 return pointer{v: u} 89 return pointer{v: u}
87} 90}
88 91
diff --git a/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go b/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go
index d55a335..dbfffe0 100644
--- a/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go
+++ b/vendor/github.com/golang/protobuf/proto/pointer_unsafe.go
@@ -85,16 +85,21 @@ func toPointer(i *Message) pointer {
85 85
86// toAddrPointer converts an interface to a pointer that points to 86// toAddrPointer converts an interface to a pointer that points to
87// the interface data. 87// the interface data.
88func toAddrPointer(i *interface{}, isptr bool) pointer { 88func toAddrPointer(i *interface{}, isptr, deref bool) (p pointer) {
89 // Super-tricky - read or get the address of data word of interface value. 89 // Super-tricky - read or get the address of data word of interface value.
90 if isptr { 90 if isptr {
91 // The interface is of pointer type, thus it is a direct interface. 91 // The interface is of pointer type, thus it is a direct interface.
92 // The data word is the pointer data itself. We take its address. 92 // The data word is the pointer data itself. We take its address.
93 return pointer{p: unsafe.Pointer(uintptr(unsafe.Pointer(i)) + ptrSize)} 93 p = pointer{p: unsafe.Pointer(uintptr(unsafe.Pointer(i)) + ptrSize)}
94 } else {
95 // The interface is not of pointer type. The data word is the pointer
96 // to the data.
97 p = pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}
94 } 98 }
95 // The interface is not of pointer type. The data word is the pointer 99 if deref {
96 // to the data. 100 p.p = *(*unsafe.Pointer)(p.p)
97 return pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]} 101 }
102 return p
98} 103}
99 104
100// valToPointer converts v to a pointer. v must be of pointer type. 105// valToPointer converts v to a pointer. v must be of pointer type.
diff --git a/vendor/github.com/golang/protobuf/proto/properties.go b/vendor/github.com/golang/protobuf/proto/properties.go
index 50b99b8..79668ff 100644
--- a/vendor/github.com/golang/protobuf/proto/properties.go
+++ b/vendor/github.com/golang/protobuf/proto/properties.go
@@ -334,9 +334,6 @@ func GetProperties(t reflect.Type) *StructProperties {
334 sprop, ok := propertiesMap[t] 334 sprop, ok := propertiesMap[t]
335 propertiesMu.RUnlock() 335 propertiesMu.RUnlock()
336 if ok { 336 if ok {
337 if collectStats {
338 stats.Chit++
339 }
340 return sprop 337 return sprop
341 } 338 }
342 339
@@ -346,17 +343,20 @@ func GetProperties(t reflect.Type) *StructProperties {
346 return sprop 343 return sprop
347} 344}
348 345
346type (
347 oneofFuncsIface interface {
348 XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})
349 }
350 oneofWrappersIface interface {
351 XXX_OneofWrappers() []interface{}
352 }
353)
354
349// getPropertiesLocked requires that propertiesMu is held. 355// getPropertiesLocked requires that propertiesMu is held.
350func getPropertiesLocked(t reflect.Type) *StructProperties { 356func getPropertiesLocked(t reflect.Type) *StructProperties {
351 if prop, ok := propertiesMap[t]; ok { 357 if prop, ok := propertiesMap[t]; ok {
352 if collectStats {
353 stats.Chit++
354 }
355 return prop 358 return prop
356 } 359 }
357 if collectStats {
358 stats.Cmiss++
359 }
360 360
361 prop := new(StructProperties) 361 prop := new(StructProperties)
362 // in case of recursive protos, fill this in now. 362 // in case of recursive protos, fill this in now.
@@ -391,13 +391,14 @@ func getPropertiesLocked(t reflect.Type) *StructProperties {
391 // Re-order prop.order. 391 // Re-order prop.order.
392 sort.Sort(prop) 392 sort.Sort(prop)
393 393
394 type oneofMessage interface { 394 var oots []interface{}
395 XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{}) 395 switch m := reflect.Zero(reflect.PtrTo(t)).Interface().(type) {
396 case oneofFuncsIface:
397 _, _, _, oots = m.XXX_OneofFuncs()
398 case oneofWrappersIface:
399 oots = m.XXX_OneofWrappers()
396 } 400 }
397 if om, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); ok { 401 if len(oots) > 0 {
398 var oots []interface{}
399 _, _, _, oots = om.XXX_OneofFuncs()
400
401 // Interpret oneof metadata. 402 // Interpret oneof metadata.
402 prop.OneofTypes = make(map[string]*OneofProperties) 403 prop.OneofTypes = make(map[string]*OneofProperties)
403 for _, oot := range oots { 404 for _, oot := range oots {
diff --git a/vendor/github.com/golang/protobuf/proto/table_marshal.go b/vendor/github.com/golang/protobuf/proto/table_marshal.go
index b167944..5cb11fa 100644
--- a/vendor/github.com/golang/protobuf/proto/table_marshal.go
+++ b/vendor/github.com/golang/protobuf/proto/table_marshal.go
@@ -87,6 +87,7 @@ type marshalElemInfo struct {
87 sizer sizer 87 sizer sizer
88 marshaler marshaler 88 marshaler marshaler
89 isptr bool // elem is pointer typed, thus interface of this type is a direct interface (extension only) 89 isptr bool // elem is pointer typed, thus interface of this type is a direct interface (extension only)
90 deref bool // dereference the pointer before operating on it; implies isptr
90} 91}
91 92
92var ( 93var (
@@ -320,8 +321,11 @@ func (u *marshalInfo) computeMarshalInfo() {
320 321
321 // get oneof implementers 322 // get oneof implementers
322 var oneofImplementers []interface{} 323 var oneofImplementers []interface{}
323 if m, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); ok { 324 switch m := reflect.Zero(reflect.PtrTo(t)).Interface().(type) {
325 case oneofFuncsIface:
324 _, _, _, oneofImplementers = m.XXX_OneofFuncs() 326 _, _, _, oneofImplementers = m.XXX_OneofFuncs()
327 case oneofWrappersIface:
328 oneofImplementers = m.XXX_OneofWrappers()
325 } 329 }
326 330
327 n := t.NumField() 331 n := t.NumField()
@@ -407,13 +411,22 @@ func (u *marshalInfo) getExtElemInfo(desc *ExtensionDesc) *marshalElemInfo {
407 panic("tag is not an integer") 411 panic("tag is not an integer")
408 } 412 }
409 wt := wiretype(tags[0]) 413 wt := wiretype(tags[0])
414 if t.Kind() == reflect.Ptr && t.Elem().Kind() != reflect.Struct {
415 t = t.Elem()
416 }
410 sizer, marshaler := typeMarshaler(t, tags, false, false) 417 sizer, marshaler := typeMarshaler(t, tags, false, false)
418 var deref bool
419 if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {
420 t = reflect.PtrTo(t)
421 deref = true
422 }
411 e = &marshalElemInfo{ 423 e = &marshalElemInfo{
412 wiretag: uint64(tag)<<3 | wt, 424 wiretag: uint64(tag)<<3 | wt,
413 tagsize: SizeVarint(uint64(tag) << 3), 425 tagsize: SizeVarint(uint64(tag) << 3),
414 sizer: sizer, 426 sizer: sizer,
415 marshaler: marshaler, 427 marshaler: marshaler,
416 isptr: t.Kind() == reflect.Ptr, 428 isptr: t.Kind() == reflect.Ptr,
429 deref: deref,
417 } 430 }
418 431
419 // update cache 432 // update cache
@@ -448,7 +461,7 @@ func (fi *marshalFieldInfo) computeMarshalFieldInfo(f *reflect.StructField) {
448 461
449func (fi *marshalFieldInfo) computeOneofFieldInfo(f *reflect.StructField, oneofImplementers []interface{}) { 462func (fi *marshalFieldInfo) computeOneofFieldInfo(f *reflect.StructField, oneofImplementers []interface{}) {
450 fi.field = toField(f) 463 fi.field = toField(f)
451 fi.wiretag = 1<<31 - 1 // Use a large tag number, make oneofs sorted at the end. This tag will not appear on the wire. 464 fi.wiretag = math.MaxInt32 // Use a large tag number, make oneofs sorted at the end. This tag will not appear on the wire.
452 fi.isPointer = true 465 fi.isPointer = true
453 fi.sizer, fi.marshaler = makeOneOfMarshaler(fi, f) 466 fi.sizer, fi.marshaler = makeOneOfMarshaler(fi, f)
454 fi.oneofElems = make(map[reflect.Type]*marshalElemInfo) 467 fi.oneofElems = make(map[reflect.Type]*marshalElemInfo)
@@ -476,10 +489,6 @@ func (fi *marshalFieldInfo) computeOneofFieldInfo(f *reflect.StructField, oneofI
476 } 489 }
477} 490}
478 491
479type oneofMessage interface {
480 XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})
481}
482
483// wiretype returns the wire encoding of the type. 492// wiretype returns the wire encoding of the type.
484func wiretype(encoding string) uint64 { 493func wiretype(encoding string) uint64 {
485 switch encoding { 494 switch encoding {
@@ -2310,8 +2319,8 @@ func makeMapMarshaler(f *reflect.StructField) (sizer, marshaler) {
2310 for _, k := range m.MapKeys() { 2319 for _, k := range m.MapKeys() {
2311 ki := k.Interface() 2320 ki := k.Interface()
2312 vi := m.MapIndex(k).Interface() 2321 vi := m.MapIndex(k).Interface()
2313 kaddr := toAddrPointer(&ki, false) // pointer to key 2322 kaddr := toAddrPointer(&ki, false, false) // pointer to key
2314 vaddr := toAddrPointer(&vi, valIsPtr) // pointer to value 2323 vaddr := toAddrPointer(&vi, valIsPtr, false) // pointer to value
2315 siz := keySizer(kaddr, 1) + valSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1) 2324 siz := keySizer(kaddr, 1) + valSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
2316 n += siz + SizeVarint(uint64(siz)) + tagsize 2325 n += siz + SizeVarint(uint64(siz)) + tagsize
2317 } 2326 }
@@ -2329,8 +2338,8 @@ func makeMapMarshaler(f *reflect.StructField) (sizer, marshaler) {
2329 for _, k := range keys { 2338 for _, k := range keys {
2330 ki := k.Interface() 2339 ki := k.Interface()
2331 vi := m.MapIndex(k).Interface() 2340 vi := m.MapIndex(k).Interface()
2332 kaddr := toAddrPointer(&ki, false) // pointer to key 2341 kaddr := toAddrPointer(&ki, false, false) // pointer to key
2333 vaddr := toAddrPointer(&vi, valIsPtr) // pointer to value 2342 vaddr := toAddrPointer(&vi, valIsPtr, false) // pointer to value
2334 b = appendVarint(b, tag) 2343 b = appendVarint(b, tag)
2335 siz := keySizer(kaddr, 1) + valCachedSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1) 2344 siz := keySizer(kaddr, 1) + valCachedSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
2336 b = appendVarint(b, uint64(siz)) 2345 b = appendVarint(b, uint64(siz))
@@ -2399,7 +2408,7 @@ func (u *marshalInfo) sizeExtensions(ext *XXX_InternalExtensions) int {
2399 // the last time this function was called. 2408 // the last time this function was called.
2400 ei := u.getExtElemInfo(e.desc) 2409 ei := u.getExtElemInfo(e.desc)
2401 v := e.value 2410 v := e.value
2402 p := toAddrPointer(&v, ei.isptr) 2411 p := toAddrPointer(&v, ei.isptr, ei.deref)
2403 n += ei.sizer(p, ei.tagsize) 2412 n += ei.sizer(p, ei.tagsize)
2404 } 2413 }
2405 mu.Unlock() 2414 mu.Unlock()
@@ -2434,7 +2443,7 @@ func (u *marshalInfo) appendExtensions(b []byte, ext *XXX_InternalExtensions, de
2434 2443
2435 ei := u.getExtElemInfo(e.desc) 2444 ei := u.getExtElemInfo(e.desc)
2436 v := e.value 2445 v := e.value
2437 p := toAddrPointer(&v, ei.isptr) 2446 p := toAddrPointer(&v, ei.isptr, ei.deref)
2438 b, err = ei.marshaler(b, p, ei.wiretag, deterministic) 2447 b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
2439 if !nerr.Merge(err) { 2448 if !nerr.Merge(err) {
2440 return b, err 2449 return b, err
@@ -2465,7 +2474,7 @@ func (u *marshalInfo) appendExtensions(b []byte, ext *XXX_InternalExtensions, de
2465 2474
2466 ei := u.getExtElemInfo(e.desc) 2475 ei := u.getExtElemInfo(e.desc)
2467 v := e.value 2476 v := e.value
2468 p := toAddrPointer(&v, ei.isptr) 2477 p := toAddrPointer(&v, ei.isptr, ei.deref)
2469 b, err = ei.marshaler(b, p, ei.wiretag, deterministic) 2478 b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
2470 if !nerr.Merge(err) { 2479 if !nerr.Merge(err) {
2471 return b, err 2480 return b, err
@@ -2510,7 +2519,7 @@ func (u *marshalInfo) sizeMessageSet(ext *XXX_InternalExtensions) int {
2510 2519
2511 ei := u.getExtElemInfo(e.desc) 2520 ei := u.getExtElemInfo(e.desc)
2512 v := e.value 2521 v := e.value
2513 p := toAddrPointer(&v, ei.isptr) 2522 p := toAddrPointer(&v, ei.isptr, ei.deref)
2514 n += ei.sizer(p, 1) // message, tag = 3 (size=1) 2523 n += ei.sizer(p, 1) // message, tag = 3 (size=1)
2515 } 2524 }
2516 mu.Unlock() 2525 mu.Unlock()
@@ -2553,7 +2562,7 @@ func (u *marshalInfo) appendMessageSet(b []byte, ext *XXX_InternalExtensions, de
2553 2562
2554 ei := u.getExtElemInfo(e.desc) 2563 ei := u.getExtElemInfo(e.desc)
2555 v := e.value 2564 v := e.value
2556 p := toAddrPointer(&v, ei.isptr) 2565 p := toAddrPointer(&v, ei.isptr, ei.deref)
2557 b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic) 2566 b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
2558 if !nerr.Merge(err) { 2567 if !nerr.Merge(err) {
2559 return b, err 2568 return b, err
@@ -2591,7 +2600,7 @@ func (u *marshalInfo) appendMessageSet(b []byte, ext *XXX_InternalExtensions, de
2591 2600
2592 ei := u.getExtElemInfo(e.desc) 2601 ei := u.getExtElemInfo(e.desc)
2593 v := e.value 2602 v := e.value
2594 p := toAddrPointer(&v, ei.isptr) 2603 p := toAddrPointer(&v, ei.isptr, ei.deref)
2595 b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic) 2604 b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
2596 b = append(b, 1<<3|WireEndGroup) 2605 b = append(b, 1<<3|WireEndGroup)
2597 if !nerr.Merge(err) { 2606 if !nerr.Merge(err) {
@@ -2621,7 +2630,7 @@ func (u *marshalInfo) sizeV1Extensions(m map[int32]Extension) int {
2621 2630
2622 ei := u.getExtElemInfo(e.desc) 2631 ei := u.getExtElemInfo(e.desc)
2623 v := e.value 2632 v := e.value
2624 p := toAddrPointer(&v, ei.isptr) 2633 p := toAddrPointer(&v, ei.isptr, ei.deref)
2625 n += ei.sizer(p, ei.tagsize) 2634 n += ei.sizer(p, ei.tagsize)
2626 } 2635 }
2627 return n 2636 return n
@@ -2656,7 +2665,7 @@ func (u *marshalInfo) appendV1Extensions(b []byte, m map[int32]Extension, determ
2656 2665
2657 ei := u.getExtElemInfo(e.desc) 2666 ei := u.getExtElemInfo(e.desc)
2658 v := e.value 2667 v := e.value
2659 p := toAddrPointer(&v, ei.isptr) 2668 p := toAddrPointer(&v, ei.isptr, ei.deref)
2660 b, err = ei.marshaler(b, p, ei.wiretag, deterministic) 2669 b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
2661 if !nerr.Merge(err) { 2670 if !nerr.Merge(err) {
2662 return b, err 2671 return b, err
diff --git a/vendor/github.com/golang/protobuf/proto/table_unmarshal.go b/vendor/github.com/golang/protobuf/proto/table_unmarshal.go
index ebf1caa..acee2fc 100644
--- a/vendor/github.com/golang/protobuf/proto/table_unmarshal.go
+++ b/vendor/github.com/golang/protobuf/proto/table_unmarshal.go
@@ -136,7 +136,7 @@ func (u *unmarshalInfo) unmarshal(m pointer, b []byte) error {
136 u.computeUnmarshalInfo() 136 u.computeUnmarshalInfo()
137 } 137 }
138 if u.isMessageSet { 138 if u.isMessageSet {
139 return UnmarshalMessageSet(b, m.offset(u.extensions).toExtensions()) 139 return unmarshalMessageSet(b, m.offset(u.extensions).toExtensions())
140 } 140 }
141 var reqMask uint64 // bitmask of required fields we've seen. 141 var reqMask uint64 // bitmask of required fields we've seen.
142 var errLater error 142 var errLater error
@@ -362,46 +362,48 @@ func (u *unmarshalInfo) computeUnmarshalInfo() {
362 } 362 }
363 363
364 // Find any types associated with oneof fields. 364 // Find any types associated with oneof fields.
365 // TODO: XXX_OneofFuncs returns more info than we need. Get rid of some of it? 365 var oneofImplementers []interface{}
366 fn := reflect.Zero(reflect.PtrTo(t)).MethodByName("XXX_OneofFuncs") 366 switch m := reflect.Zero(reflect.PtrTo(t)).Interface().(type) {
367 if fn.IsValid() { 367 case oneofFuncsIface:
368 res := fn.Call(nil)[3] // last return value from XXX_OneofFuncs: []interface{} 368 _, _, _, oneofImplementers = m.XXX_OneofFuncs()
369 for i := res.Len() - 1; i >= 0; i-- { 369 case oneofWrappersIface:
370 v := res.Index(i) // interface{} 370 oneofImplementers = m.XXX_OneofWrappers()
371 tptr := reflect.ValueOf(v.Interface()).Type() // *Msg_X 371 }
372 typ := tptr.Elem() // Msg_X 372 for _, v := range oneofImplementers {
373 373 tptr := reflect.TypeOf(v) // *Msg_X
374 f := typ.Field(0) // oneof implementers have one field 374 typ := tptr.Elem() // Msg_X
375 baseUnmarshal := fieldUnmarshaler(&f) 375
376 tags := strings.Split(f.Tag.Get("protobuf"), ",") 376 f := typ.Field(0) // oneof implementers have one field
377 fieldNum, err := strconv.Atoi(tags[1]) 377 baseUnmarshal := fieldUnmarshaler(&f)
378 if err != nil { 378 tags := strings.Split(f.Tag.Get("protobuf"), ",")
379 panic("protobuf tag field not an integer: " + tags[1]) 379 fieldNum, err := strconv.Atoi(tags[1])
380 } 380 if err != nil {
381 var name string 381 panic("protobuf tag field not an integer: " + tags[1])
382 for _, tag := range tags { 382 }
383 if strings.HasPrefix(tag, "name=") { 383 var name string
384 name = strings.TrimPrefix(tag, "name=") 384 for _, tag := range tags {
385 break 385 if strings.HasPrefix(tag, "name=") {
386 } 386 name = strings.TrimPrefix(tag, "name=")
387 break
387 } 388 }
389 }
388 390
389 // Find the oneof field that this struct implements. 391 // Find the oneof field that this struct implements.
390 // Might take O(n^2) to process all of the oneofs, but who cares. 392 // Might take O(n^2) to process all of the oneofs, but who cares.
391 for _, of := range oneofFields { 393 for _, of := range oneofFields {
392 if tptr.Implements(of.ityp) { 394 if tptr.Implements(of.ityp) {
393 // We have found the corresponding interface for this struct. 395 // We have found the corresponding interface for this struct.
394 // That lets us know where this struct should be stored 396 // That lets us know where this struct should be stored
395 // when we encounter it during unmarshaling. 397 // when we encounter it during unmarshaling.
396 unmarshal := makeUnmarshalOneof(typ, of.ityp, baseUnmarshal) 398 unmarshal := makeUnmarshalOneof(typ, of.ityp, baseUnmarshal)
397 u.setTag(fieldNum, of.field, unmarshal, 0, name) 399 u.setTag(fieldNum, of.field, unmarshal, 0, name)
398 }
399 } 400 }
400 } 401 }
402
401 } 403 }
402 404
403 // Get extension ranges, if any. 405 // Get extension ranges, if any.
404 fn = reflect.Zero(reflect.PtrTo(t)).MethodByName("ExtensionRangeArray") 406 fn := reflect.Zero(reflect.PtrTo(t)).MethodByName("ExtensionRangeArray")
405 if fn.IsValid() { 407 if fn.IsValid() {
406 if !u.extensions.IsValid() && !u.oldExtensions.IsValid() { 408 if !u.extensions.IsValid() && !u.oldExtensions.IsValid() {
407 panic("a message with extensions, but no extensions field in " + t.Name()) 409 panic("a message with extensions, but no extensions field in " + t.Name())
@@ -1948,7 +1950,7 @@ func encodeVarint(b []byte, x uint64) []byte {
1948// If there is an error, it returns 0,0. 1950// If there is an error, it returns 0,0.
1949func decodeVarint(b []byte) (uint64, int) { 1951func decodeVarint(b []byte) (uint64, int) {
1950 var x, y uint64 1952 var x, y uint64
1951 if len(b) <= 0 { 1953 if len(b) == 0 {
1952 goto bad 1954 goto bad
1953 } 1955 }
1954 x = uint64(b[0]) 1956 x = uint64(b[0])
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go
new file mode 100644
index 0000000..1ded05b
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go
@@ -0,0 +1,2887 @@
1// Code generated by protoc-gen-go. DO NOT EDIT.
2// source: google/protobuf/descriptor.proto
3
4package descriptor
5
6import (
7 fmt "fmt"
8 proto "github.com/golang/protobuf/proto"
9 math "math"
10)
11
12// Reference imports to suppress errors if they are not otherwise used.
13var _ = proto.Marshal
14var _ = fmt.Errorf
15var _ = math.Inf
16
17// This is a compile-time assertion to ensure that this generated file
18// is compatible with the proto package it is being compiled against.
19// A compilation error at this line likely means your copy of the
20// proto package needs to be updated.
21const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
22
23type FieldDescriptorProto_Type int32
24
25const (
26 // 0 is reserved for errors.
27 // Order is weird for historical reasons.
28 FieldDescriptorProto_TYPE_DOUBLE FieldDescriptorProto_Type = 1
29 FieldDescriptorProto_TYPE_FLOAT FieldDescriptorProto_Type = 2
30 // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if
31 // negative values are likely.
32 FieldDescriptorProto_TYPE_INT64 FieldDescriptorProto_Type = 3
33 FieldDescriptorProto_TYPE_UINT64 FieldDescriptorProto_Type = 4
34 // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if
35 // negative values are likely.
36 FieldDescriptorProto_TYPE_INT32 FieldDescriptorProto_Type = 5
37 FieldDescriptorProto_TYPE_FIXED64 FieldDescriptorProto_Type = 6
38 FieldDescriptorProto_TYPE_FIXED32 FieldDescriptorProto_Type = 7
39 FieldDescriptorProto_TYPE_BOOL FieldDescriptorProto_Type = 8
40 FieldDescriptorProto_TYPE_STRING FieldDescriptorProto_Type = 9
41 // Tag-delimited aggregate.
42 // Group type is deprecated and not supported in proto3. However, Proto3
43 // implementations should still be able to parse the group wire format and
44 // treat group fields as unknown fields.
45 FieldDescriptorProto_TYPE_GROUP FieldDescriptorProto_Type = 10
46 FieldDescriptorProto_TYPE_MESSAGE FieldDescriptorProto_Type = 11
47 // New in version 2.
48 FieldDescriptorProto_TYPE_BYTES FieldDescriptorProto_Type = 12
49 FieldDescriptorProto_TYPE_UINT32 FieldDescriptorProto_Type = 13
50 FieldDescriptorProto_TYPE_ENUM FieldDescriptorProto_Type = 14
51 FieldDescriptorProto_TYPE_SFIXED32 FieldDescriptorProto_Type = 15
52 FieldDescriptorProto_TYPE_SFIXED64 FieldDescriptorProto_Type = 16
53 FieldDescriptorProto_TYPE_SINT32 FieldDescriptorProto_Type = 17
54 FieldDescriptorProto_TYPE_SINT64 FieldDescriptorProto_Type = 18
55)
56
57var FieldDescriptorProto_Type_name = map[int32]string{
58 1: "TYPE_DOUBLE",
59 2: "TYPE_FLOAT",
60 3: "TYPE_INT64",
61 4: "TYPE_UINT64",
62 5: "TYPE_INT32",
63 6: "TYPE_FIXED64",
64 7: "TYPE_FIXED32",
65 8: "TYPE_BOOL",
66 9: "TYPE_STRING",
67 10: "TYPE_GROUP",
68 11: "TYPE_MESSAGE",
69 12: "TYPE_BYTES",
70 13: "TYPE_UINT32",
71 14: "TYPE_ENUM",
72 15: "TYPE_SFIXED32",
73 16: "TYPE_SFIXED64",
74 17: "TYPE_SINT32",
75 18: "TYPE_SINT64",
76}
77
78var FieldDescriptorProto_Type_value = map[string]int32{
79 "TYPE_DOUBLE": 1,
80 "TYPE_FLOAT": 2,
81 "TYPE_INT64": 3,
82 "TYPE_UINT64": 4,
83 "TYPE_INT32": 5,
84 "TYPE_FIXED64": 6,
85 "TYPE_FIXED32": 7,
86 "TYPE_BOOL": 8,
87 "TYPE_STRING": 9,
88 "TYPE_GROUP": 10,
89 "TYPE_MESSAGE": 11,
90 "TYPE_BYTES": 12,
91 "TYPE_UINT32": 13,
92 "TYPE_ENUM": 14,
93 "TYPE_SFIXED32": 15,
94 "TYPE_SFIXED64": 16,
95 "TYPE_SINT32": 17,
96 "TYPE_SINT64": 18,
97}
98
99func (x FieldDescriptorProto_Type) Enum() *FieldDescriptorProto_Type {
100 p := new(FieldDescriptorProto_Type)
101 *p = x
102 return p
103}
104
105func (x FieldDescriptorProto_Type) String() string {
106 return proto.EnumName(FieldDescriptorProto_Type_name, int32(x))
107}
108
109func (x *FieldDescriptorProto_Type) UnmarshalJSON(data []byte) error {
110 value, err := proto.UnmarshalJSONEnum(FieldDescriptorProto_Type_value, data, "FieldDescriptorProto_Type")
111 if err != nil {
112 return err
113 }
114 *x = FieldDescriptorProto_Type(value)
115 return nil
116}
117
118func (FieldDescriptorProto_Type) EnumDescriptor() ([]byte, []int) {
119 return fileDescriptor_e5baabe45344a177, []int{4, 0}
120}
121
122type FieldDescriptorProto_Label int32
123
124const (
125 // 0 is reserved for errors
126 FieldDescriptorProto_LABEL_OPTIONAL FieldDescriptorProto_Label = 1
127 FieldDescriptorProto_LABEL_REQUIRED FieldDescriptorProto_Label = 2
128 FieldDescriptorProto_LABEL_REPEATED FieldDescriptorProto_Label = 3
129)
130
131var FieldDescriptorProto_Label_name = map[int32]string{
132 1: "LABEL_OPTIONAL",
133 2: "LABEL_REQUIRED",
134 3: "LABEL_REPEATED",
135}
136
137var FieldDescriptorProto_Label_value = map[string]int32{
138 "LABEL_OPTIONAL": 1,
139 "LABEL_REQUIRED": 2,
140 "LABEL_REPEATED": 3,
141}
142
143func (x FieldDescriptorProto_Label) Enum() *FieldDescriptorProto_Label {
144 p := new(FieldDescriptorProto_Label)
145 *p = x
146 return p
147}
148
149func (x FieldDescriptorProto_Label) String() string {
150 return proto.EnumName(FieldDescriptorProto_Label_name, int32(x))
151}
152
153func (x *FieldDescriptorProto_Label) UnmarshalJSON(data []byte) error {
154 value, err := proto.UnmarshalJSONEnum(FieldDescriptorProto_Label_value, data, "FieldDescriptorProto_Label")
155 if err != nil {
156 return err
157 }
158 *x = FieldDescriptorProto_Label(value)
159 return nil
160}
161
162func (FieldDescriptorProto_Label) EnumDescriptor() ([]byte, []int) {
163 return fileDescriptor_e5baabe45344a177, []int{4, 1}
164}
165
166// Generated classes can be optimized for speed or code size.
167type FileOptions_OptimizeMode int32
168
169const (
170 FileOptions_SPEED FileOptions_OptimizeMode = 1
171 // etc.
172 FileOptions_CODE_SIZE FileOptions_OptimizeMode = 2
173 FileOptions_LITE_RUNTIME FileOptions_OptimizeMode = 3
174)
175
176var FileOptions_OptimizeMode_name = map[int32]string{
177 1: "SPEED",
178 2: "CODE_SIZE",
179 3: "LITE_RUNTIME",
180}
181
182var FileOptions_OptimizeMode_value = map[string]int32{
183 "SPEED": 1,
184 "CODE_SIZE": 2,
185 "LITE_RUNTIME": 3,
186}
187
188func (x FileOptions_OptimizeMode) Enum() *FileOptions_OptimizeMode {
189 p := new(FileOptions_OptimizeMode)
190 *p = x
191 return p
192}
193
194func (x FileOptions_OptimizeMode) String() string {
195 return proto.EnumName(FileOptions_OptimizeMode_name, int32(x))
196}
197
198func (x *FileOptions_OptimizeMode) UnmarshalJSON(data []byte) error {
199 value, err := proto.UnmarshalJSONEnum(FileOptions_OptimizeMode_value, data, "FileOptions_OptimizeMode")
200 if err != nil {
201 return err
202 }
203 *x = FileOptions_OptimizeMode(value)
204 return nil
205}
206
207func (FileOptions_OptimizeMode) EnumDescriptor() ([]byte, []int) {
208 return fileDescriptor_e5baabe45344a177, []int{10, 0}
209}
210
211type FieldOptions_CType int32
212
213const (
214 // Default mode.
215 FieldOptions_STRING FieldOptions_CType = 0
216 FieldOptions_CORD FieldOptions_CType = 1
217 FieldOptions_STRING_PIECE FieldOptions_CType = 2
218)
219
220var FieldOptions_CType_name = map[int32]string{
221 0: "STRING",
222 1: "CORD",
223 2: "STRING_PIECE",
224}
225
226var FieldOptions_CType_value = map[string]int32{
227 "STRING": 0,
228 "CORD": 1,
229 "STRING_PIECE": 2,
230}
231
232func (x FieldOptions_CType) Enum() *FieldOptions_CType {
233 p := new(FieldOptions_CType)
234 *p = x
235 return p
236}
237
238func (x FieldOptions_CType) String() string {
239 return proto.EnumName(FieldOptions_CType_name, int32(x))
240}
241
242func (x *FieldOptions_CType) UnmarshalJSON(data []byte) error {
243 value, err := proto.UnmarshalJSONEnum(FieldOptions_CType_value, data, "FieldOptions_CType")
244 if err != nil {
245 return err
246 }
247 *x = FieldOptions_CType(value)
248 return nil
249}
250
251func (FieldOptions_CType) EnumDescriptor() ([]byte, []int) {
252 return fileDescriptor_e5baabe45344a177, []int{12, 0}
253}
254
255type FieldOptions_JSType int32
256
257const (
258 // Use the default type.
259 FieldOptions_JS_NORMAL FieldOptions_JSType = 0
260 // Use JavaScript strings.
261 FieldOptions_JS_STRING FieldOptions_JSType = 1
262 // Use JavaScript numbers.
263 FieldOptions_JS_NUMBER FieldOptions_JSType = 2
264)
265
266var FieldOptions_JSType_name = map[int32]string{
267 0: "JS_NORMAL",
268 1: "JS_STRING",
269 2: "JS_NUMBER",
270}
271
272var FieldOptions_JSType_value = map[string]int32{
273 "JS_NORMAL": 0,
274 "JS_STRING": 1,
275 "JS_NUMBER": 2,
276}
277
278func (x FieldOptions_JSType) Enum() *FieldOptions_JSType {
279 p := new(FieldOptions_JSType)
280 *p = x
281 return p
282}
283
284func (x FieldOptions_JSType) String() string {
285 return proto.EnumName(FieldOptions_JSType_name, int32(x))
286}
287
288func (x *FieldOptions_JSType) UnmarshalJSON(data []byte) error {
289 value, err := proto.UnmarshalJSONEnum(FieldOptions_JSType_value, data, "FieldOptions_JSType")
290 if err != nil {
291 return err
292 }
293 *x = FieldOptions_JSType(value)
294 return nil
295}
296
297func (FieldOptions_JSType) EnumDescriptor() ([]byte, []int) {
298 return fileDescriptor_e5baabe45344a177, []int{12, 1}
299}
300
301// Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
302// or neither? HTTP based RPC implementation may choose GET verb for safe
303// methods, and PUT verb for idempotent methods instead of the default POST.
304type MethodOptions_IdempotencyLevel int32
305
306const (
307 MethodOptions_IDEMPOTENCY_UNKNOWN MethodOptions_IdempotencyLevel = 0
308 MethodOptions_NO_SIDE_EFFECTS MethodOptions_IdempotencyLevel = 1
309 MethodOptions_IDEMPOTENT MethodOptions_IdempotencyLevel = 2
310)
311
312var MethodOptions_IdempotencyLevel_name = map[int32]string{
313 0: "IDEMPOTENCY_UNKNOWN",
314 1: "NO_SIDE_EFFECTS",
315 2: "IDEMPOTENT",
316}
317
318var MethodOptions_IdempotencyLevel_value = map[string]int32{
319 "IDEMPOTENCY_UNKNOWN": 0,
320 "NO_SIDE_EFFECTS": 1,
321 "IDEMPOTENT": 2,
322}
323
324func (x MethodOptions_IdempotencyLevel) Enum() *MethodOptions_IdempotencyLevel {
325 p := new(MethodOptions_IdempotencyLevel)
326 *p = x
327 return p
328}
329
330func (x MethodOptions_IdempotencyLevel) String() string {
331 return proto.EnumName(MethodOptions_IdempotencyLevel_name, int32(x))
332}
333
334func (x *MethodOptions_IdempotencyLevel) UnmarshalJSON(data []byte) error {
335 value, err := proto.UnmarshalJSONEnum(MethodOptions_IdempotencyLevel_value, data, "MethodOptions_IdempotencyLevel")
336 if err != nil {
337 return err
338 }
339 *x = MethodOptions_IdempotencyLevel(value)
340 return nil
341}
342
343func (MethodOptions_IdempotencyLevel) EnumDescriptor() ([]byte, []int) {
344 return fileDescriptor_e5baabe45344a177, []int{17, 0}
345}
346
347// The protocol compiler can output a FileDescriptorSet containing the .proto
348// files it parses.
349type FileDescriptorSet struct {
350 File []*FileDescriptorProto `protobuf:"bytes,1,rep,name=file" json:"file,omitempty"`
351 XXX_NoUnkeyedLiteral struct{} `json:"-"`
352 XXX_unrecognized []byte `json:"-"`
353 XXX_sizecache int32 `json:"-"`
354}
355
356func (m *FileDescriptorSet) Reset() { *m = FileDescriptorSet{} }
357func (m *FileDescriptorSet) String() string { return proto.CompactTextString(m) }
358func (*FileDescriptorSet) ProtoMessage() {}
359func (*FileDescriptorSet) Descriptor() ([]byte, []int) {
360 return fileDescriptor_e5baabe45344a177, []int{0}
361}
362
363func (m *FileDescriptorSet) XXX_Unmarshal(b []byte) error {
364 return xxx_messageInfo_FileDescriptorSet.Unmarshal(m, b)
365}
366func (m *FileDescriptorSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
367 return xxx_messageInfo_FileDescriptorSet.Marshal(b, m, deterministic)
368}
369func (m *FileDescriptorSet) XXX_Merge(src proto.Message) {
370 xxx_messageInfo_FileDescriptorSet.Merge(m, src)
371}
372func (m *FileDescriptorSet) XXX_Size() int {
373 return xxx_messageInfo_FileDescriptorSet.Size(m)
374}
375func (m *FileDescriptorSet) XXX_DiscardUnknown() {
376 xxx_messageInfo_FileDescriptorSet.DiscardUnknown(m)
377}
378
379var xxx_messageInfo_FileDescriptorSet proto.InternalMessageInfo
380
381func (m *FileDescriptorSet) GetFile() []*FileDescriptorProto {
382 if m != nil {
383 return m.File
384 }
385 return nil
386}
387
388// Describes a complete .proto file.
389type FileDescriptorProto struct {
390 Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
391 Package *string `protobuf:"bytes,2,opt,name=package" json:"package,omitempty"`
392 // Names of files imported by this file.
393 Dependency []string `protobuf:"bytes,3,rep,name=dependency" json:"dependency,omitempty"`
394 // Indexes of the public imported files in the dependency list above.
395 PublicDependency []int32 `protobuf:"varint,10,rep,name=public_dependency,json=publicDependency" json:"public_dependency,omitempty"`
396 // Indexes of the weak imported files in the dependency list.
397 // For Google-internal migration only. Do not use.
398 WeakDependency []int32 `protobuf:"varint,11,rep,name=weak_dependency,json=weakDependency" json:"weak_dependency,omitempty"`
399 // All top-level definitions in this file.
400 MessageType []*DescriptorProto `protobuf:"bytes,4,rep,name=message_type,json=messageType" json:"message_type,omitempty"`
401 EnumType []*EnumDescriptorProto `protobuf:"bytes,5,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"`
402 Service []*ServiceDescriptorProto `protobuf:"bytes,6,rep,name=service" json:"service,omitempty"`
403 Extension []*FieldDescriptorProto `protobuf:"bytes,7,rep,name=extension" json:"extension,omitempty"`
404 Options *FileOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"`
405 // This field contains optional information about the original source code.
406 // You may safely remove this entire field without harming runtime
407 // functionality of the descriptors -- the information is needed only by
408 // development tools.
409 SourceCodeInfo *SourceCodeInfo `protobuf:"bytes,9,opt,name=source_code_info,json=sourceCodeInfo" json:"source_code_info,omitempty"`
410 // The syntax of the proto file.
411 // The supported values are "proto2" and "proto3".
412 Syntax *string `protobuf:"bytes,12,opt,name=syntax" json:"syntax,omitempty"`
413 XXX_NoUnkeyedLiteral struct{} `json:"-"`
414 XXX_unrecognized []byte `json:"-"`
415 XXX_sizecache int32 `json:"-"`
416}
417
418func (m *FileDescriptorProto) Reset() { *m = FileDescriptorProto{} }
419func (m *FileDescriptorProto) String() string { return proto.CompactTextString(m) }
420func (*FileDescriptorProto) ProtoMessage() {}
421func (*FileDescriptorProto) Descriptor() ([]byte, []int) {
422 return fileDescriptor_e5baabe45344a177, []int{1}
423}
424
425func (m *FileDescriptorProto) XXX_Unmarshal(b []byte) error {
426 return xxx_messageInfo_FileDescriptorProto.Unmarshal(m, b)
427}
428func (m *FileDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
429 return xxx_messageInfo_FileDescriptorProto.Marshal(b, m, deterministic)
430}
431func (m *FileDescriptorProto) XXX_Merge(src proto.Message) {
432 xxx_messageInfo_FileDescriptorProto.Merge(m, src)
433}
434func (m *FileDescriptorProto) XXX_Size() int {
435 return xxx_messageInfo_FileDescriptorProto.Size(m)
436}
437func (m *FileDescriptorProto) XXX_DiscardUnknown() {
438 xxx_messageInfo_FileDescriptorProto.DiscardUnknown(m)
439}
440
441var xxx_messageInfo_FileDescriptorProto proto.InternalMessageInfo
442
443func (m *FileDescriptorProto) GetName() string {
444 if m != nil && m.Name != nil {
445 return *m.Name
446 }
447 return ""
448}
449
450func (m *FileDescriptorProto) GetPackage() string {
451 if m != nil && m.Package != nil {
452 return *m.Package
453 }
454 return ""
455}
456
457func (m *FileDescriptorProto) GetDependency() []string {
458 if m != nil {
459 return m.Dependency
460 }
461 return nil
462}
463
464func (m *FileDescriptorProto) GetPublicDependency() []int32 {
465 if m != nil {
466 return m.PublicDependency
467 }
468 return nil
469}
470
471func (m *FileDescriptorProto) GetWeakDependency() []int32 {
472 if m != nil {
473 return m.WeakDependency
474 }
475 return nil
476}
477
478func (m *FileDescriptorProto) GetMessageType() []*DescriptorProto {
479 if m != nil {
480 return m.MessageType
481 }
482 return nil
483}
484
485func (m *FileDescriptorProto) GetEnumType() []*EnumDescriptorProto {
486 if m != nil {
487 return m.EnumType
488 }
489 return nil
490}
491
492func (m *FileDescriptorProto) GetService() []*ServiceDescriptorProto {
493 if m != nil {
494 return m.Service
495 }
496 return nil
497}
498
499func (m *FileDescriptorProto) GetExtension() []*FieldDescriptorProto {
500 if m != nil {
501 return m.Extension
502 }
503 return nil
504}
505
506func (m *FileDescriptorProto) GetOptions() *FileOptions {
507 if m != nil {
508 return m.Options
509 }
510 return nil
511}
512
513func (m *FileDescriptorProto) GetSourceCodeInfo() *SourceCodeInfo {
514 if m != nil {
515 return m.SourceCodeInfo
516 }
517 return nil
518}
519
520func (m *FileDescriptorProto) GetSyntax() string {
521 if m != nil && m.Syntax != nil {
522 return *m.Syntax
523 }
524 return ""
525}
526
527// Describes a message type.
528type DescriptorProto struct {
529 Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
530 Field []*FieldDescriptorProto `protobuf:"bytes,2,rep,name=field" json:"field,omitempty"`
531 Extension []*FieldDescriptorProto `protobuf:"bytes,6,rep,name=extension" json:"extension,omitempty"`
532 NestedType []*DescriptorProto `protobuf:"bytes,3,rep,name=nested_type,json=nestedType" json:"nested_type,omitempty"`
533 EnumType []*EnumDescriptorProto `protobuf:"bytes,4,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"`
534 ExtensionRange []*DescriptorProto_ExtensionRange `protobuf:"bytes,5,rep,name=extension_range,json=extensionRange" json:"extension_range,omitempty"`
535 OneofDecl []*OneofDescriptorProto `protobuf:"bytes,8,rep,name=oneof_decl,json=oneofDecl" json:"oneof_decl,omitempty"`
536 Options *MessageOptions `protobuf:"bytes,7,opt,name=options" json:"options,omitempty"`
537 ReservedRange []*DescriptorProto_ReservedRange `protobuf:"bytes,9,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"`
538 // Reserved field names, which may not be used by fields in the same message.
539 // A given name may only be reserved once.
540 ReservedName []string `protobuf:"bytes,10,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
541 XXX_NoUnkeyedLiteral struct{} `json:"-"`
542 XXX_unrecognized []byte `json:"-"`
543 XXX_sizecache int32 `json:"-"`
544}
545
546func (m *DescriptorProto) Reset() { *m = DescriptorProto{} }
547func (m *DescriptorProto) String() string { return proto.CompactTextString(m) }
548func (*DescriptorProto) ProtoMessage() {}
549func (*DescriptorProto) Descriptor() ([]byte, []int) {
550 return fileDescriptor_e5baabe45344a177, []int{2}
551}
552
553func (m *DescriptorProto) XXX_Unmarshal(b []byte) error {
554 return xxx_messageInfo_DescriptorProto.Unmarshal(m, b)
555}
556func (m *DescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
557 return xxx_messageInfo_DescriptorProto.Marshal(b, m, deterministic)
558}
559func (m *DescriptorProto) XXX_Merge(src proto.Message) {
560 xxx_messageInfo_DescriptorProto.Merge(m, src)
561}
562func (m *DescriptorProto) XXX_Size() int {
563 return xxx_messageInfo_DescriptorProto.Size(m)
564}
565func (m *DescriptorProto) XXX_DiscardUnknown() {
566 xxx_messageInfo_DescriptorProto.DiscardUnknown(m)
567}
568
569var xxx_messageInfo_DescriptorProto proto.InternalMessageInfo
570
571func (m *DescriptorProto) GetName() string {
572 if m != nil && m.Name != nil {
573 return *m.Name
574 }
575 return ""
576}
577
578func (m *DescriptorProto) GetField() []*FieldDescriptorProto {
579 if m != nil {
580 return m.Field
581 }
582 return nil
583}
584
585func (m *DescriptorProto) GetExtension() []*FieldDescriptorProto {
586 if m != nil {
587 return m.Extension
588 }
589 return nil
590}
591
592func (m *DescriptorProto) GetNestedType() []*DescriptorProto {
593 if m != nil {
594 return m.NestedType
595 }
596 return nil
597}
598
599func (m *DescriptorProto) GetEnumType() []*EnumDescriptorProto {
600 if m != nil {
601 return m.EnumType
602 }
603 return nil
604}
605
606func (m *DescriptorProto) GetExtensionRange() []*DescriptorProto_ExtensionRange {
607 if m != nil {
608 return m.ExtensionRange
609 }
610 return nil
611}
612
613func (m *DescriptorProto) GetOneofDecl() []*OneofDescriptorProto {
614 if m != nil {
615 return m.OneofDecl
616 }
617 return nil
618}
619
620func (m *DescriptorProto) GetOptions() *MessageOptions {
621 if m != nil {
622 return m.Options
623 }
624 return nil
625}
626
627func (m *DescriptorProto) GetReservedRange() []*DescriptorProto_ReservedRange {
628 if m != nil {
629 return m.ReservedRange
630 }
631 return nil
632}
633
634func (m *DescriptorProto) GetReservedName() []string {
635 if m != nil {
636 return m.ReservedName
637 }
638 return nil
639}
640
641type DescriptorProto_ExtensionRange struct {
642 Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"`
643 End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`
644 Options *ExtensionRangeOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
645 XXX_NoUnkeyedLiteral struct{} `json:"-"`
646 XXX_unrecognized []byte `json:"-"`
647 XXX_sizecache int32 `json:"-"`
648}
649
650func (m *DescriptorProto_ExtensionRange) Reset() { *m = DescriptorProto_ExtensionRange{} }
651func (m *DescriptorProto_ExtensionRange) String() string { return proto.CompactTextString(m) }
652func (*DescriptorProto_ExtensionRange) ProtoMessage() {}
653func (*DescriptorProto_ExtensionRange) Descriptor() ([]byte, []int) {
654 return fileDescriptor_e5baabe45344a177, []int{2, 0}
655}
656
657func (m *DescriptorProto_ExtensionRange) XXX_Unmarshal(b []byte) error {
658 return xxx_messageInfo_DescriptorProto_ExtensionRange.Unmarshal(m, b)
659}
660func (m *DescriptorProto_ExtensionRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
661 return xxx_messageInfo_DescriptorProto_ExtensionRange.Marshal(b, m, deterministic)
662}
663func (m *DescriptorProto_ExtensionRange) XXX_Merge(src proto.Message) {
664 xxx_messageInfo_DescriptorProto_ExtensionRange.Merge(m, src)
665}
666func (m *DescriptorProto_ExtensionRange) XXX_Size() int {
667 return xxx_messageInfo_DescriptorProto_ExtensionRange.Size(m)
668}
669func (m *DescriptorProto_ExtensionRange) XXX_DiscardUnknown() {
670 xxx_messageInfo_DescriptorProto_ExtensionRange.DiscardUnknown(m)
671}
672
673var xxx_messageInfo_DescriptorProto_ExtensionRange proto.InternalMessageInfo
674
675func (m *DescriptorProto_ExtensionRange) GetStart() int32 {
676 if m != nil && m.Start != nil {
677 return *m.Start
678 }
679 return 0
680}
681
682func (m *DescriptorProto_ExtensionRange) GetEnd() int32 {
683 if m != nil && m.End != nil {
684 return *m.End
685 }
686 return 0
687}
688
689func (m *DescriptorProto_ExtensionRange) GetOptions() *ExtensionRangeOptions {
690 if m != nil {
691 return m.Options
692 }
693 return nil
694}
695
696// Range of reserved tag numbers. Reserved tag numbers may not be used by
697// fields or extension ranges in the same message. Reserved ranges may
698// not overlap.
699type DescriptorProto_ReservedRange struct {
700 Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"`
701 End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`
702 XXX_NoUnkeyedLiteral struct{} `json:"-"`
703 XXX_unrecognized []byte `json:"-"`
704 XXX_sizecache int32 `json:"-"`
705}
706
707func (m *DescriptorProto_ReservedRange) Reset() { *m = DescriptorProto_ReservedRange{} }
708func (m *DescriptorProto_ReservedRange) String() string { return proto.CompactTextString(m) }
709func (*DescriptorProto_ReservedRange) ProtoMessage() {}
710func (*DescriptorProto_ReservedRange) Descriptor() ([]byte, []int) {
711 return fileDescriptor_e5baabe45344a177, []int{2, 1}
712}
713
714func (m *DescriptorProto_ReservedRange) XXX_Unmarshal(b []byte) error {
715 return xxx_messageInfo_DescriptorProto_ReservedRange.Unmarshal(m, b)
716}
717func (m *DescriptorProto_ReservedRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
718 return xxx_messageInfo_DescriptorProto_ReservedRange.Marshal(b, m, deterministic)
719}
720func (m *DescriptorProto_ReservedRange) XXX_Merge(src proto.Message) {
721 xxx_messageInfo_DescriptorProto_ReservedRange.Merge(m, src)
722}
723func (m *DescriptorProto_ReservedRange) XXX_Size() int {
724 return xxx_messageInfo_DescriptorProto_ReservedRange.Size(m)
725}
726func (m *DescriptorProto_ReservedRange) XXX_DiscardUnknown() {
727 xxx_messageInfo_DescriptorProto_ReservedRange.DiscardUnknown(m)
728}
729
730var xxx_messageInfo_DescriptorProto_ReservedRange proto.InternalMessageInfo
731
732func (m *DescriptorProto_ReservedRange) GetStart() int32 {
733 if m != nil && m.Start != nil {
734 return *m.Start
735 }
736 return 0
737}
738
739func (m *DescriptorProto_ReservedRange) GetEnd() int32 {
740 if m != nil && m.End != nil {
741 return *m.End
742 }
743 return 0
744}
745
746type ExtensionRangeOptions struct {
747 // The parser stores options it doesn't recognize here. See above.
748 UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
749 XXX_NoUnkeyedLiteral struct{} `json:"-"`
750 proto.XXX_InternalExtensions `json:"-"`
751 XXX_unrecognized []byte `json:"-"`
752 XXX_sizecache int32 `json:"-"`
753}
754
755func (m *ExtensionRangeOptions) Reset() { *m = ExtensionRangeOptions{} }
756func (m *ExtensionRangeOptions) String() string { return proto.CompactTextString(m) }
757func (*ExtensionRangeOptions) ProtoMessage() {}
758func (*ExtensionRangeOptions) Descriptor() ([]byte, []int) {
759 return fileDescriptor_e5baabe45344a177, []int{3}
760}
761
762var extRange_ExtensionRangeOptions = []proto.ExtensionRange{
763 {Start: 1000, End: 536870911},
764}
765
766func (*ExtensionRangeOptions) ExtensionRangeArray() []proto.ExtensionRange {
767 return extRange_ExtensionRangeOptions
768}
769
770func (m *ExtensionRangeOptions) XXX_Unmarshal(b []byte) error {
771 return xxx_messageInfo_ExtensionRangeOptions.Unmarshal(m, b)
772}
773func (m *ExtensionRangeOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
774 return xxx_messageInfo_ExtensionRangeOptions.Marshal(b, m, deterministic)
775}
776func (m *ExtensionRangeOptions) XXX_Merge(src proto.Message) {
777 xxx_messageInfo_ExtensionRangeOptions.Merge(m, src)
778}
779func (m *ExtensionRangeOptions) XXX_Size() int {
780 return xxx_messageInfo_ExtensionRangeOptions.Size(m)
781}
782func (m *ExtensionRangeOptions) XXX_DiscardUnknown() {
783 xxx_messageInfo_ExtensionRangeOptions.DiscardUnknown(m)
784}
785
786var xxx_messageInfo_ExtensionRangeOptions proto.InternalMessageInfo
787
788func (m *ExtensionRangeOptions) GetUninterpretedOption() []*UninterpretedOption {
789 if m != nil {
790 return m.UninterpretedOption
791 }
792 return nil
793}
794
795// Describes a field within a message.
796type FieldDescriptorProto struct {
797 Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
798 Number *int32 `protobuf:"varint,3,opt,name=number" json:"number,omitempty"`
799 Label *FieldDescriptorProto_Label `protobuf:"varint,4,opt,name=label,enum=google.protobuf.FieldDescriptorProto_Label" json:"label,omitempty"`
800 // If type_name is set, this need not be set. If both this and type_name
801 // are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
802 Type *FieldDescriptorProto_Type `protobuf:"varint,5,opt,name=type,enum=google.protobuf.FieldDescriptorProto_Type" json:"type,omitempty"`
803 // For message and enum types, this is the name of the type. If the name
804 // starts with a '.', it is fully-qualified. Otherwise, C++-like scoping
805 // rules are used to find the type (i.e. first the nested types within this
806 // message are searched, then within the parent, on up to the root
807 // namespace).
808 TypeName *string `protobuf:"bytes,6,opt,name=type_name,json=typeName" json:"type_name,omitempty"`
809 // For extensions, this is the name of the type being extended. It is
810 // resolved in the same manner as type_name.
811 Extendee *string `protobuf:"bytes,2,opt,name=extendee" json:"extendee,omitempty"`
812 // For numeric types, contains the original text representation of the value.
813 // For booleans, "true" or "false".
814 // For strings, contains the default text contents (not escaped in any way).
815 // For bytes, contains the C escaped value. All bytes >= 128 are escaped.
816 // TODO(kenton): Base-64 encode?
817 DefaultValue *string `protobuf:"bytes,7,opt,name=default_value,json=defaultValue" json:"default_value,omitempty"`
818 // If set, gives the index of a oneof in the containing type's oneof_decl
819 // list. This field is a member of that oneof.
820 OneofIndex *int32 `protobuf:"varint,9,opt,name=oneof_index,json=oneofIndex" json:"oneof_index,omitempty"`
821 // JSON name of this field. The value is set by protocol compiler. If the
822 // user has set a "json_name" option on this field, that option's value
823 // will be used. Otherwise, it's deduced from the field's name by converting
824 // it to camelCase.
825 JsonName *string `protobuf:"bytes,10,opt,name=json_name,json=jsonName" json:"json_name,omitempty"`
826 Options *FieldOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"`
827 XXX_NoUnkeyedLiteral struct{} `json:"-"`
828 XXX_unrecognized []byte `json:"-"`
829 XXX_sizecache int32 `json:"-"`
830}
831
832func (m *FieldDescriptorProto) Reset() { *m = FieldDescriptorProto{} }
833func (m *FieldDescriptorProto) String() string { return proto.CompactTextString(m) }
834func (*FieldDescriptorProto) ProtoMessage() {}
835func (*FieldDescriptorProto) Descriptor() ([]byte, []int) {
836 return fileDescriptor_e5baabe45344a177, []int{4}
837}
838
839func (m *FieldDescriptorProto) XXX_Unmarshal(b []byte) error {
840 return xxx_messageInfo_FieldDescriptorProto.Unmarshal(m, b)
841}
842func (m *FieldDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
843 return xxx_messageInfo_FieldDescriptorProto.Marshal(b, m, deterministic)
844}
845func (m *FieldDescriptorProto) XXX_Merge(src proto.Message) {
846 xxx_messageInfo_FieldDescriptorProto.Merge(m, src)
847}
848func (m *FieldDescriptorProto) XXX_Size() int {
849 return xxx_messageInfo_FieldDescriptorProto.Size(m)
850}
851func (m *FieldDescriptorProto) XXX_DiscardUnknown() {
852 xxx_messageInfo_FieldDescriptorProto.DiscardUnknown(m)
853}
854
855var xxx_messageInfo_FieldDescriptorProto proto.InternalMessageInfo
856
857func (m *FieldDescriptorProto) GetName() string {
858 if m != nil && m.Name != nil {
859 return *m.Name
860 }
861 return ""
862}
863
864func (m *FieldDescriptorProto) GetNumber() int32 {
865 if m != nil && m.Number != nil {
866 return *m.Number
867 }
868 return 0
869}
870
871func (m *FieldDescriptorProto) GetLabel() FieldDescriptorProto_Label {
872 if m != nil && m.Label != nil {
873 return *m.Label
874 }
875 return FieldDescriptorProto_LABEL_OPTIONAL
876}
877
878func (m *FieldDescriptorProto) GetType() FieldDescriptorProto_Type {
879 if m != nil && m.Type != nil {
880 return *m.Type
881 }
882 return FieldDescriptorProto_TYPE_DOUBLE
883}
884
885func (m *FieldDescriptorProto) GetTypeName() string {
886 if m != nil && m.TypeName != nil {
887 return *m.TypeName
888 }
889 return ""
890}
891
892func (m *FieldDescriptorProto) GetExtendee() string {
893 if m != nil && m.Extendee != nil {
894 return *m.Extendee
895 }
896 return ""
897}
898
899func (m *FieldDescriptorProto) GetDefaultValue() string {
900 if m != nil && m.DefaultValue != nil {
901 return *m.DefaultValue
902 }
903 return ""
904}
905
906func (m *FieldDescriptorProto) GetOneofIndex() int32 {
907 if m != nil && m.OneofIndex != nil {
908 return *m.OneofIndex
909 }
910 return 0
911}
912
913func (m *FieldDescriptorProto) GetJsonName() string {
914 if m != nil && m.JsonName != nil {
915 return *m.JsonName
916 }
917 return ""
918}
919
920func (m *FieldDescriptorProto) GetOptions() *FieldOptions {
921 if m != nil {
922 return m.Options
923 }
924 return nil
925}
926
927// Describes a oneof.
928type OneofDescriptorProto struct {
929 Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
930 Options *OneofOptions `protobuf:"bytes,2,opt,name=options" json:"options,omitempty"`
931 XXX_NoUnkeyedLiteral struct{} `json:"-"`
932 XXX_unrecognized []byte `json:"-"`
933 XXX_sizecache int32 `json:"-"`
934}
935
936func (m *OneofDescriptorProto) Reset() { *m = OneofDescriptorProto{} }
937func (m *OneofDescriptorProto) String() string { return proto.CompactTextString(m) }
938func (*OneofDescriptorProto) ProtoMessage() {}
939func (*OneofDescriptorProto) Descriptor() ([]byte, []int) {
940 return fileDescriptor_e5baabe45344a177, []int{5}
941}
942
943func (m *OneofDescriptorProto) XXX_Unmarshal(b []byte) error {
944 return xxx_messageInfo_OneofDescriptorProto.Unmarshal(m, b)
945}
946func (m *OneofDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
947 return xxx_messageInfo_OneofDescriptorProto.Marshal(b, m, deterministic)
948}
949func (m *OneofDescriptorProto) XXX_Merge(src proto.Message) {
950 xxx_messageInfo_OneofDescriptorProto.Merge(m, src)
951}
952func (m *OneofDescriptorProto) XXX_Size() int {
953 return xxx_messageInfo_OneofDescriptorProto.Size(m)
954}
955func (m *OneofDescriptorProto) XXX_DiscardUnknown() {
956 xxx_messageInfo_OneofDescriptorProto.DiscardUnknown(m)
957}
958
959var xxx_messageInfo_OneofDescriptorProto proto.InternalMessageInfo
960
961func (m *OneofDescriptorProto) GetName() string {
962 if m != nil && m.Name != nil {
963 return *m.Name
964 }
965 return ""
966}
967
968func (m *OneofDescriptorProto) GetOptions() *OneofOptions {
969 if m != nil {
970 return m.Options
971 }
972 return nil
973}
974
975// Describes an enum type.
976type EnumDescriptorProto struct {
977 Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
978 Value []*EnumValueDescriptorProto `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"`
979 Options *EnumOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
980 // Range of reserved numeric values. Reserved numeric values may not be used
981 // by enum values in the same enum declaration. Reserved ranges may not
982 // overlap.
983 ReservedRange []*EnumDescriptorProto_EnumReservedRange `protobuf:"bytes,4,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"`
984 // Reserved enum value names, which may not be reused. A given name may only
985 // be reserved once.
986 ReservedName []string `protobuf:"bytes,5,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
987 XXX_NoUnkeyedLiteral struct{} `json:"-"`
988 XXX_unrecognized []byte `json:"-"`
989 XXX_sizecache int32 `json:"-"`
990}
991
992func (m *EnumDescriptorProto) Reset() { *m = EnumDescriptorProto{} }
993func (m *EnumDescriptorProto) String() string { return proto.CompactTextString(m) }
994func (*EnumDescriptorProto) ProtoMessage() {}
995func (*EnumDescriptorProto) Descriptor() ([]byte, []int) {
996 return fileDescriptor_e5baabe45344a177, []int{6}
997}
998
999func (m *EnumDescriptorProto) XXX_Unmarshal(b []byte) error {
1000 return xxx_messageInfo_EnumDescriptorProto.Unmarshal(m, b)
1001}
1002func (m *EnumDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1003 return xxx_messageInfo_EnumDescriptorProto.Marshal(b, m, deterministic)
1004}
1005func (m *EnumDescriptorProto) XXX_Merge(src proto.Message) {
1006 xxx_messageInfo_EnumDescriptorProto.Merge(m, src)
1007}
1008func (m *EnumDescriptorProto) XXX_Size() int {
1009 return xxx_messageInfo_EnumDescriptorProto.Size(m)
1010}
1011func (m *EnumDescriptorProto) XXX_DiscardUnknown() {
1012 xxx_messageInfo_EnumDescriptorProto.DiscardUnknown(m)
1013}
1014
1015var xxx_messageInfo_EnumDescriptorProto proto.InternalMessageInfo
1016
1017func (m *EnumDescriptorProto) GetName() string {
1018 if m != nil && m.Name != nil {
1019 return *m.Name
1020 }
1021 return ""
1022}
1023
1024func (m *EnumDescriptorProto) GetValue() []*EnumValueDescriptorProto {
1025 if m != nil {
1026 return m.Value
1027 }
1028 return nil
1029}
1030
1031func (m *EnumDescriptorProto) GetOptions() *EnumOptions {
1032 if m != nil {
1033 return m.Options
1034 }
1035 return nil
1036}
1037
1038func (m *EnumDescriptorProto) GetReservedRange() []*EnumDescriptorProto_EnumReservedRange {
1039 if m != nil {
1040 return m.ReservedRange
1041 }
1042 return nil
1043}
1044
1045func (m *EnumDescriptorProto) GetReservedName() []string {
1046 if m != nil {
1047 return m.ReservedName
1048 }
1049 return nil
1050}
1051
1052// Range of reserved numeric values. Reserved values may not be used by
1053// entries in the same enum. Reserved ranges may not overlap.
1054//
1055// Note that this is distinct from DescriptorProto.ReservedRange in that it
1056// is inclusive such that it can appropriately represent the entire int32
1057// domain.
1058type EnumDescriptorProto_EnumReservedRange struct {
1059 Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"`
1060 End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`
1061 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1062 XXX_unrecognized []byte `json:"-"`
1063 XXX_sizecache int32 `json:"-"`
1064}
1065
1066func (m *EnumDescriptorProto_EnumReservedRange) Reset() { *m = EnumDescriptorProto_EnumReservedRange{} }
1067func (m *EnumDescriptorProto_EnumReservedRange) String() string { return proto.CompactTextString(m) }
1068func (*EnumDescriptorProto_EnumReservedRange) ProtoMessage() {}
1069func (*EnumDescriptorProto_EnumReservedRange) Descriptor() ([]byte, []int) {
1070 return fileDescriptor_e5baabe45344a177, []int{6, 0}
1071}
1072
1073func (m *EnumDescriptorProto_EnumReservedRange) XXX_Unmarshal(b []byte) error {
1074 return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Unmarshal(m, b)
1075}
1076func (m *EnumDescriptorProto_EnumReservedRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1077 return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Marshal(b, m, deterministic)
1078}
1079func (m *EnumDescriptorProto_EnumReservedRange) XXX_Merge(src proto.Message) {
1080 xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Merge(m, src)
1081}
1082func (m *EnumDescriptorProto_EnumReservedRange) XXX_Size() int {
1083 return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Size(m)
1084}
1085func (m *EnumDescriptorProto_EnumReservedRange) XXX_DiscardUnknown() {
1086 xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.DiscardUnknown(m)
1087}
1088
1089var xxx_messageInfo_EnumDescriptorProto_EnumReservedRange proto.InternalMessageInfo
1090
1091func (m *EnumDescriptorProto_EnumReservedRange) GetStart() int32 {
1092 if m != nil && m.Start != nil {
1093 return *m.Start
1094 }
1095 return 0
1096}
1097
1098func (m *EnumDescriptorProto_EnumReservedRange) GetEnd() int32 {
1099 if m != nil && m.End != nil {
1100 return *m.End
1101 }
1102 return 0
1103}
1104
1105// Describes a value within an enum.
1106type EnumValueDescriptorProto struct {
1107 Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
1108 Number *int32 `protobuf:"varint,2,opt,name=number" json:"number,omitempty"`
1109 Options *EnumValueOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
1110 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1111 XXX_unrecognized []byte `json:"-"`
1112 XXX_sizecache int32 `json:"-"`
1113}
1114
1115func (m *EnumValueDescriptorProto) Reset() { *m = EnumValueDescriptorProto{} }
1116func (m *EnumValueDescriptorProto) String() string { return proto.CompactTextString(m) }
1117func (*EnumValueDescriptorProto) ProtoMessage() {}
1118func (*EnumValueDescriptorProto) Descriptor() ([]byte, []int) {
1119 return fileDescriptor_e5baabe45344a177, []int{7}
1120}
1121
1122func (m *EnumValueDescriptorProto) XXX_Unmarshal(b []byte) error {
1123 return xxx_messageInfo_EnumValueDescriptorProto.Unmarshal(m, b)
1124}
1125func (m *EnumValueDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1126 return xxx_messageInfo_EnumValueDescriptorProto.Marshal(b, m, deterministic)
1127}
1128func (m *EnumValueDescriptorProto) XXX_Merge(src proto.Message) {
1129 xxx_messageInfo_EnumValueDescriptorProto.Merge(m, src)
1130}
1131func (m *EnumValueDescriptorProto) XXX_Size() int {
1132 return xxx_messageInfo_EnumValueDescriptorProto.Size(m)
1133}
1134func (m *EnumValueDescriptorProto) XXX_DiscardUnknown() {
1135 xxx_messageInfo_EnumValueDescriptorProto.DiscardUnknown(m)
1136}
1137
1138var xxx_messageInfo_EnumValueDescriptorProto proto.InternalMessageInfo
1139
1140func (m *EnumValueDescriptorProto) GetName() string {
1141 if m != nil && m.Name != nil {
1142 return *m.Name
1143 }
1144 return ""
1145}
1146
1147func (m *EnumValueDescriptorProto) GetNumber() int32 {
1148 if m != nil && m.Number != nil {
1149 return *m.Number
1150 }
1151 return 0
1152}
1153
1154func (m *EnumValueDescriptorProto) GetOptions() *EnumValueOptions {
1155 if m != nil {
1156 return m.Options
1157 }
1158 return nil
1159}
1160
1161// Describes a service.
1162type ServiceDescriptorProto struct {
1163 Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
1164 Method []*MethodDescriptorProto `protobuf:"bytes,2,rep,name=method" json:"method,omitempty"`
1165 Options *ServiceOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
1166 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1167 XXX_unrecognized []byte `json:"-"`
1168 XXX_sizecache int32 `json:"-"`
1169}
1170
1171func (m *ServiceDescriptorProto) Reset() { *m = ServiceDescriptorProto{} }
1172func (m *ServiceDescriptorProto) String() string { return proto.CompactTextString(m) }
1173func (*ServiceDescriptorProto) ProtoMessage() {}
1174func (*ServiceDescriptorProto) Descriptor() ([]byte, []int) {
1175 return fileDescriptor_e5baabe45344a177, []int{8}
1176}
1177
1178func (m *ServiceDescriptorProto) XXX_Unmarshal(b []byte) error {
1179 return xxx_messageInfo_ServiceDescriptorProto.Unmarshal(m, b)
1180}
1181func (m *ServiceDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1182 return xxx_messageInfo_ServiceDescriptorProto.Marshal(b, m, deterministic)
1183}
1184func (m *ServiceDescriptorProto) XXX_Merge(src proto.Message) {
1185 xxx_messageInfo_ServiceDescriptorProto.Merge(m, src)
1186}
1187func (m *ServiceDescriptorProto) XXX_Size() int {
1188 return xxx_messageInfo_ServiceDescriptorProto.Size(m)
1189}
1190func (m *ServiceDescriptorProto) XXX_DiscardUnknown() {
1191 xxx_messageInfo_ServiceDescriptorProto.DiscardUnknown(m)
1192}
1193
1194var xxx_messageInfo_ServiceDescriptorProto proto.InternalMessageInfo
1195
1196func (m *ServiceDescriptorProto) GetName() string {
1197 if m != nil && m.Name != nil {
1198 return *m.Name
1199 }
1200 return ""
1201}
1202
1203func (m *ServiceDescriptorProto) GetMethod() []*MethodDescriptorProto {
1204 if m != nil {
1205 return m.Method
1206 }
1207 return nil
1208}
1209
1210func (m *ServiceDescriptorProto) GetOptions() *ServiceOptions {
1211 if m != nil {
1212 return m.Options
1213 }
1214 return nil
1215}
1216
1217// Describes a method of a service.
1218type MethodDescriptorProto struct {
1219 Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
1220 // Input and output type names. These are resolved in the same way as
1221 // FieldDescriptorProto.type_name, but must refer to a message type.
1222 InputType *string `protobuf:"bytes,2,opt,name=input_type,json=inputType" json:"input_type,omitempty"`
1223 OutputType *string `protobuf:"bytes,3,opt,name=output_type,json=outputType" json:"output_type,omitempty"`
1224 Options *MethodOptions `protobuf:"bytes,4,opt,name=options" json:"options,omitempty"`
1225 // Identifies if client streams multiple client messages
1226 ClientStreaming *bool `protobuf:"varint,5,opt,name=client_streaming,json=clientStreaming,def=0" json:"client_streaming,omitempty"`
1227 // Identifies if server streams multiple server messages
1228 ServerStreaming *bool `protobuf:"varint,6,opt,name=server_streaming,json=serverStreaming,def=0" json:"server_streaming,omitempty"`
1229 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1230 XXX_unrecognized []byte `json:"-"`
1231 XXX_sizecache int32 `json:"-"`
1232}
1233
1234func (m *MethodDescriptorProto) Reset() { *m = MethodDescriptorProto{} }
1235func (m *MethodDescriptorProto) String() string { return proto.CompactTextString(m) }
1236func (*MethodDescriptorProto) ProtoMessage() {}
1237func (*MethodDescriptorProto) Descriptor() ([]byte, []int) {
1238 return fileDescriptor_e5baabe45344a177, []int{9}
1239}
1240
1241func (m *MethodDescriptorProto) XXX_Unmarshal(b []byte) error {
1242 return xxx_messageInfo_MethodDescriptorProto.Unmarshal(m, b)
1243}
1244func (m *MethodDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1245 return xxx_messageInfo_MethodDescriptorProto.Marshal(b, m, deterministic)
1246}
1247func (m *MethodDescriptorProto) XXX_Merge(src proto.Message) {
1248 xxx_messageInfo_MethodDescriptorProto.Merge(m, src)
1249}
1250func (m *MethodDescriptorProto) XXX_Size() int {
1251 return xxx_messageInfo_MethodDescriptorProto.Size(m)
1252}
1253func (m *MethodDescriptorProto) XXX_DiscardUnknown() {
1254 xxx_messageInfo_MethodDescriptorProto.DiscardUnknown(m)
1255}
1256
1257var xxx_messageInfo_MethodDescriptorProto proto.InternalMessageInfo
1258
1259const Default_MethodDescriptorProto_ClientStreaming bool = false
1260const Default_MethodDescriptorProto_ServerStreaming bool = false
1261
1262func (m *MethodDescriptorProto) GetName() string {
1263 if m != nil && m.Name != nil {
1264 return *m.Name
1265 }
1266 return ""
1267}
1268
1269func (m *MethodDescriptorProto) GetInputType() string {
1270 if m != nil && m.InputType != nil {
1271 return *m.InputType
1272 }
1273 return ""
1274}
1275
1276func (m *MethodDescriptorProto) GetOutputType() string {
1277 if m != nil && m.OutputType != nil {
1278 return *m.OutputType
1279 }
1280 return ""
1281}
1282
1283func (m *MethodDescriptorProto) GetOptions() *MethodOptions {
1284 if m != nil {
1285 return m.Options
1286 }
1287 return nil
1288}
1289
1290func (m *MethodDescriptorProto) GetClientStreaming() bool {
1291 if m != nil && m.ClientStreaming != nil {
1292 return *m.ClientStreaming
1293 }
1294 return Default_MethodDescriptorProto_ClientStreaming
1295}
1296
1297func (m *MethodDescriptorProto) GetServerStreaming() bool {
1298 if m != nil && m.ServerStreaming != nil {
1299 return *m.ServerStreaming
1300 }
1301 return Default_MethodDescriptorProto_ServerStreaming
1302}
1303
1304type FileOptions struct {
1305 // Sets the Java package where classes generated from this .proto will be
1306 // placed. By default, the proto package is used, but this is often
1307 // inappropriate because proto packages do not normally start with backwards
1308 // domain names.
1309 JavaPackage *string `protobuf:"bytes,1,opt,name=java_package,json=javaPackage" json:"java_package,omitempty"`
1310 // If set, all the classes from the .proto file are wrapped in a single
1311 // outer class with the given name. This applies to both Proto1
1312 // (equivalent to the old "--one_java_file" option) and Proto2 (where
1313 // a .proto always translates to a single class, but you may want to
1314 // explicitly choose the class name).
1315 JavaOuterClassname *string `protobuf:"bytes,8,opt,name=java_outer_classname,json=javaOuterClassname" json:"java_outer_classname,omitempty"`
1316 // If set true, then the Java code generator will generate a separate .java
1317 // file for each top-level message, enum, and service defined in the .proto
1318 // file. Thus, these types will *not* be nested inside the outer class
1319 // named by java_outer_classname. However, the outer class will still be
1320 // generated to contain the file's getDescriptor() method as well as any
1321 // top-level extensions defined in the file.
1322 JavaMultipleFiles *bool `protobuf:"varint,10,opt,name=java_multiple_files,json=javaMultipleFiles,def=0" json:"java_multiple_files,omitempty"`
1323 // This option does nothing.
1324 JavaGenerateEqualsAndHash *bool `protobuf:"varint,20,opt,name=java_generate_equals_and_hash,json=javaGenerateEqualsAndHash" json:"java_generate_equals_and_hash,omitempty"` // Deprecated: Do not use.
1325 // If set true, then the Java2 code generator will generate code that
1326 // throws an exception whenever an attempt is made to assign a non-UTF-8
1327 // byte sequence to a string field.
1328 // Message reflection will do the same.
1329 // However, an extension field still accepts non-UTF-8 byte sequences.
1330 // This option has no effect on when used with the lite runtime.
1331 JavaStringCheckUtf8 *bool `protobuf:"varint,27,opt,name=java_string_check_utf8,json=javaStringCheckUtf8,def=0" json:"java_string_check_utf8,omitempty"`
1332 OptimizeFor *FileOptions_OptimizeMode `protobuf:"varint,9,opt,name=optimize_for,json=optimizeFor,enum=google.protobuf.FileOptions_OptimizeMode,def=1" json:"optimize_for,omitempty"`
1333 // Sets the Go package where structs generated from this .proto will be
1334 // placed. If omitted, the Go package will be derived from the following:
1335 // - The basename of the package import path, if provided.
1336 // - Otherwise, the package statement in the .proto file, if present.
1337 // - Otherwise, the basename of the .proto file, without extension.
1338 GoPackage *string `protobuf:"bytes,11,opt,name=go_package,json=goPackage" json:"go_package,omitempty"`
1339 // Should generic services be generated in each language? "Generic" services
1340 // are not specific to any particular RPC system. They are generated by the
1341 // main code generators in each language (without additional plugins).
1342 // Generic services were the only kind of service generation supported by
1343 // early versions of google.protobuf.
1344 //
1345 // Generic services are now considered deprecated in favor of using plugins
1346 // that generate code specific to your particular RPC system. Therefore,
1347 // these default to false. Old code which depends on generic services should
1348 // explicitly set them to true.
1349 CcGenericServices *bool `protobuf:"varint,16,opt,name=cc_generic_services,json=ccGenericServices,def=0" json:"cc_generic_services,omitempty"`
1350 JavaGenericServices *bool `protobuf:"varint,17,opt,name=java_generic_services,json=javaGenericServices,def=0" json:"java_generic_services,omitempty"`
1351 PyGenericServices *bool `protobuf:"varint,18,opt,name=py_generic_services,json=pyGenericServices,def=0" json:"py_generic_services,omitempty"`
1352 PhpGenericServices *bool `protobuf:"varint,42,opt,name=php_generic_services,json=phpGenericServices,def=0" json:"php_generic_services,omitempty"`
1353 // Is this file deprecated?
1354 // Depending on the target platform, this can emit Deprecated annotations
1355 // for everything in the file, or it will be completely ignored; in the very
1356 // least, this is a formalization for deprecating files.
1357 Deprecated *bool `protobuf:"varint,23,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
1358 // Enables the use of arenas for the proto messages in this file. This applies
1359 // only to generated classes for C++.
1360 CcEnableArenas *bool `protobuf:"varint,31,opt,name=cc_enable_arenas,json=ccEnableArenas,def=0" json:"cc_enable_arenas,omitempty"`
1361 // Sets the objective c class prefix which is prepended to all objective c
1362 // generated classes from this .proto. There is no default.
1363 ObjcClassPrefix *string `protobuf:"bytes,36,opt,name=objc_class_prefix,json=objcClassPrefix" json:"objc_class_prefix,omitempty"`
1364 // Namespace for generated classes; defaults to the package.
1365 CsharpNamespace *string `protobuf:"bytes,37,opt,name=csharp_namespace,json=csharpNamespace" json:"csharp_namespace,omitempty"`
1366 // By default Swift generators will take the proto package and CamelCase it
1367 // replacing '.' with underscore and use that to prefix the types/symbols
1368 // defined. When this options is provided, they will use this value instead
1369 // to prefix the types/symbols defined.
1370 SwiftPrefix *string `protobuf:"bytes,39,opt,name=swift_prefix,json=swiftPrefix" json:"swift_prefix,omitempty"`
1371 // Sets the php class prefix which is prepended to all php generated classes
1372 // from this .proto. Default is empty.
1373 PhpClassPrefix *string `protobuf:"bytes,40,opt,name=php_class_prefix,json=phpClassPrefix" json:"php_class_prefix,omitempty"`
1374 // Use this option to change the namespace of php generated classes. Default
1375 // is empty. When this option is empty, the package name will be used for
1376 // determining the namespace.
1377 PhpNamespace *string `protobuf:"bytes,41,opt,name=php_namespace,json=phpNamespace" json:"php_namespace,omitempty"`
1378 // Use this option to change the namespace of php generated metadata classes.
1379 // Default is empty. When this option is empty, the proto file name will be used
1380 // for determining the namespace.
1381 PhpMetadataNamespace *string `protobuf:"bytes,44,opt,name=php_metadata_namespace,json=phpMetadataNamespace" json:"php_metadata_namespace,omitempty"`
1382 // Use this option to change the package of ruby generated classes. Default
1383 // is empty. When this option is not set, the package name will be used for
1384 // determining the ruby package.
1385 RubyPackage *string `protobuf:"bytes,45,opt,name=ruby_package,json=rubyPackage" json:"ruby_package,omitempty"`
1386 // The parser stores options it doesn't recognize here.
1387 // See the documentation for the "Options" section above.
1388 UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
1389 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1390 proto.XXX_InternalExtensions `json:"-"`
1391 XXX_unrecognized []byte `json:"-"`
1392 XXX_sizecache int32 `json:"-"`
1393}
1394
1395func (m *FileOptions) Reset() { *m = FileOptions{} }
1396func (m *FileOptions) String() string { return proto.CompactTextString(m) }
1397func (*FileOptions) ProtoMessage() {}
1398func (*FileOptions) Descriptor() ([]byte, []int) {
1399 return fileDescriptor_e5baabe45344a177, []int{10}
1400}
1401
1402var extRange_FileOptions = []proto.ExtensionRange{
1403 {Start: 1000, End: 536870911},
1404}
1405
1406func (*FileOptions) ExtensionRangeArray() []proto.ExtensionRange {
1407 return extRange_FileOptions
1408}
1409
1410func (m *FileOptions) XXX_Unmarshal(b []byte) error {
1411 return xxx_messageInfo_FileOptions.Unmarshal(m, b)
1412}
1413func (m *FileOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1414 return xxx_messageInfo_FileOptions.Marshal(b, m, deterministic)
1415}
1416func (m *FileOptions) XXX_Merge(src proto.Message) {
1417 xxx_messageInfo_FileOptions.Merge(m, src)
1418}
1419func (m *FileOptions) XXX_Size() int {
1420 return xxx_messageInfo_FileOptions.Size(m)
1421}
1422func (m *FileOptions) XXX_DiscardUnknown() {
1423 xxx_messageInfo_FileOptions.DiscardUnknown(m)
1424}
1425
1426var xxx_messageInfo_FileOptions proto.InternalMessageInfo
1427
1428const Default_FileOptions_JavaMultipleFiles bool = false
1429const Default_FileOptions_JavaStringCheckUtf8 bool = false
1430const Default_FileOptions_OptimizeFor FileOptions_OptimizeMode = FileOptions_SPEED
1431const Default_FileOptions_CcGenericServices bool = false
1432const Default_FileOptions_JavaGenericServices bool = false
1433const Default_FileOptions_PyGenericServices bool = false
1434const Default_FileOptions_PhpGenericServices bool = false
1435const Default_FileOptions_Deprecated bool = false
1436const Default_FileOptions_CcEnableArenas bool = false
1437
1438func (m *FileOptions) GetJavaPackage() string {
1439 if m != nil && m.JavaPackage != nil {
1440 return *m.JavaPackage
1441 }
1442 return ""
1443}
1444
1445func (m *FileOptions) GetJavaOuterClassname() string {
1446 if m != nil && m.JavaOuterClassname != nil {
1447 return *m.JavaOuterClassname
1448 }
1449 return ""
1450}
1451
1452func (m *FileOptions) GetJavaMultipleFiles() bool {
1453 if m != nil && m.JavaMultipleFiles != nil {
1454 return *m.JavaMultipleFiles
1455 }
1456 return Default_FileOptions_JavaMultipleFiles
1457}
1458
1459// Deprecated: Do not use.
1460func (m *FileOptions) GetJavaGenerateEqualsAndHash() bool {
1461 if m != nil && m.JavaGenerateEqualsAndHash != nil {
1462 return *m.JavaGenerateEqualsAndHash
1463 }
1464 return false
1465}
1466
1467func (m *FileOptions) GetJavaStringCheckUtf8() bool {
1468 if m != nil && m.JavaStringCheckUtf8 != nil {
1469 return *m.JavaStringCheckUtf8
1470 }
1471 return Default_FileOptions_JavaStringCheckUtf8
1472}
1473
1474func (m *FileOptions) GetOptimizeFor() FileOptions_OptimizeMode {
1475 if m != nil && m.OptimizeFor != nil {
1476 return *m.OptimizeFor
1477 }
1478 return Default_FileOptions_OptimizeFor
1479}
1480
1481func (m *FileOptions) GetGoPackage() string {
1482 if m != nil && m.GoPackage != nil {
1483 return *m.GoPackage
1484 }
1485 return ""
1486}
1487
1488func (m *FileOptions) GetCcGenericServices() bool {
1489 if m != nil && m.CcGenericServices != nil {
1490 return *m.CcGenericServices
1491 }
1492 return Default_FileOptions_CcGenericServices
1493}
1494
1495func (m *FileOptions) GetJavaGenericServices() bool {
1496 if m != nil && m.JavaGenericServices != nil {
1497 return *m.JavaGenericServices
1498 }
1499 return Default_FileOptions_JavaGenericServices
1500}
1501
1502func (m *FileOptions) GetPyGenericServices() bool {
1503 if m != nil && m.PyGenericServices != nil {
1504 return *m.PyGenericServices
1505 }
1506 return Default_FileOptions_PyGenericServices
1507}
1508
1509func (m *FileOptions) GetPhpGenericServices() bool {
1510 if m != nil && m.PhpGenericServices != nil {
1511 return *m.PhpGenericServices
1512 }
1513 return Default_FileOptions_PhpGenericServices
1514}
1515
1516func (m *FileOptions) GetDeprecated() bool {
1517 if m != nil && m.Deprecated != nil {
1518 return *m.Deprecated
1519 }
1520 return Default_FileOptions_Deprecated
1521}
1522
1523func (m *FileOptions) GetCcEnableArenas() bool {
1524 if m != nil && m.CcEnableArenas != nil {
1525 return *m.CcEnableArenas
1526 }
1527 return Default_FileOptions_CcEnableArenas
1528}
1529
1530func (m *FileOptions) GetObjcClassPrefix() string {
1531 if m != nil && m.ObjcClassPrefix != nil {
1532 return *m.ObjcClassPrefix
1533 }
1534 return ""
1535}
1536
1537func (m *FileOptions) GetCsharpNamespace() string {
1538 if m != nil && m.CsharpNamespace != nil {
1539 return *m.CsharpNamespace
1540 }
1541 return ""
1542}
1543
1544func (m *FileOptions) GetSwiftPrefix() string {
1545 if m != nil && m.SwiftPrefix != nil {
1546 return *m.SwiftPrefix
1547 }
1548 return ""
1549}
1550
1551func (m *FileOptions) GetPhpClassPrefix() string {
1552 if m != nil && m.PhpClassPrefix != nil {
1553 return *m.PhpClassPrefix
1554 }
1555 return ""
1556}
1557
1558func (m *FileOptions) GetPhpNamespace() string {
1559 if m != nil && m.PhpNamespace != nil {
1560 return *m.PhpNamespace
1561 }
1562 return ""
1563}
1564
1565func (m *FileOptions) GetPhpMetadataNamespace() string {
1566 if m != nil && m.PhpMetadataNamespace != nil {
1567 return *m.PhpMetadataNamespace
1568 }
1569 return ""
1570}
1571
1572func (m *FileOptions) GetRubyPackage() string {
1573 if m != nil && m.RubyPackage != nil {
1574 return *m.RubyPackage
1575 }
1576 return ""
1577}
1578
1579func (m *FileOptions) GetUninterpretedOption() []*UninterpretedOption {
1580 if m != nil {
1581 return m.UninterpretedOption
1582 }
1583 return nil
1584}
1585
1586type MessageOptions struct {
1587 // Set true to use the old proto1 MessageSet wire format for extensions.
1588 // This is provided for backwards-compatibility with the MessageSet wire
1589 // format. You should not use this for any other reason: It's less
1590 // efficient, has fewer features, and is more complicated.
1591 //
1592 // The message must be defined exactly as follows:
1593 // message Foo {
1594 // option message_set_wire_format = true;
1595 // extensions 4 to max;
1596 // }
1597 // Note that the message cannot have any defined fields; MessageSets only
1598 // have extensions.
1599 //
1600 // All extensions of your type must be singular messages; e.g. they cannot
1601 // be int32s, enums, or repeated messages.
1602 //
1603 // Because this is an option, the above two restrictions are not enforced by
1604 // the protocol compiler.
1605 MessageSetWireFormat *bool `protobuf:"varint,1,opt,name=message_set_wire_format,json=messageSetWireFormat,def=0" json:"message_set_wire_format,omitempty"`
1606 // Disables the generation of the standard "descriptor()" accessor, which can
1607 // conflict with a field of the same name. This is meant to make migration
1608 // from proto1 easier; new code should avoid fields named "descriptor".
1609 NoStandardDescriptorAccessor *bool `protobuf:"varint,2,opt,name=no_standard_descriptor_accessor,json=noStandardDescriptorAccessor,def=0" json:"no_standard_descriptor_accessor,omitempty"`
1610 // Is this message deprecated?
1611 // Depending on the target platform, this can emit Deprecated annotations
1612 // for the message, or it will be completely ignored; in the very least,
1613 // this is a formalization for deprecating messages.
1614 Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
1615 // Whether the message is an automatically generated map entry type for the
1616 // maps field.
1617 //
1618 // For maps fields:
1619 // map<KeyType, ValueType> map_field = 1;
1620 // The parsed descriptor looks like:
1621 // message MapFieldEntry {
1622 // option map_entry = true;
1623 // optional KeyType key = 1;
1624 // optional ValueType value = 2;
1625 // }
1626 // repeated MapFieldEntry map_field = 1;
1627 //
1628 // Implementations may choose not to generate the map_entry=true message, but
1629 // use a native map in the target language to hold the keys and values.
1630 // The reflection APIs in such implementions still need to work as
1631 // if the field is a repeated message field.
1632 //
1633 // NOTE: Do not set the option in .proto files. Always use the maps syntax
1634 // instead. The option should only be implicitly set by the proto compiler
1635 // parser.
1636 MapEntry *bool `protobuf:"varint,7,opt,name=map_entry,json=mapEntry" json:"map_entry,omitempty"`
1637 // The parser stores options it doesn't recognize here. See above.
1638 UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
1639 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1640 proto.XXX_InternalExtensions `json:"-"`
1641 XXX_unrecognized []byte `json:"-"`
1642 XXX_sizecache int32 `json:"-"`
1643}
1644
1645func (m *MessageOptions) Reset() { *m = MessageOptions{} }
1646func (m *MessageOptions) String() string { return proto.CompactTextString(m) }
1647func (*MessageOptions) ProtoMessage() {}
1648func (*MessageOptions) Descriptor() ([]byte, []int) {
1649 return fileDescriptor_e5baabe45344a177, []int{11}
1650}
1651
1652var extRange_MessageOptions = []proto.ExtensionRange{
1653 {Start: 1000, End: 536870911},
1654}
1655
1656func (*MessageOptions) ExtensionRangeArray() []proto.ExtensionRange {
1657 return extRange_MessageOptions
1658}
1659
1660func (m *MessageOptions) XXX_Unmarshal(b []byte) error {
1661 return xxx_messageInfo_MessageOptions.Unmarshal(m, b)
1662}
1663func (m *MessageOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1664 return xxx_messageInfo_MessageOptions.Marshal(b, m, deterministic)
1665}
1666func (m *MessageOptions) XXX_Merge(src proto.Message) {
1667 xxx_messageInfo_MessageOptions.Merge(m, src)
1668}
1669func (m *MessageOptions) XXX_Size() int {
1670 return xxx_messageInfo_MessageOptions.Size(m)
1671}
1672func (m *MessageOptions) XXX_DiscardUnknown() {
1673 xxx_messageInfo_MessageOptions.DiscardUnknown(m)
1674}
1675
1676var xxx_messageInfo_MessageOptions proto.InternalMessageInfo
1677
1678const Default_MessageOptions_MessageSetWireFormat bool = false
1679const Default_MessageOptions_NoStandardDescriptorAccessor bool = false
1680const Default_MessageOptions_Deprecated bool = false
1681
1682func (m *MessageOptions) GetMessageSetWireFormat() bool {
1683 if m != nil && m.MessageSetWireFormat != nil {
1684 return *m.MessageSetWireFormat
1685 }
1686 return Default_MessageOptions_MessageSetWireFormat
1687}
1688
1689func (m *MessageOptions) GetNoStandardDescriptorAccessor() bool {
1690 if m != nil && m.NoStandardDescriptorAccessor != nil {
1691 return *m.NoStandardDescriptorAccessor
1692 }
1693 return Default_MessageOptions_NoStandardDescriptorAccessor
1694}
1695
1696func (m *MessageOptions) GetDeprecated() bool {
1697 if m != nil && m.Deprecated != nil {
1698 return *m.Deprecated
1699 }
1700 return Default_MessageOptions_Deprecated
1701}
1702
1703func (m *MessageOptions) GetMapEntry() bool {
1704 if m != nil && m.MapEntry != nil {
1705 return *m.MapEntry
1706 }
1707 return false
1708}
1709
1710func (m *MessageOptions) GetUninterpretedOption() []*UninterpretedOption {
1711 if m != nil {
1712 return m.UninterpretedOption
1713 }
1714 return nil
1715}
1716
1717type FieldOptions struct {
1718 // The ctype option instructs the C++ code generator to use a different
1719 // representation of the field than it normally would. See the specific
1720 // options below. This option is not yet implemented in the open source
1721 // release -- sorry, we'll try to include it in a future version!
1722 Ctype *FieldOptions_CType `protobuf:"varint,1,opt,name=ctype,enum=google.protobuf.FieldOptions_CType,def=0" json:"ctype,omitempty"`
1723 // The packed option can be enabled for repeated primitive fields to enable
1724 // a more efficient representation on the wire. Rather than repeatedly
1725 // writing the tag and type for each element, the entire array is encoded as
1726 // a single length-delimited blob. In proto3, only explicit setting it to
1727 // false will avoid using packed encoding.
1728 Packed *bool `protobuf:"varint,2,opt,name=packed" json:"packed,omitempty"`
1729 // The jstype option determines the JavaScript type used for values of the
1730 // field. The option is permitted only for 64 bit integral and fixed types
1731 // (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING
1732 // is represented as JavaScript string, which avoids loss of precision that
1733 // can happen when a large value is converted to a floating point JavaScript.
1734 // Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
1735 // use the JavaScript "number" type. The behavior of the default option
1736 // JS_NORMAL is implementation dependent.
1737 //
1738 // This option is an enum to permit additional types to be added, e.g.
1739 // goog.math.Integer.
1740 Jstype *FieldOptions_JSType `protobuf:"varint,6,opt,name=jstype,enum=google.protobuf.FieldOptions_JSType,def=0" json:"jstype,omitempty"`
1741 // Should this field be parsed lazily? Lazy applies only to message-type
1742 // fields. It means that when the outer message is initially parsed, the
1743 // inner message's contents will not be parsed but instead stored in encoded
1744 // form. The inner message will actually be parsed when it is first accessed.
1745 //
1746 // This is only a hint. Implementations are free to choose whether to use
1747 // eager or lazy parsing regardless of the value of this option. However,
1748 // setting this option true suggests that the protocol author believes that
1749 // using lazy parsing on this field is worth the additional bookkeeping
1750 // overhead typically needed to implement it.
1751 //
1752 // This option does not affect the public interface of any generated code;
1753 // all method signatures remain the same. Furthermore, thread-safety of the
1754 // interface is not affected by this option; const methods remain safe to
1755 // call from multiple threads concurrently, while non-const methods continue
1756 // to require exclusive access.
1757 //
1758 //
1759 // Note that implementations may choose not to check required fields within
1760 // a lazy sub-message. That is, calling IsInitialized() on the outer message
1761 // may return true even if the inner message has missing required fields.
1762 // This is necessary because otherwise the inner message would have to be
1763 // parsed in order to perform the check, defeating the purpose of lazy
1764 // parsing. An implementation which chooses not to check required fields
1765 // must be consistent about it. That is, for any particular sub-message, the
1766 // implementation must either *always* check its required fields, or *never*
1767 // check its required fields, regardless of whether or not the message has
1768 // been parsed.
1769 Lazy *bool `protobuf:"varint,5,opt,name=lazy,def=0" json:"lazy,omitempty"`
1770 // Is this field deprecated?
1771 // Depending on the target platform, this can emit Deprecated annotations
1772 // for accessors, or it will be completely ignored; in the very least, this
1773 // is a formalization for deprecating fields.
1774 Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
1775 // For Google-internal migration only. Do not use.
1776 Weak *bool `protobuf:"varint,10,opt,name=weak,def=0" json:"weak,omitempty"`
1777 // The parser stores options it doesn't recognize here. See above.
1778 UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
1779 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1780 proto.XXX_InternalExtensions `json:"-"`
1781 XXX_unrecognized []byte `json:"-"`
1782 XXX_sizecache int32 `json:"-"`
1783}
1784
1785func (m *FieldOptions) Reset() { *m = FieldOptions{} }
1786func (m *FieldOptions) String() string { return proto.CompactTextString(m) }
1787func (*FieldOptions) ProtoMessage() {}
1788func (*FieldOptions) Descriptor() ([]byte, []int) {
1789 return fileDescriptor_e5baabe45344a177, []int{12}
1790}
1791
1792var extRange_FieldOptions = []proto.ExtensionRange{
1793 {Start: 1000, End: 536870911},
1794}
1795
1796func (*FieldOptions) ExtensionRangeArray() []proto.ExtensionRange {
1797 return extRange_FieldOptions
1798}
1799
1800func (m *FieldOptions) XXX_Unmarshal(b []byte) error {
1801 return xxx_messageInfo_FieldOptions.Unmarshal(m, b)
1802}
1803func (m *FieldOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1804 return xxx_messageInfo_FieldOptions.Marshal(b, m, deterministic)
1805}
1806func (m *FieldOptions) XXX_Merge(src proto.Message) {
1807 xxx_messageInfo_FieldOptions.Merge(m, src)
1808}
1809func (m *FieldOptions) XXX_Size() int {
1810 return xxx_messageInfo_FieldOptions.Size(m)
1811}
1812func (m *FieldOptions) XXX_DiscardUnknown() {
1813 xxx_messageInfo_FieldOptions.DiscardUnknown(m)
1814}
1815
1816var xxx_messageInfo_FieldOptions proto.InternalMessageInfo
1817
1818const Default_FieldOptions_Ctype FieldOptions_CType = FieldOptions_STRING
1819const Default_FieldOptions_Jstype FieldOptions_JSType = FieldOptions_JS_NORMAL
1820const Default_FieldOptions_Lazy bool = false
1821const Default_FieldOptions_Deprecated bool = false
1822const Default_FieldOptions_Weak bool = false
1823
1824func (m *FieldOptions) GetCtype() FieldOptions_CType {
1825 if m != nil && m.Ctype != nil {
1826 return *m.Ctype
1827 }
1828 return Default_FieldOptions_Ctype
1829}
1830
1831func (m *FieldOptions) GetPacked() bool {
1832 if m != nil && m.Packed != nil {
1833 return *m.Packed
1834 }
1835 return false
1836}
1837
1838func (m *FieldOptions) GetJstype() FieldOptions_JSType {
1839 if m != nil && m.Jstype != nil {
1840 return *m.Jstype
1841 }
1842 return Default_FieldOptions_Jstype
1843}
1844
1845func (m *FieldOptions) GetLazy() bool {
1846 if m != nil && m.Lazy != nil {
1847 return *m.Lazy
1848 }
1849 return Default_FieldOptions_Lazy
1850}
1851
1852func (m *FieldOptions) GetDeprecated() bool {
1853 if m != nil && m.Deprecated != nil {
1854 return *m.Deprecated
1855 }
1856 return Default_FieldOptions_Deprecated
1857}
1858
1859func (m *FieldOptions) GetWeak() bool {
1860 if m != nil && m.Weak != nil {
1861 return *m.Weak
1862 }
1863 return Default_FieldOptions_Weak
1864}
1865
1866func (m *FieldOptions) GetUninterpretedOption() []*UninterpretedOption {
1867 if m != nil {
1868 return m.UninterpretedOption
1869 }
1870 return nil
1871}
1872
1873type OneofOptions struct {
1874 // The parser stores options it doesn't recognize here. See above.
1875 UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
1876 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1877 proto.XXX_InternalExtensions `json:"-"`
1878 XXX_unrecognized []byte `json:"-"`
1879 XXX_sizecache int32 `json:"-"`
1880}
1881
1882func (m *OneofOptions) Reset() { *m = OneofOptions{} }
1883func (m *OneofOptions) String() string { return proto.CompactTextString(m) }
1884func (*OneofOptions) ProtoMessage() {}
1885func (*OneofOptions) Descriptor() ([]byte, []int) {
1886 return fileDescriptor_e5baabe45344a177, []int{13}
1887}
1888
1889var extRange_OneofOptions = []proto.ExtensionRange{
1890 {Start: 1000, End: 536870911},
1891}
1892
1893func (*OneofOptions) ExtensionRangeArray() []proto.ExtensionRange {
1894 return extRange_OneofOptions
1895}
1896
1897func (m *OneofOptions) XXX_Unmarshal(b []byte) error {
1898 return xxx_messageInfo_OneofOptions.Unmarshal(m, b)
1899}
1900func (m *OneofOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1901 return xxx_messageInfo_OneofOptions.Marshal(b, m, deterministic)
1902}
1903func (m *OneofOptions) XXX_Merge(src proto.Message) {
1904 xxx_messageInfo_OneofOptions.Merge(m, src)
1905}
1906func (m *OneofOptions) XXX_Size() int {
1907 return xxx_messageInfo_OneofOptions.Size(m)
1908}
1909func (m *OneofOptions) XXX_DiscardUnknown() {
1910 xxx_messageInfo_OneofOptions.DiscardUnknown(m)
1911}
1912
1913var xxx_messageInfo_OneofOptions proto.InternalMessageInfo
1914
1915func (m *OneofOptions) GetUninterpretedOption() []*UninterpretedOption {
1916 if m != nil {
1917 return m.UninterpretedOption
1918 }
1919 return nil
1920}
1921
1922type EnumOptions struct {
1923 // Set this option to true to allow mapping different tag names to the same
1924 // value.
1925 AllowAlias *bool `protobuf:"varint,2,opt,name=allow_alias,json=allowAlias" json:"allow_alias,omitempty"`
1926 // Is this enum deprecated?
1927 // Depending on the target platform, this can emit Deprecated annotations
1928 // for the enum, or it will be completely ignored; in the very least, this
1929 // is a formalization for deprecating enums.
1930 Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
1931 // The parser stores options it doesn't recognize here. See above.
1932 UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
1933 XXX_NoUnkeyedLiteral struct{} `json:"-"`
1934 proto.XXX_InternalExtensions `json:"-"`
1935 XXX_unrecognized []byte `json:"-"`
1936 XXX_sizecache int32 `json:"-"`
1937}
1938
1939func (m *EnumOptions) Reset() { *m = EnumOptions{} }
1940func (m *EnumOptions) String() string { return proto.CompactTextString(m) }
1941func (*EnumOptions) ProtoMessage() {}
1942func (*EnumOptions) Descriptor() ([]byte, []int) {
1943 return fileDescriptor_e5baabe45344a177, []int{14}
1944}
1945
1946var extRange_EnumOptions = []proto.ExtensionRange{
1947 {Start: 1000, End: 536870911},
1948}
1949
1950func (*EnumOptions) ExtensionRangeArray() []proto.ExtensionRange {
1951 return extRange_EnumOptions
1952}
1953
1954func (m *EnumOptions) XXX_Unmarshal(b []byte) error {
1955 return xxx_messageInfo_EnumOptions.Unmarshal(m, b)
1956}
1957func (m *EnumOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
1958 return xxx_messageInfo_EnumOptions.Marshal(b, m, deterministic)
1959}
1960func (m *EnumOptions) XXX_Merge(src proto.Message) {
1961 xxx_messageInfo_EnumOptions.Merge(m, src)
1962}
1963func (m *EnumOptions) XXX_Size() int {
1964 return xxx_messageInfo_EnumOptions.Size(m)
1965}
1966func (m *EnumOptions) XXX_DiscardUnknown() {
1967 xxx_messageInfo_EnumOptions.DiscardUnknown(m)
1968}
1969
1970var xxx_messageInfo_EnumOptions proto.InternalMessageInfo
1971
1972const Default_EnumOptions_Deprecated bool = false
1973
1974func (m *EnumOptions) GetAllowAlias() bool {
1975 if m != nil && m.AllowAlias != nil {
1976 return *m.AllowAlias
1977 }
1978 return false
1979}
1980
1981func (m *EnumOptions) GetDeprecated() bool {
1982 if m != nil && m.Deprecated != nil {
1983 return *m.Deprecated
1984 }
1985 return Default_EnumOptions_Deprecated
1986}
1987
1988func (m *EnumOptions) GetUninterpretedOption() []*UninterpretedOption {
1989 if m != nil {
1990 return m.UninterpretedOption
1991 }
1992 return nil
1993}
1994
1995type EnumValueOptions struct {
1996 // Is this enum value deprecated?
1997 // Depending on the target platform, this can emit Deprecated annotations
1998 // for the enum value, or it will be completely ignored; in the very least,
1999 // this is a formalization for deprecating enum values.
2000 Deprecated *bool `protobuf:"varint,1,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
2001 // The parser stores options it doesn't recognize here. See above.
2002 UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
2003 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2004 proto.XXX_InternalExtensions `json:"-"`
2005 XXX_unrecognized []byte `json:"-"`
2006 XXX_sizecache int32 `json:"-"`
2007}
2008
2009func (m *EnumValueOptions) Reset() { *m = EnumValueOptions{} }
2010func (m *EnumValueOptions) String() string { return proto.CompactTextString(m) }
2011func (*EnumValueOptions) ProtoMessage() {}
2012func (*EnumValueOptions) Descriptor() ([]byte, []int) {
2013 return fileDescriptor_e5baabe45344a177, []int{15}
2014}
2015
2016var extRange_EnumValueOptions = []proto.ExtensionRange{
2017 {Start: 1000, End: 536870911},
2018}
2019
2020func (*EnumValueOptions) ExtensionRangeArray() []proto.ExtensionRange {
2021 return extRange_EnumValueOptions
2022}
2023
2024func (m *EnumValueOptions) XXX_Unmarshal(b []byte) error {
2025 return xxx_messageInfo_EnumValueOptions.Unmarshal(m, b)
2026}
2027func (m *EnumValueOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2028 return xxx_messageInfo_EnumValueOptions.Marshal(b, m, deterministic)
2029}
2030func (m *EnumValueOptions) XXX_Merge(src proto.Message) {
2031 xxx_messageInfo_EnumValueOptions.Merge(m, src)
2032}
2033func (m *EnumValueOptions) XXX_Size() int {
2034 return xxx_messageInfo_EnumValueOptions.Size(m)
2035}
2036func (m *EnumValueOptions) XXX_DiscardUnknown() {
2037 xxx_messageInfo_EnumValueOptions.DiscardUnknown(m)
2038}
2039
2040var xxx_messageInfo_EnumValueOptions proto.InternalMessageInfo
2041
2042const Default_EnumValueOptions_Deprecated bool = false
2043
2044func (m *EnumValueOptions) GetDeprecated() bool {
2045 if m != nil && m.Deprecated != nil {
2046 return *m.Deprecated
2047 }
2048 return Default_EnumValueOptions_Deprecated
2049}
2050
2051func (m *EnumValueOptions) GetUninterpretedOption() []*UninterpretedOption {
2052 if m != nil {
2053 return m.UninterpretedOption
2054 }
2055 return nil
2056}
2057
2058type ServiceOptions struct {
2059 // Is this service deprecated?
2060 // Depending on the target platform, this can emit Deprecated annotations
2061 // for the service, or it will be completely ignored; in the very least,
2062 // this is a formalization for deprecating services.
2063 Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
2064 // The parser stores options it doesn't recognize here. See above.
2065 UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
2066 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2067 proto.XXX_InternalExtensions `json:"-"`
2068 XXX_unrecognized []byte `json:"-"`
2069 XXX_sizecache int32 `json:"-"`
2070}
2071
2072func (m *ServiceOptions) Reset() { *m = ServiceOptions{} }
2073func (m *ServiceOptions) String() string { return proto.CompactTextString(m) }
2074func (*ServiceOptions) ProtoMessage() {}
2075func (*ServiceOptions) Descriptor() ([]byte, []int) {
2076 return fileDescriptor_e5baabe45344a177, []int{16}
2077}
2078
2079var extRange_ServiceOptions = []proto.ExtensionRange{
2080 {Start: 1000, End: 536870911},
2081}
2082
2083func (*ServiceOptions) ExtensionRangeArray() []proto.ExtensionRange {
2084 return extRange_ServiceOptions
2085}
2086
2087func (m *ServiceOptions) XXX_Unmarshal(b []byte) error {
2088 return xxx_messageInfo_ServiceOptions.Unmarshal(m, b)
2089}
2090func (m *ServiceOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2091 return xxx_messageInfo_ServiceOptions.Marshal(b, m, deterministic)
2092}
2093func (m *ServiceOptions) XXX_Merge(src proto.Message) {
2094 xxx_messageInfo_ServiceOptions.Merge(m, src)
2095}
2096func (m *ServiceOptions) XXX_Size() int {
2097 return xxx_messageInfo_ServiceOptions.Size(m)
2098}
2099func (m *ServiceOptions) XXX_DiscardUnknown() {
2100 xxx_messageInfo_ServiceOptions.DiscardUnknown(m)
2101}
2102
2103var xxx_messageInfo_ServiceOptions proto.InternalMessageInfo
2104
2105const Default_ServiceOptions_Deprecated bool = false
2106
2107func (m *ServiceOptions) GetDeprecated() bool {
2108 if m != nil && m.Deprecated != nil {
2109 return *m.Deprecated
2110 }
2111 return Default_ServiceOptions_Deprecated
2112}
2113
2114func (m *ServiceOptions) GetUninterpretedOption() []*UninterpretedOption {
2115 if m != nil {
2116 return m.UninterpretedOption
2117 }
2118 return nil
2119}
2120
2121type MethodOptions struct {
2122 // Is this method deprecated?
2123 // Depending on the target platform, this can emit Deprecated annotations
2124 // for the method, or it will be completely ignored; in the very least,
2125 // this is a formalization for deprecating methods.
2126 Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
2127 IdempotencyLevel *MethodOptions_IdempotencyLevel `protobuf:"varint,34,opt,name=idempotency_level,json=idempotencyLevel,enum=google.protobuf.MethodOptions_IdempotencyLevel,def=0" json:"idempotency_level,omitempty"`
2128 // The parser stores options it doesn't recognize here. See above.
2129 UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
2130 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2131 proto.XXX_InternalExtensions `json:"-"`
2132 XXX_unrecognized []byte `json:"-"`
2133 XXX_sizecache int32 `json:"-"`
2134}
2135
2136func (m *MethodOptions) Reset() { *m = MethodOptions{} }
2137func (m *MethodOptions) String() string { return proto.CompactTextString(m) }
2138func (*MethodOptions) ProtoMessage() {}
2139func (*MethodOptions) Descriptor() ([]byte, []int) {
2140 return fileDescriptor_e5baabe45344a177, []int{17}
2141}
2142
2143var extRange_MethodOptions = []proto.ExtensionRange{
2144 {Start: 1000, End: 536870911},
2145}
2146
2147func (*MethodOptions) ExtensionRangeArray() []proto.ExtensionRange {
2148 return extRange_MethodOptions
2149}
2150
2151func (m *MethodOptions) XXX_Unmarshal(b []byte) error {
2152 return xxx_messageInfo_MethodOptions.Unmarshal(m, b)
2153}
2154func (m *MethodOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2155 return xxx_messageInfo_MethodOptions.Marshal(b, m, deterministic)
2156}
2157func (m *MethodOptions) XXX_Merge(src proto.Message) {
2158 xxx_messageInfo_MethodOptions.Merge(m, src)
2159}
2160func (m *MethodOptions) XXX_Size() int {
2161 return xxx_messageInfo_MethodOptions.Size(m)
2162}
2163func (m *MethodOptions) XXX_DiscardUnknown() {
2164 xxx_messageInfo_MethodOptions.DiscardUnknown(m)
2165}
2166
2167var xxx_messageInfo_MethodOptions proto.InternalMessageInfo
2168
2169const Default_MethodOptions_Deprecated bool = false
2170const Default_MethodOptions_IdempotencyLevel MethodOptions_IdempotencyLevel = MethodOptions_IDEMPOTENCY_UNKNOWN
2171
2172func (m *MethodOptions) GetDeprecated() bool {
2173 if m != nil && m.Deprecated != nil {
2174 return *m.Deprecated
2175 }
2176 return Default_MethodOptions_Deprecated
2177}
2178
2179func (m *MethodOptions) GetIdempotencyLevel() MethodOptions_IdempotencyLevel {
2180 if m != nil && m.IdempotencyLevel != nil {
2181 return *m.IdempotencyLevel
2182 }
2183 return Default_MethodOptions_IdempotencyLevel
2184}
2185
2186func (m *MethodOptions) GetUninterpretedOption() []*UninterpretedOption {
2187 if m != nil {
2188 return m.UninterpretedOption
2189 }
2190 return nil
2191}
2192
2193// A message representing a option the parser does not recognize. This only
2194// appears in options protos created by the compiler::Parser class.
2195// DescriptorPool resolves these when building Descriptor objects. Therefore,
2196// options protos in descriptor objects (e.g. returned by Descriptor::options(),
2197// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
2198// in them.
2199type UninterpretedOption struct {
2200 Name []*UninterpretedOption_NamePart `protobuf:"bytes,2,rep,name=name" json:"name,omitempty"`
2201 // The value of the uninterpreted option, in whatever type the tokenizer
2202 // identified it as during parsing. Exactly one of these should be set.
2203 IdentifierValue *string `protobuf:"bytes,3,opt,name=identifier_value,json=identifierValue" json:"identifier_value,omitempty"`
2204 PositiveIntValue *uint64 `protobuf:"varint,4,opt,name=positive_int_value,json=positiveIntValue" json:"positive_int_value,omitempty"`
2205 NegativeIntValue *int64 `protobuf:"varint,5,opt,name=negative_int_value,json=negativeIntValue" json:"negative_int_value,omitempty"`
2206 DoubleValue *float64 `protobuf:"fixed64,6,opt,name=double_value,json=doubleValue" json:"double_value,omitempty"`
2207 StringValue []byte `protobuf:"bytes,7,opt,name=string_value,json=stringValue" json:"string_value,omitempty"`
2208 AggregateValue *string `protobuf:"bytes,8,opt,name=aggregate_value,json=aggregateValue" json:"aggregate_value,omitempty"`
2209 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2210 XXX_unrecognized []byte `json:"-"`
2211 XXX_sizecache int32 `json:"-"`
2212}
2213
2214func (m *UninterpretedOption) Reset() { *m = UninterpretedOption{} }
2215func (m *UninterpretedOption) String() string { return proto.CompactTextString(m) }
2216func (*UninterpretedOption) ProtoMessage() {}
2217func (*UninterpretedOption) Descriptor() ([]byte, []int) {
2218 return fileDescriptor_e5baabe45344a177, []int{18}
2219}
2220
2221func (m *UninterpretedOption) XXX_Unmarshal(b []byte) error {
2222 return xxx_messageInfo_UninterpretedOption.Unmarshal(m, b)
2223}
2224func (m *UninterpretedOption) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2225 return xxx_messageInfo_UninterpretedOption.Marshal(b, m, deterministic)
2226}
2227func (m *UninterpretedOption) XXX_Merge(src proto.Message) {
2228 xxx_messageInfo_UninterpretedOption.Merge(m, src)
2229}
2230func (m *UninterpretedOption) XXX_Size() int {
2231 return xxx_messageInfo_UninterpretedOption.Size(m)
2232}
2233func (m *UninterpretedOption) XXX_DiscardUnknown() {
2234 xxx_messageInfo_UninterpretedOption.DiscardUnknown(m)
2235}
2236
2237var xxx_messageInfo_UninterpretedOption proto.InternalMessageInfo
2238
2239func (m *UninterpretedOption) GetName() []*UninterpretedOption_NamePart {
2240 if m != nil {
2241 return m.Name
2242 }
2243 return nil
2244}
2245
2246func (m *UninterpretedOption) GetIdentifierValue() string {
2247 if m != nil && m.IdentifierValue != nil {
2248 return *m.IdentifierValue
2249 }
2250 return ""
2251}
2252
2253func (m *UninterpretedOption) GetPositiveIntValue() uint64 {
2254 if m != nil && m.PositiveIntValue != nil {
2255 return *m.PositiveIntValue
2256 }
2257 return 0
2258}
2259
2260func (m *UninterpretedOption) GetNegativeIntValue() int64 {
2261 if m != nil && m.NegativeIntValue != nil {
2262 return *m.NegativeIntValue
2263 }
2264 return 0
2265}
2266
2267func (m *UninterpretedOption) GetDoubleValue() float64 {
2268 if m != nil && m.DoubleValue != nil {
2269 return *m.DoubleValue
2270 }
2271 return 0
2272}
2273
2274func (m *UninterpretedOption) GetStringValue() []byte {
2275 if m != nil {
2276 return m.StringValue
2277 }
2278 return nil
2279}
2280
2281func (m *UninterpretedOption) GetAggregateValue() string {
2282 if m != nil && m.AggregateValue != nil {
2283 return *m.AggregateValue
2284 }
2285 return ""
2286}
2287
2288// The name of the uninterpreted option. Each string represents a segment in
2289// a dot-separated name. is_extension is true iff a segment represents an
2290// extension (denoted with parentheses in options specs in .proto files).
2291// E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
2292// "foo.(bar.baz).qux".
2293type UninterpretedOption_NamePart struct {
2294 NamePart *string `protobuf:"bytes,1,req,name=name_part,json=namePart" json:"name_part,omitempty"`
2295 IsExtension *bool `protobuf:"varint,2,req,name=is_extension,json=isExtension" json:"is_extension,omitempty"`
2296 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2297 XXX_unrecognized []byte `json:"-"`
2298 XXX_sizecache int32 `json:"-"`
2299}
2300
2301func (m *UninterpretedOption_NamePart) Reset() { *m = UninterpretedOption_NamePart{} }
2302func (m *UninterpretedOption_NamePart) String() string { return proto.CompactTextString(m) }
2303func (*UninterpretedOption_NamePart) ProtoMessage() {}
2304func (*UninterpretedOption_NamePart) Descriptor() ([]byte, []int) {
2305 return fileDescriptor_e5baabe45344a177, []int{18, 0}
2306}
2307
2308func (m *UninterpretedOption_NamePart) XXX_Unmarshal(b []byte) error {
2309 return xxx_messageInfo_UninterpretedOption_NamePart.Unmarshal(m, b)
2310}
2311func (m *UninterpretedOption_NamePart) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2312 return xxx_messageInfo_UninterpretedOption_NamePart.Marshal(b, m, deterministic)
2313}
2314func (m *UninterpretedOption_NamePart) XXX_Merge(src proto.Message) {
2315 xxx_messageInfo_UninterpretedOption_NamePart.Merge(m, src)
2316}
2317func (m *UninterpretedOption_NamePart) XXX_Size() int {
2318 return xxx_messageInfo_UninterpretedOption_NamePart.Size(m)
2319}
2320func (m *UninterpretedOption_NamePart) XXX_DiscardUnknown() {
2321 xxx_messageInfo_UninterpretedOption_NamePart.DiscardUnknown(m)
2322}
2323
2324var xxx_messageInfo_UninterpretedOption_NamePart proto.InternalMessageInfo
2325
2326func (m *UninterpretedOption_NamePart) GetNamePart() string {
2327 if m != nil && m.NamePart != nil {
2328 return *m.NamePart
2329 }
2330 return ""
2331}
2332
2333func (m *UninterpretedOption_NamePart) GetIsExtension() bool {
2334 if m != nil && m.IsExtension != nil {
2335 return *m.IsExtension
2336 }
2337 return false
2338}
2339
2340// Encapsulates information about the original source file from which a
2341// FileDescriptorProto was generated.
2342type SourceCodeInfo struct {
2343 // A Location identifies a piece of source code in a .proto file which
2344 // corresponds to a particular definition. This information is intended
2345 // to be useful to IDEs, code indexers, documentation generators, and similar
2346 // tools.
2347 //
2348 // For example, say we have a file like:
2349 // message Foo {
2350 // optional string foo = 1;
2351 // }
2352 // Let's look at just the field definition:
2353 // optional string foo = 1;
2354 // ^ ^^ ^^ ^ ^^^
2355 // a bc de f ghi
2356 // We have the following locations:
2357 // span path represents
2358 // [a,i) [ 4, 0, 2, 0 ] The whole field definition.
2359 // [a,b) [ 4, 0, 2, 0, 4 ] The label (optional).
2360 // [c,d) [ 4, 0, 2, 0, 5 ] The type (string).
2361 // [e,f) [ 4, 0, 2, 0, 1 ] The name (foo).
2362 // [g,h) [ 4, 0, 2, 0, 3 ] The number (1).
2363 //
2364 // Notes:
2365 // - A location may refer to a repeated field itself (i.e. not to any
2366 // particular index within it). This is used whenever a set of elements are
2367 // logically enclosed in a single code segment. For example, an entire
2368 // extend block (possibly containing multiple extension definitions) will
2369 // have an outer location whose path refers to the "extensions" repeated
2370 // field without an index.
2371 // - Multiple locations may have the same path. This happens when a single
2372 // logical declaration is spread out across multiple places. The most
2373 // obvious example is the "extend" block again -- there may be multiple
2374 // extend blocks in the same scope, each of which will have the same path.
2375 // - A location's span is not always a subset of its parent's span. For
2376 // example, the "extendee" of an extension declaration appears at the
2377 // beginning of the "extend" block and is shared by all extensions within
2378 // the block.
2379 // - Just because a location's span is a subset of some other location's span
2380 // does not mean that it is a descendent. For example, a "group" defines
2381 // both a type and a field in a single declaration. Thus, the locations
2382 // corresponding to the type and field and their components will overlap.
2383 // - Code which tries to interpret locations should probably be designed to
2384 // ignore those that it doesn't understand, as more types of locations could
2385 // be recorded in the future.
2386 Location []*SourceCodeInfo_Location `protobuf:"bytes,1,rep,name=location" json:"location,omitempty"`
2387 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2388 XXX_unrecognized []byte `json:"-"`
2389 XXX_sizecache int32 `json:"-"`
2390}
2391
2392func (m *SourceCodeInfo) Reset() { *m = SourceCodeInfo{} }
2393func (m *SourceCodeInfo) String() string { return proto.CompactTextString(m) }
2394func (*SourceCodeInfo) ProtoMessage() {}
2395func (*SourceCodeInfo) Descriptor() ([]byte, []int) {
2396 return fileDescriptor_e5baabe45344a177, []int{19}
2397}
2398
2399func (m *SourceCodeInfo) XXX_Unmarshal(b []byte) error {
2400 return xxx_messageInfo_SourceCodeInfo.Unmarshal(m, b)
2401}
2402func (m *SourceCodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2403 return xxx_messageInfo_SourceCodeInfo.Marshal(b, m, deterministic)
2404}
2405func (m *SourceCodeInfo) XXX_Merge(src proto.Message) {
2406 xxx_messageInfo_SourceCodeInfo.Merge(m, src)
2407}
2408func (m *SourceCodeInfo) XXX_Size() int {
2409 return xxx_messageInfo_SourceCodeInfo.Size(m)
2410}
2411func (m *SourceCodeInfo) XXX_DiscardUnknown() {
2412 xxx_messageInfo_SourceCodeInfo.DiscardUnknown(m)
2413}
2414
2415var xxx_messageInfo_SourceCodeInfo proto.InternalMessageInfo
2416
2417func (m *SourceCodeInfo) GetLocation() []*SourceCodeInfo_Location {
2418 if m != nil {
2419 return m.Location
2420 }
2421 return nil
2422}
2423
2424type SourceCodeInfo_Location struct {
2425 // Identifies which part of the FileDescriptorProto was defined at this
2426 // location.
2427 //
2428 // Each element is a field number or an index. They form a path from
2429 // the root FileDescriptorProto to the place where the definition. For
2430 // example, this path:
2431 // [ 4, 3, 2, 7, 1 ]
2432 // refers to:
2433 // file.message_type(3) // 4, 3
2434 // .field(7) // 2, 7
2435 // .name() // 1
2436 // This is because FileDescriptorProto.message_type has field number 4:
2437 // repeated DescriptorProto message_type = 4;
2438 // and DescriptorProto.field has field number 2:
2439 // repeated FieldDescriptorProto field = 2;
2440 // and FieldDescriptorProto.name has field number 1:
2441 // optional string name = 1;
2442 //
2443 // Thus, the above path gives the location of a field name. If we removed
2444 // the last element:
2445 // [ 4, 3, 2, 7 ]
2446 // this path refers to the whole field declaration (from the beginning
2447 // of the label to the terminating semicolon).
2448 Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"`
2449 // Always has exactly three or four elements: start line, start column,
2450 // end line (optional, otherwise assumed same as start line), end column.
2451 // These are packed into a single field for efficiency. Note that line
2452 // and column numbers are zero-based -- typically you will want to add
2453 // 1 to each before displaying to a user.
2454 Span []int32 `protobuf:"varint,2,rep,packed,name=span" json:"span,omitempty"`
2455 // If this SourceCodeInfo represents a complete declaration, these are any
2456 // comments appearing before and after the declaration which appear to be
2457 // attached to the declaration.
2458 //
2459 // A series of line comments appearing on consecutive lines, with no other
2460 // tokens appearing on those lines, will be treated as a single comment.
2461 //
2462 // leading_detached_comments will keep paragraphs of comments that appear
2463 // before (but not connected to) the current element. Each paragraph,
2464 // separated by empty lines, will be one comment element in the repeated
2465 // field.
2466 //
2467 // Only the comment content is provided; comment markers (e.g. //) are
2468 // stripped out. For block comments, leading whitespace and an asterisk
2469 // will be stripped from the beginning of each line other than the first.
2470 // Newlines are included in the output.
2471 //
2472 // Examples:
2473 //
2474 // optional int32 foo = 1; // Comment attached to foo.
2475 // // Comment attached to bar.
2476 // optional int32 bar = 2;
2477 //
2478 // optional string baz = 3;
2479 // // Comment attached to baz.
2480 // // Another line attached to baz.
2481 //
2482 // // Comment attached to qux.
2483 // //
2484 // // Another line attached to qux.
2485 // optional double qux = 4;
2486 //
2487 // // Detached comment for corge. This is not leading or trailing comments
2488 // // to qux or corge because there are blank lines separating it from
2489 // // both.
2490 //
2491 // // Detached comment for corge paragraph 2.
2492 //
2493 // optional string corge = 5;
2494 // /* Block comment attached
2495 // * to corge. Leading asterisks
2496 // * will be removed. */
2497 // /* Block comment attached to
2498 // * grault. */
2499 // optional int32 grault = 6;
2500 //
2501 // // ignored detached comments.
2502 LeadingComments *string `protobuf:"bytes,3,opt,name=leading_comments,json=leadingComments" json:"leading_comments,omitempty"`
2503 TrailingComments *string `protobuf:"bytes,4,opt,name=trailing_comments,json=trailingComments" json:"trailing_comments,omitempty"`
2504 LeadingDetachedComments []string `protobuf:"bytes,6,rep,name=leading_detached_comments,json=leadingDetachedComments" json:"leading_detached_comments,omitempty"`
2505 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2506 XXX_unrecognized []byte `json:"-"`
2507 XXX_sizecache int32 `json:"-"`
2508}
2509
2510func (m *SourceCodeInfo_Location) Reset() { *m = SourceCodeInfo_Location{} }
2511func (m *SourceCodeInfo_Location) String() string { return proto.CompactTextString(m) }
2512func (*SourceCodeInfo_Location) ProtoMessage() {}
2513func (*SourceCodeInfo_Location) Descriptor() ([]byte, []int) {
2514 return fileDescriptor_e5baabe45344a177, []int{19, 0}
2515}
2516
2517func (m *SourceCodeInfo_Location) XXX_Unmarshal(b []byte) error {
2518 return xxx_messageInfo_SourceCodeInfo_Location.Unmarshal(m, b)
2519}
2520func (m *SourceCodeInfo_Location) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2521 return xxx_messageInfo_SourceCodeInfo_Location.Marshal(b, m, deterministic)
2522}
2523func (m *SourceCodeInfo_Location) XXX_Merge(src proto.Message) {
2524 xxx_messageInfo_SourceCodeInfo_Location.Merge(m, src)
2525}
2526func (m *SourceCodeInfo_Location) XXX_Size() int {
2527 return xxx_messageInfo_SourceCodeInfo_Location.Size(m)
2528}
2529func (m *SourceCodeInfo_Location) XXX_DiscardUnknown() {
2530 xxx_messageInfo_SourceCodeInfo_Location.DiscardUnknown(m)
2531}
2532
2533var xxx_messageInfo_SourceCodeInfo_Location proto.InternalMessageInfo
2534
2535func (m *SourceCodeInfo_Location) GetPath() []int32 {
2536 if m != nil {
2537 return m.Path
2538 }
2539 return nil
2540}
2541
2542func (m *SourceCodeInfo_Location) GetSpan() []int32 {
2543 if m != nil {
2544 return m.Span
2545 }
2546 return nil
2547}
2548
2549func (m *SourceCodeInfo_Location) GetLeadingComments() string {
2550 if m != nil && m.LeadingComments != nil {
2551 return *m.LeadingComments
2552 }
2553 return ""
2554}
2555
2556func (m *SourceCodeInfo_Location) GetTrailingComments() string {
2557 if m != nil && m.TrailingComments != nil {
2558 return *m.TrailingComments
2559 }
2560 return ""
2561}
2562
2563func (m *SourceCodeInfo_Location) GetLeadingDetachedComments() []string {
2564 if m != nil {
2565 return m.LeadingDetachedComments
2566 }
2567 return nil
2568}
2569
2570// Describes the relationship between generated code and its original source
2571// file. A GeneratedCodeInfo message is associated with only one generated
2572// source file, but may contain references to different source .proto files.
2573type GeneratedCodeInfo struct {
2574 // An Annotation connects some span of text in generated code to an element
2575 // of its generating .proto file.
2576 Annotation []*GeneratedCodeInfo_Annotation `protobuf:"bytes,1,rep,name=annotation" json:"annotation,omitempty"`
2577 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2578 XXX_unrecognized []byte `json:"-"`
2579 XXX_sizecache int32 `json:"-"`
2580}
2581
2582func (m *GeneratedCodeInfo) Reset() { *m = GeneratedCodeInfo{} }
2583func (m *GeneratedCodeInfo) String() string { return proto.CompactTextString(m) }
2584func (*GeneratedCodeInfo) ProtoMessage() {}
2585func (*GeneratedCodeInfo) Descriptor() ([]byte, []int) {
2586 return fileDescriptor_e5baabe45344a177, []int{20}
2587}
2588
2589func (m *GeneratedCodeInfo) XXX_Unmarshal(b []byte) error {
2590 return xxx_messageInfo_GeneratedCodeInfo.Unmarshal(m, b)
2591}
2592func (m *GeneratedCodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2593 return xxx_messageInfo_GeneratedCodeInfo.Marshal(b, m, deterministic)
2594}
2595func (m *GeneratedCodeInfo) XXX_Merge(src proto.Message) {
2596 xxx_messageInfo_GeneratedCodeInfo.Merge(m, src)
2597}
2598func (m *GeneratedCodeInfo) XXX_Size() int {
2599 return xxx_messageInfo_GeneratedCodeInfo.Size(m)
2600}
2601func (m *GeneratedCodeInfo) XXX_DiscardUnknown() {
2602 xxx_messageInfo_GeneratedCodeInfo.DiscardUnknown(m)
2603}
2604
2605var xxx_messageInfo_GeneratedCodeInfo proto.InternalMessageInfo
2606
2607func (m *GeneratedCodeInfo) GetAnnotation() []*GeneratedCodeInfo_Annotation {
2608 if m != nil {
2609 return m.Annotation
2610 }
2611 return nil
2612}
2613
2614type GeneratedCodeInfo_Annotation struct {
2615 // Identifies the element in the original source .proto file. This field
2616 // is formatted the same as SourceCodeInfo.Location.path.
2617 Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"`
2618 // Identifies the filesystem path to the original source .proto.
2619 SourceFile *string `protobuf:"bytes,2,opt,name=source_file,json=sourceFile" json:"source_file,omitempty"`
2620 // Identifies the starting offset in bytes in the generated code
2621 // that relates to the identified object.
2622 Begin *int32 `protobuf:"varint,3,opt,name=begin" json:"begin,omitempty"`
2623 // Identifies the ending offset in bytes in the generated code that
2624 // relates to the identified offset. The end offset should be one past
2625 // the last relevant byte (so the length of the text = end - begin).
2626 End *int32 `protobuf:"varint,4,opt,name=end" json:"end,omitempty"`
2627 XXX_NoUnkeyedLiteral struct{} `json:"-"`
2628 XXX_unrecognized []byte `json:"-"`
2629 XXX_sizecache int32 `json:"-"`
2630}
2631
2632func (m *GeneratedCodeInfo_Annotation) Reset() { *m = GeneratedCodeInfo_Annotation{} }
2633func (m *GeneratedCodeInfo_Annotation) String() string { return proto.CompactTextString(m) }
2634func (*GeneratedCodeInfo_Annotation) ProtoMessage() {}
2635func (*GeneratedCodeInfo_Annotation) Descriptor() ([]byte, []int) {
2636 return fileDescriptor_e5baabe45344a177, []int{20, 0}
2637}
2638
2639func (m *GeneratedCodeInfo_Annotation) XXX_Unmarshal(b []byte) error {
2640 return xxx_messageInfo_GeneratedCodeInfo_Annotation.Unmarshal(m, b)
2641}
2642func (m *GeneratedCodeInfo_Annotation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
2643 return xxx_messageInfo_GeneratedCodeInfo_Annotation.Marshal(b, m, deterministic)
2644}
2645func (m *GeneratedCodeInfo_Annotation) XXX_Merge(src proto.Message) {
2646 xxx_messageInfo_GeneratedCodeInfo_Annotation.Merge(m, src)
2647}
2648func (m *GeneratedCodeInfo_Annotation) XXX_Size() int {
2649 return xxx_messageInfo_GeneratedCodeInfo_Annotation.Size(m)
2650}
2651func (m *GeneratedCodeInfo_Annotation) XXX_DiscardUnknown() {
2652 xxx_messageInfo_GeneratedCodeInfo_Annotation.DiscardUnknown(m)
2653}
2654
2655var xxx_messageInfo_GeneratedCodeInfo_Annotation proto.InternalMessageInfo
2656
2657func (m *GeneratedCodeInfo_Annotation) GetPath() []int32 {
2658 if m != nil {
2659 return m.Path
2660 }
2661 return nil
2662}
2663
2664func (m *GeneratedCodeInfo_Annotation) GetSourceFile() string {
2665 if m != nil && m.SourceFile != nil {
2666 return *m.SourceFile
2667 }
2668 return ""
2669}
2670
2671func (m *GeneratedCodeInfo_Annotation) GetBegin() int32 {
2672 if m != nil && m.Begin != nil {
2673 return *m.Begin
2674 }
2675 return 0
2676}
2677
2678func (m *GeneratedCodeInfo_Annotation) GetEnd() int32 {
2679 if m != nil && m.End != nil {
2680 return *m.End
2681 }
2682 return 0
2683}
2684
2685func init() {
2686 proto.RegisterEnum("google.protobuf.FieldDescriptorProto_Type", FieldDescriptorProto_Type_name, FieldDescriptorProto_Type_value)
2687 proto.RegisterEnum("google.protobuf.FieldDescriptorProto_Label", FieldDescriptorProto_Label_name, FieldDescriptorProto_Label_value)
2688 proto.RegisterEnum("google.protobuf.FileOptions_OptimizeMode", FileOptions_OptimizeMode_name, FileOptions_OptimizeMode_value)
2689 proto.RegisterEnum("google.protobuf.FieldOptions_CType", FieldOptions_CType_name, FieldOptions_CType_value)
2690 proto.RegisterEnum("google.protobuf.FieldOptions_JSType", FieldOptions_JSType_name, FieldOptions_JSType_value)
2691 proto.RegisterEnum("google.protobuf.MethodOptions_IdempotencyLevel", MethodOptions_IdempotencyLevel_name, MethodOptions_IdempotencyLevel_value)
2692 proto.RegisterType((*FileDescriptorSet)(nil), "google.protobuf.FileDescriptorSet")
2693 proto.RegisterType((*FileDescriptorProto)(nil), "google.protobuf.FileDescriptorProto")
2694 proto.RegisterType((*DescriptorProto)(nil), "google.protobuf.DescriptorProto")
2695 proto.RegisterType((*DescriptorProto_ExtensionRange)(nil), "google.protobuf.DescriptorProto.ExtensionRange")
2696 proto.RegisterType((*DescriptorProto_ReservedRange)(nil), "google.protobuf.DescriptorProto.ReservedRange")
2697 proto.RegisterType((*ExtensionRangeOptions)(nil), "google.protobuf.ExtensionRangeOptions")
2698 proto.RegisterType((*FieldDescriptorProto)(nil), "google.protobuf.FieldDescriptorProto")
2699 proto.RegisterType((*OneofDescriptorProto)(nil), "google.protobuf.OneofDescriptorProto")
2700 proto.RegisterType((*EnumDescriptorProto)(nil), "google.protobuf.EnumDescriptorProto")
2701 proto.RegisterType((*EnumDescriptorProto_EnumReservedRange)(nil), "google.protobuf.EnumDescriptorProto.EnumReservedRange")
2702 proto.RegisterType((*EnumValueDescriptorProto)(nil), "google.protobuf.EnumValueDescriptorProto")
2703 proto.RegisterType((*ServiceDescriptorProto)(nil), "google.protobuf.ServiceDescriptorProto")
2704 proto.RegisterType((*MethodDescriptorProto)(nil), "google.protobuf.MethodDescriptorProto")
2705 proto.RegisterType((*FileOptions)(nil), "google.protobuf.FileOptions")
2706 proto.RegisterType((*MessageOptions)(nil), "google.protobuf.MessageOptions")
2707 proto.RegisterType((*FieldOptions)(nil), "google.protobuf.FieldOptions")
2708 proto.RegisterType((*OneofOptions)(nil), "google.protobuf.OneofOptions")
2709 proto.RegisterType((*EnumOptions)(nil), "google.protobuf.EnumOptions")
2710 proto.RegisterType((*EnumValueOptions)(nil), "google.protobuf.EnumValueOptions")
2711 proto.RegisterType((*ServiceOptions)(nil), "google.protobuf.ServiceOptions")
2712 proto.RegisterType((*MethodOptions)(nil), "google.protobuf.MethodOptions")
2713 proto.RegisterType((*UninterpretedOption)(nil), "google.protobuf.UninterpretedOption")
2714 proto.RegisterType((*UninterpretedOption_NamePart)(nil), "google.protobuf.UninterpretedOption.NamePart")
2715 proto.RegisterType((*SourceCodeInfo)(nil), "google.protobuf.SourceCodeInfo")
2716 proto.RegisterType((*SourceCodeInfo_Location)(nil), "google.protobuf.SourceCodeInfo.Location")
2717 proto.RegisterType((*GeneratedCodeInfo)(nil), "google.protobuf.GeneratedCodeInfo")
2718 proto.RegisterType((*GeneratedCodeInfo_Annotation)(nil), "google.protobuf.GeneratedCodeInfo.Annotation")
2719}
2720
2721func init() { proto.RegisterFile("google/protobuf/descriptor.proto", fileDescriptor_e5baabe45344a177) }
2722
2723var fileDescriptor_e5baabe45344a177 = []byte{
2724 // 2589 bytes of a gzipped FileDescriptorProto
2725 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x59, 0xdd, 0x8e, 0xdb, 0xc6,
2726 0x15, 0x0e, 0xf5, 0xb7, 0xd2, 0x91, 0x56, 0x3b, 0x3b, 0xbb, 0xb1, 0xe9, 0xcd, 0x8f, 0xd7, 0xca,
2727 0x8f, 0xd7, 0x4e, 0xac, 0x0d, 0x1c, 0xdb, 0x71, 0xd6, 0x45, 0x5a, 0xad, 0x44, 0x6f, 0xe4, 0xee,
2728 0x4a, 0x2a, 0xa5, 0x6d, 0x7e, 0x80, 0x82, 0x98, 0x25, 0x47, 0x12, 0x6d, 0x8a, 0x64, 0x48, 0xca,
2729 0xf6, 0x06, 0xbd, 0x30, 0xd0, 0xab, 0x5e, 0x15, 0xe8, 0x55, 0x51, 0x14, 0xbd, 0xe8, 0x4d, 0x80,
2730 0x3e, 0x40, 0x81, 0xde, 0xf5, 0x09, 0x0a, 0xe4, 0x0d, 0x8a, 0xb6, 0x40, 0xfb, 0x08, 0xbd, 0x2c,
2731 0x66, 0x86, 0xa4, 0x48, 0x49, 0x1b, 0x6f, 0x02, 0xc4, 0xb9, 0x92, 0xe6, 0x3b, 0xdf, 0x39, 0x73,
2732 0xe6, 0xcc, 0x99, 0x99, 0x33, 0x43, 0xd8, 0x1e, 0x39, 0xce, 0xc8, 0xa2, 0xbb, 0xae, 0xe7, 0x04,
2733 0xce, 0xc9, 0x74, 0xb8, 0x6b, 0x50, 0x5f, 0xf7, 0x4c, 0x37, 0x70, 0xbc, 0x3a, 0xc7, 0xf0, 0x9a,
2734 0x60, 0xd4, 0x23, 0x46, 0xed, 0x08, 0xd6, 0xef, 0x9b, 0x16, 0x6d, 0xc5, 0xc4, 0x3e, 0x0d, 0xf0,
2735 0x5d, 0xc8, 0x0d, 0x4d, 0x8b, 0xca, 0xd2, 0x76, 0x76, 0xa7, 0x7c, 0xf3, 0xcd, 0xfa, 0x9c, 0x52,
2736 0x3d, 0xad, 0xd1, 0x63, 0xb0, 0xca, 0x35, 0x6a, 0xff, 0xce, 0xc1, 0xc6, 0x12, 0x29, 0xc6, 0x90,
2737 0xb3, 0xc9, 0x84, 0x59, 0x94, 0x76, 0x4a, 0x2a, 0xff, 0x8f, 0x65, 0x58, 0x71, 0x89, 0xfe, 0x88,
2738 0x8c, 0xa8, 0x9c, 0xe1, 0x70, 0xd4, 0xc4, 0xaf, 0x03, 0x18, 0xd4, 0xa5, 0xb6, 0x41, 0x6d, 0xfd,
2739 0x54, 0xce, 0x6e, 0x67, 0x77, 0x4a, 0x6a, 0x02, 0xc1, 0xef, 0xc0, 0xba, 0x3b, 0x3d, 0xb1, 0x4c,
2740 0x5d, 0x4b, 0xd0, 0x60, 0x3b, 0xbb, 0x93, 0x57, 0x91, 0x10, 0xb4, 0x66, 0xe4, 0xab, 0xb0, 0xf6,
2741 0x84, 0x92, 0x47, 0x49, 0x6a, 0x99, 0x53, 0xab, 0x0c, 0x4e, 0x10, 0x9b, 0x50, 0x99, 0x50, 0xdf,
2742 0x27, 0x23, 0xaa, 0x05, 0xa7, 0x2e, 0x95, 0x73, 0x7c, 0xf4, 0xdb, 0x0b, 0xa3, 0x9f, 0x1f, 0x79,
2743 0x39, 0xd4, 0x1a, 0x9c, 0xba, 0x14, 0x37, 0xa0, 0x44, 0xed, 0xe9, 0x44, 0x58, 0xc8, 0x9f, 0x11,
2744 0x3f, 0xc5, 0x9e, 0x4e, 0xe6, 0xad, 0x14, 0x99, 0x5a, 0x68, 0x62, 0xc5, 0xa7, 0xde, 0x63, 0x53,
2745 0xa7, 0x72, 0x81, 0x1b, 0xb8, 0xba, 0x60, 0xa0, 0x2f, 0xe4, 0xf3, 0x36, 0x22, 0x3d, 0xdc, 0x84,
2746 0x12, 0x7d, 0x1a, 0x50, 0xdb, 0x37, 0x1d, 0x5b, 0x5e, 0xe1, 0x46, 0xde, 0x5a, 0x32, 0x8b, 0xd4,
2747 0x32, 0xe6, 0x4d, 0xcc, 0xf4, 0xf0, 0x1d, 0x58, 0x71, 0xdc, 0xc0, 0x74, 0x6c, 0x5f, 0x2e, 0x6e,
2748 0x4b, 0x3b, 0xe5, 0x9b, 0xaf, 0x2e, 0x4d, 0x84, 0xae, 0xe0, 0xa8, 0x11, 0x19, 0xb7, 0x01, 0xf9,
2749 0xce, 0xd4, 0xd3, 0xa9, 0xa6, 0x3b, 0x06, 0xd5, 0x4c, 0x7b, 0xe8, 0xc8, 0x25, 0x6e, 0xe0, 0xf2,
2750 0xe2, 0x40, 0x38, 0xb1, 0xe9, 0x18, 0xb4, 0x6d, 0x0f, 0x1d, 0xb5, 0xea, 0xa7, 0xda, 0xf8, 0x02,
2751 0x14, 0xfc, 0x53, 0x3b, 0x20, 0x4f, 0xe5, 0x0a, 0xcf, 0x90, 0xb0, 0x55, 0xfb, 0x6b, 0x01, 0xd6,
2752 0xce, 0x93, 0x62, 0xf7, 0x20, 0x3f, 0x64, 0xa3, 0x94, 0x33, 0xdf, 0x26, 0x06, 0x42, 0x27, 0x1d,
2753 0xc4, 0xc2, 0x77, 0x0c, 0x62, 0x03, 0xca, 0x36, 0xf5, 0x03, 0x6a, 0x88, 0x8c, 0xc8, 0x9e, 0x33,
2754 0xa7, 0x40, 0x28, 0x2d, 0xa6, 0x54, 0xee, 0x3b, 0xa5, 0xd4, 0xa7, 0xb0, 0x16, 0xbb, 0xa4, 0x79,
2755 0xc4, 0x1e, 0x45, 0xb9, 0xb9, 0xfb, 0x3c, 0x4f, 0xea, 0x4a, 0xa4, 0xa7, 0x32, 0x35, 0xb5, 0x4a,
2756 0x53, 0x6d, 0xdc, 0x02, 0x70, 0x6c, 0xea, 0x0c, 0x35, 0x83, 0xea, 0x96, 0x5c, 0x3c, 0x23, 0x4a,
2757 0x5d, 0x46, 0x59, 0x88, 0x92, 0x23, 0x50, 0xdd, 0xc2, 0x1f, 0xce, 0x52, 0x6d, 0xe5, 0x8c, 0x4c,
2758 0x39, 0x12, 0x8b, 0x6c, 0x21, 0xdb, 0x8e, 0xa1, 0xea, 0x51, 0x96, 0xf7, 0xd4, 0x08, 0x47, 0x56,
2759 0xe2, 0x4e, 0xd4, 0x9f, 0x3b, 0x32, 0x35, 0x54, 0x13, 0x03, 0x5b, 0xf5, 0x92, 0x4d, 0xfc, 0x06,
2760 0xc4, 0x80, 0xc6, 0xd3, 0x0a, 0xf8, 0x2e, 0x54, 0x89, 0xc0, 0x0e, 0x99, 0xd0, 0xad, 0x2f, 0xa1,
2761 0x9a, 0x0e, 0x0f, 0xde, 0x84, 0xbc, 0x1f, 0x10, 0x2f, 0xe0, 0x59, 0x98, 0x57, 0x45, 0x03, 0x23,
2762 0xc8, 0x52, 0xdb, 0xe0, 0xbb, 0x5c, 0x5e, 0x65, 0x7f, 0xf1, 0x4f, 0x66, 0x03, 0xce, 0xf2, 0x01,
2763 0xbf, 0xbd, 0x38, 0xa3, 0x29, 0xcb, 0xf3, 0xe3, 0xde, 0xfa, 0x00, 0x56, 0x53, 0x03, 0x38, 0x6f,
2764 0xd7, 0xb5, 0x5f, 0xc2, 0xcb, 0x4b, 0x4d, 0xe3, 0x4f, 0x61, 0x73, 0x6a, 0x9b, 0x76, 0x40, 0x3d,
2765 0xd7, 0xa3, 0x2c, 0x63, 0x45, 0x57, 0xf2, 0x7f, 0x56, 0xce, 0xc8, 0xb9, 0xe3, 0x24, 0x5b, 0x58,
2766 0x51, 0x37, 0xa6, 0x8b, 0xe0, 0xf5, 0x52, 0xf1, 0xbf, 0x2b, 0xe8, 0xd9, 0xb3, 0x67, 0xcf, 0x32,
2767 0xb5, 0xdf, 0x15, 0x60, 0x73, 0xd9, 0x9a, 0x59, 0xba, 0x7c, 0x2f, 0x40, 0xc1, 0x9e, 0x4e, 0x4e,
2768 0xa8, 0xc7, 0x83, 0x94, 0x57, 0xc3, 0x16, 0x6e, 0x40, 0xde, 0x22, 0x27, 0xd4, 0x92, 0x73, 0xdb,
2769 0xd2, 0x4e, 0xf5, 0xe6, 0x3b, 0xe7, 0x5a, 0x95, 0xf5, 0x43, 0xa6, 0xa2, 0x0a, 0x4d, 0xfc, 0x11,
2770 0xe4, 0xc2, 0x2d, 0x9a, 0x59, 0xb8, 0x7e, 0x3e, 0x0b, 0x6c, 0x2d, 0xa9, 0x5c, 0x0f, 0xbf, 0x02,
2771 0x25, 0xf6, 0x2b, 0x72, 0xa3, 0xc0, 0x7d, 0x2e, 0x32, 0x80, 0xe5, 0x05, 0xde, 0x82, 0x22, 0x5f,
2772 0x26, 0x06, 0x8d, 0x8e, 0xb6, 0xb8, 0xcd, 0x12, 0xcb, 0xa0, 0x43, 0x32, 0xb5, 0x02, 0xed, 0x31,
2773 0xb1, 0xa6, 0x94, 0x27, 0x7c, 0x49, 0xad, 0x84, 0xe0, 0xcf, 0x19, 0x86, 0x2f, 0x43, 0x59, 0xac,
2774 0x2a, 0xd3, 0x36, 0xe8, 0x53, 0xbe, 0x7b, 0xe6, 0x55, 0xb1, 0xd0, 0xda, 0x0c, 0x61, 0xdd, 0x3f,
2775 0xf4, 0x1d, 0x3b, 0x4a, 0x4d, 0xde, 0x05, 0x03, 0x78, 0xf7, 0x1f, 0xcc, 0x6f, 0xdc, 0xaf, 0x2d,
2776 0x1f, 0xde, 0x7c, 0x4e, 0xd5, 0xfe, 0x92, 0x81, 0x1c, 0xdf, 0x2f, 0xd6, 0xa0, 0x3c, 0xf8, 0xac,
2777 0xa7, 0x68, 0xad, 0xee, 0xf1, 0xfe, 0xa1, 0x82, 0x24, 0x5c, 0x05, 0xe0, 0xc0, 0xfd, 0xc3, 0x6e,
2778 0x63, 0x80, 0x32, 0x71, 0xbb, 0xdd, 0x19, 0xdc, 0xb9, 0x85, 0xb2, 0xb1, 0xc2, 0xb1, 0x00, 0x72,
2779 0x49, 0xc2, 0xfb, 0x37, 0x51, 0x1e, 0x23, 0xa8, 0x08, 0x03, 0xed, 0x4f, 0x95, 0xd6, 0x9d, 0x5b,
2780 0xa8, 0x90, 0x46, 0xde, 0xbf, 0x89, 0x56, 0xf0, 0x2a, 0x94, 0x38, 0xb2, 0xdf, 0xed, 0x1e, 0xa2,
2781 0x62, 0x6c, 0xb3, 0x3f, 0x50, 0xdb, 0x9d, 0x03, 0x54, 0x8a, 0x6d, 0x1e, 0xa8, 0xdd, 0xe3, 0x1e,
2782 0x82, 0xd8, 0xc2, 0x91, 0xd2, 0xef, 0x37, 0x0e, 0x14, 0x54, 0x8e, 0x19, 0xfb, 0x9f, 0x0d, 0x94,
2783 0x3e, 0xaa, 0xa4, 0xdc, 0x7a, 0xff, 0x26, 0x5a, 0x8d, 0xbb, 0x50, 0x3a, 0xc7, 0x47, 0xa8, 0x8a,
2784 0xd7, 0x61, 0x55, 0x74, 0x11, 0x39, 0xb1, 0x36, 0x07, 0xdd, 0xb9, 0x85, 0xd0, 0xcc, 0x11, 0x61,
2785 0x65, 0x3d, 0x05, 0xdc, 0xb9, 0x85, 0x70, 0xad, 0x09, 0x79, 0x9e, 0x5d, 0x18, 0x43, 0xf5, 0xb0,
2786 0xb1, 0xaf, 0x1c, 0x6a, 0xdd, 0xde, 0xa0, 0xdd, 0xed, 0x34, 0x0e, 0x91, 0x34, 0xc3, 0x54, 0xe5,
2787 0x67, 0xc7, 0x6d, 0x55, 0x69, 0xa1, 0x4c, 0x12, 0xeb, 0x29, 0x8d, 0x81, 0xd2, 0x42, 0xd9, 0x9a,
2788 0x0e, 0x9b, 0xcb, 0xf6, 0xc9, 0xa5, 0x2b, 0x23, 0x31, 0xc5, 0x99, 0x33, 0xa6, 0x98, 0xdb, 0x5a,
2789 0x98, 0xe2, 0x7f, 0x65, 0x60, 0x63, 0xc9, 0x59, 0xb1, 0xb4, 0x93, 0x1f, 0x43, 0x5e, 0xa4, 0xa8,
2790 0x38, 0x3d, 0xaf, 0x2d, 0x3d, 0x74, 0x78, 0xc2, 0x2e, 0x9c, 0xa0, 0x5c, 0x2f, 0x59, 0x41, 0x64,
2791 0xcf, 0xa8, 0x20, 0x98, 0x89, 0x85, 0x3d, 0xfd, 0x17, 0x0b, 0x7b, 0xba, 0x38, 0xf6, 0xee, 0x9c,
2792 0xe7, 0xd8, 0xe3, 0xd8, 0xb7, 0xdb, 0xdb, 0xf3, 0x4b, 0xf6, 0xf6, 0x7b, 0xb0, 0xbe, 0x60, 0xe8,
2793 0xdc, 0x7b, 0xec, 0xaf, 0x24, 0x90, 0xcf, 0x0a, 0xce, 0x73, 0x76, 0xba, 0x4c, 0x6a, 0xa7, 0xbb,
2794 0x37, 0x1f, 0xc1, 0x2b, 0x67, 0x4f, 0xc2, 0xc2, 0x5c, 0x7f, 0x25, 0xc1, 0x85, 0xe5, 0x95, 0xe2,
2795 0x52, 0x1f, 0x3e, 0x82, 0xc2, 0x84, 0x06, 0x63, 0x27, 0xaa, 0x96, 0xde, 0x5e, 0x72, 0x06, 0x33,
2796 0xf1, 0xfc, 0x64, 0x87, 0x5a, 0xc9, 0x43, 0x3c, 0x7b, 0x56, 0xb9, 0x27, 0xbc, 0x59, 0xf0, 0xf4,
2797 0xd7, 0x19, 0x78, 0x79, 0xa9, 0xf1, 0xa5, 0x8e, 0xbe, 0x06, 0x60, 0xda, 0xee, 0x34, 0x10, 0x15,
2798 0x91, 0xd8, 0x60, 0x4b, 0x1c, 0xe1, 0x9b, 0x17, 0xdb, 0x3c, 0xa7, 0x41, 0x2c, 0xcf, 0x72, 0x39,
2799 0x08, 0x88, 0x13, 0xee, 0xce, 0x1c, 0xcd, 0x71, 0x47, 0x5f, 0x3f, 0x63, 0xa4, 0x0b, 0x89, 0xf9,
2800 0x1e, 0x20, 0xdd, 0x32, 0xa9, 0x1d, 0x68, 0x7e, 0xe0, 0x51, 0x32, 0x31, 0xed, 0x11, 0x3f, 0x41,
2801 0x8a, 0x7b, 0xf9, 0x21, 0xb1, 0x7c, 0xaa, 0xae, 0x09, 0x71, 0x3f, 0x92, 0x32, 0x0d, 0x9e, 0x40,
2802 0x5e, 0x42, 0xa3, 0x90, 0xd2, 0x10, 0xe2, 0x58, 0xa3, 0xf6, 0xdb, 0x12, 0x94, 0x13, 0x75, 0x35,
2803 0xbe, 0x02, 0x95, 0x87, 0xe4, 0x31, 0xd1, 0xa2, 0xbb, 0x92, 0x88, 0x44, 0x99, 0x61, 0xbd, 0xf0,
2804 0xbe, 0xf4, 0x1e, 0x6c, 0x72, 0x8a, 0x33, 0x0d, 0xa8, 0xa7, 0xe9, 0x16, 0xf1, 0x7d, 0x1e, 0xb4,
2805 0x22, 0xa7, 0x62, 0x26, 0xeb, 0x32, 0x51, 0x33, 0x92, 0xe0, 0xdb, 0xb0, 0xc1, 0x35, 0x26, 0x53,
2806 0x2b, 0x30, 0x5d, 0x8b, 0x6a, 0xec, 0xf6, 0xe6, 0xf3, 0x93, 0x24, 0xf6, 0x6c, 0x9d, 0x31, 0x8e,
2807 0x42, 0x02, 0xf3, 0xc8, 0xc7, 0x2d, 0x78, 0x8d, 0xab, 0x8d, 0xa8, 0x4d, 0x3d, 0x12, 0x50, 0x8d,
2808 0x7e, 0x31, 0x25, 0x96, 0xaf, 0x11, 0xdb, 0xd0, 0xc6, 0xc4, 0x1f, 0xcb, 0x9b, 0xcc, 0xc0, 0x7e,
2809 0x46, 0x96, 0xd4, 0x4b, 0x8c, 0x78, 0x10, 0xf2, 0x14, 0x4e, 0x6b, 0xd8, 0xc6, 0xc7, 0xc4, 0x1f,
2810 0xe3, 0x3d, 0xb8, 0xc0, 0xad, 0xf8, 0x81, 0x67, 0xda, 0x23, 0x4d, 0x1f, 0x53, 0xfd, 0x91, 0x36,
2811 0x0d, 0x86, 0x77, 0xe5, 0x57, 0x92, 0xfd, 0x73, 0x0f, 0xfb, 0x9c, 0xd3, 0x64, 0x94, 0xe3, 0x60,
2812 0x78, 0x17, 0xf7, 0xa1, 0xc2, 0x26, 0x63, 0x62, 0x7e, 0x49, 0xb5, 0xa1, 0xe3, 0xf1, 0xa3, 0xb1,
2813 0xba, 0x64, 0x6b, 0x4a, 0x44, 0xb0, 0xde, 0x0d, 0x15, 0x8e, 0x1c, 0x83, 0xee, 0xe5, 0xfb, 0x3d,
2814 0x45, 0x69, 0xa9, 0xe5, 0xc8, 0xca, 0x7d, 0xc7, 0x63, 0x09, 0x35, 0x72, 0xe2, 0x00, 0x97, 0x45,
2815 0x42, 0x8d, 0x9c, 0x28, 0xbc, 0xb7, 0x61, 0x43, 0xd7, 0xc5, 0x98, 0x4d, 0x5d, 0x0b, 0xef, 0x58,
2816 0xbe, 0x8c, 0x52, 0xc1, 0xd2, 0xf5, 0x03, 0x41, 0x08, 0x73, 0xdc, 0xc7, 0x1f, 0xc2, 0xcb, 0xb3,
2817 0x60, 0x25, 0x15, 0xd7, 0x17, 0x46, 0x39, 0xaf, 0x7a, 0x1b, 0x36, 0xdc, 0xd3, 0x45, 0x45, 0x9c,
2818 0xea, 0xd1, 0x3d, 0x9d, 0x57, 0xfb, 0x00, 0x36, 0xdd, 0xb1, 0xbb, 0xa8, 0x77, 0x3d, 0xa9, 0x87,
2819 0xdd, 0xb1, 0x3b, 0xaf, 0xf8, 0x16, 0xbf, 0x70, 0x7b, 0x54, 0x27, 0x01, 0x35, 0xe4, 0x8b, 0x49,
2820 0x7a, 0x42, 0x80, 0x77, 0x01, 0xe9, 0xba, 0x46, 0x6d, 0x72, 0x62, 0x51, 0x8d, 0x78, 0xd4, 0x26,
2821 0xbe, 0x7c, 0x39, 0x49, 0xae, 0xea, 0xba, 0xc2, 0xa5, 0x0d, 0x2e, 0xc4, 0xd7, 0x61, 0xdd, 0x39,
2822 0x79, 0xa8, 0x8b, 0x94, 0xd4, 0x5c, 0x8f, 0x0e, 0xcd, 0xa7, 0xf2, 0x9b, 0x3c, 0xbe, 0x6b, 0x4c,
2823 0xc0, 0x13, 0xb2, 0xc7, 0x61, 0x7c, 0x0d, 0x90, 0xee, 0x8f, 0x89, 0xe7, 0xf2, 0x3d, 0xd9, 0x77,
2824 0x89, 0x4e, 0xe5, 0xb7, 0x04, 0x55, 0xe0, 0x9d, 0x08, 0x66, 0x4b, 0xc2, 0x7f, 0x62, 0x0e, 0x83,
2825 0xc8, 0xe2, 0x55, 0xb1, 0x24, 0x38, 0x16, 0x5a, 0xdb, 0x01, 0xc4, 0x42, 0x91, 0xea, 0x78, 0x87,
2826 0xd3, 0xaa, 0xee, 0xd8, 0x4d, 0xf6, 0xfb, 0x06, 0xac, 0x32, 0xe6, 0xac, 0xd3, 0x6b, 0xa2, 0x20,
2827 0x73, 0xc7, 0x89, 0x1e, 0x6f, 0xc1, 0x05, 0x46, 0x9a, 0xd0, 0x80, 0x18, 0x24, 0x20, 0x09, 0xf6,
2828 0xbb, 0x9c, 0xcd, 0xe2, 0x7e, 0x14, 0x0a, 0x53, 0x7e, 0x7a, 0xd3, 0x93, 0xd3, 0x38, 0xb3, 0x6e,
2829 0x08, 0x3f, 0x19, 0x16, 0xe5, 0xd6, 0xf7, 0x56, 0x74, 0xd7, 0xf6, 0xa0, 0x92, 0x4c, 0x7c, 0x5c,
2830 0x02, 0x91, 0xfa, 0x48, 0x62, 0x55, 0x50, 0xb3, 0xdb, 0x62, 0xf5, 0xcb, 0xe7, 0x0a, 0xca, 0xb0,
2831 0x3a, 0xea, 0xb0, 0x3d, 0x50, 0x34, 0xf5, 0xb8, 0x33, 0x68, 0x1f, 0x29, 0x28, 0x9b, 0x28, 0xd8,
2832 0x1f, 0xe4, 0x8a, 0x6f, 0xa3, 0xab, 0xb5, 0xaf, 0x33, 0x50, 0x4d, 0xdf, 0xc0, 0xf0, 0x8f, 0xe0,
2833 0x62, 0xf4, 0x5c, 0xe2, 0xd3, 0x40, 0x7b, 0x62, 0x7a, 0x7c, 0x45, 0x4e, 0x88, 0x38, 0x1d, 0xe3,
2834 0x9c, 0xd8, 0x0c, 0x59, 0x7d, 0x1a, 0x7c, 0x62, 0x7a, 0x6c, 0xbd, 0x4d, 0x48, 0x80, 0x0f, 0xe1,
2835 0xb2, 0xed, 0x68, 0x7e, 0x40, 0x6c, 0x83, 0x78, 0x86, 0x36, 0x7b, 0xa8, 0xd2, 0x88, 0xae, 0x53,
2836 0xdf, 0x77, 0xc4, 0x49, 0x18, 0x5b, 0x79, 0xd5, 0x76, 0xfa, 0x21, 0x79, 0x76, 0x44, 0x34, 0x42,
2837 0xea, 0x5c, 0xfe, 0x66, 0xcf, 0xca, 0xdf, 0x57, 0xa0, 0x34, 0x21, 0xae, 0x46, 0xed, 0xc0, 0x3b,
2838 0xe5, 0x75, 0x77, 0x51, 0x2d, 0x4e, 0x88, 0xab, 0xb0, 0xf6, 0x0b, 0xb9, 0xfe, 0x3c, 0xc8, 0x15,
2839 0x8b, 0xa8, 0xf4, 0x20, 0x57, 0x2c, 0x21, 0xa8, 0xfd, 0x33, 0x0b, 0x95, 0x64, 0x1d, 0xce, 0xae,
2840 0x35, 0x3a, 0x3f, 0xb2, 0x24, 0xbe, 0xa9, 0xbd, 0xf1, 0x8d, 0x55, 0x7b, 0xbd, 0xc9, 0xce, 0xb2,
2841 0xbd, 0x82, 0xa8, 0x8e, 0x55, 0xa1, 0xc9, 0xea, 0x08, 0x96, 0x6c, 0x54, 0x54, 0x23, 0x45, 0x35,
2842 0x6c, 0xe1, 0x03, 0x28, 0x3c, 0xf4, 0xb9, 0xed, 0x02, 0xb7, 0xfd, 0xe6, 0x37, 0xdb, 0x7e, 0xd0,
2843 0xe7, 0xc6, 0x4b, 0x0f, 0xfa, 0x5a, 0xa7, 0xab, 0x1e, 0x35, 0x0e, 0xd5, 0x50, 0x1d, 0x5f, 0x82,
2844 0x9c, 0x45, 0xbe, 0x3c, 0x4d, 0x9f, 0x7a, 0x1c, 0x3a, 0xef, 0x24, 0x5c, 0x82, 0xdc, 0x13, 0x4a,
2845 0x1e, 0xa5, 0xcf, 0x1a, 0x0e, 0x7d, 0x8f, 0x8b, 0x61, 0x17, 0xf2, 0x3c, 0x5e, 0x18, 0x20, 0x8c,
2846 0x18, 0x7a, 0x09, 0x17, 0x21, 0xd7, 0xec, 0xaa, 0x6c, 0x41, 0x20, 0xa8, 0x08, 0x54, 0xeb, 0xb5,
2847 0x95, 0xa6, 0x82, 0x32, 0xb5, 0xdb, 0x50, 0x10, 0x41, 0x60, 0x8b, 0x25, 0x0e, 0x03, 0x7a, 0x29,
2848 0x6c, 0x86, 0x36, 0xa4, 0x48, 0x7a, 0x7c, 0xb4, 0xaf, 0xa8, 0x28, 0x93, 0x9e, 0xea, 0x1c, 0xca,
2849 0xd7, 0x7c, 0xa8, 0x24, 0x0b, 0xf1, 0x17, 0x73, 0xc9, 0xfe, 0x9b, 0x04, 0xe5, 0x44, 0x61, 0xcd,
2850 0x2a, 0x22, 0x62, 0x59, 0xce, 0x13, 0x8d, 0x58, 0x26, 0xf1, 0xc3, 0xd4, 0x00, 0x0e, 0x35, 0x18,
2851 0x72, 0xde, 0xa9, 0x7b, 0x41, 0x4b, 0x24, 0x8f, 0x0a, 0xb5, 0x3f, 0x4a, 0x80, 0xe6, 0x2b, 0xdb,
2852 0x39, 0x37, 0xa5, 0x1f, 0xd2, 0xcd, 0xda, 0x1f, 0x24, 0xa8, 0xa6, 0xcb, 0xd9, 0x39, 0xf7, 0xae,
2853 0xfc, 0xa0, 0xee, 0xfd, 0x23, 0x03, 0xab, 0xa9, 0x22, 0xf6, 0xbc, 0xde, 0x7d, 0x01, 0xeb, 0xa6,
2854 0x41, 0x27, 0xae, 0x13, 0x50, 0x5b, 0x3f, 0xd5, 0x2c, 0xfa, 0x98, 0x5a, 0x72, 0x8d, 0x6f, 0x1a,
2855 0xbb, 0xdf, 0x5c, 0x26, 0xd7, 0xdb, 0x33, 0xbd, 0x43, 0xa6, 0xb6, 0xb7, 0xd1, 0x6e, 0x29, 0x47,
2856 0xbd, 0xee, 0x40, 0xe9, 0x34, 0x3f, 0xd3, 0x8e, 0x3b, 0x3f, 0xed, 0x74, 0x3f, 0xe9, 0xa8, 0xc8,
2857 0x9c, 0xa3, 0x7d, 0x8f, 0xcb, 0xbe, 0x07, 0x68, 0xde, 0x29, 0x7c, 0x11, 0x96, 0xb9, 0x85, 0x5e,
2858 0xc2, 0x1b, 0xb0, 0xd6, 0xe9, 0x6a, 0xfd, 0x76, 0x4b, 0xd1, 0x94, 0xfb, 0xf7, 0x95, 0xe6, 0xa0,
2859 0x2f, 0x1e, 0x3e, 0x62, 0xf6, 0x20, 0xb5, 0xc0, 0x6b, 0xbf, 0xcf, 0xc2, 0xc6, 0x12, 0x4f, 0x70,
2860 0x23, 0xbc, 0xb2, 0x88, 0x5b, 0xd4, 0x8d, 0xf3, 0x78, 0x5f, 0x67, 0x35, 0x43, 0x8f, 0x78, 0x41,
2861 0x78, 0xc3, 0xb9, 0x06, 0x2c, 0x4a, 0x76, 0x60, 0x0e, 0x4d, 0xea, 0x85, 0xef, 0x44, 0xe2, 0x1e,
2862 0xb3, 0x36, 0xc3, 0xc5, 0x53, 0xd1, 0xbb, 0x80, 0x5d, 0xc7, 0x37, 0x03, 0xf3, 0x31, 0xd5, 0x4c,
2863 0x3b, 0x7a, 0x54, 0x62, 0xf7, 0x9a, 0x9c, 0x8a, 0x22, 0x49, 0xdb, 0x0e, 0x62, 0xb6, 0x4d, 0x47,
2864 0x64, 0x8e, 0xcd, 0x36, 0xf3, 0xac, 0x8a, 0x22, 0x49, 0xcc, 0xbe, 0x02, 0x15, 0xc3, 0x99, 0xb2,
2865 0x62, 0x4f, 0xf0, 0xd8, 0xd9, 0x21, 0xa9, 0x65, 0x81, 0xc5, 0x94, 0xb0, 0x8c, 0x9f, 0xbd, 0x66,
2866 0x55, 0xd4, 0xb2, 0xc0, 0x04, 0xe5, 0x2a, 0xac, 0x91, 0xd1, 0xc8, 0x63, 0xc6, 0x23, 0x43, 0xe2,
2867 0x62, 0x52, 0x8d, 0x61, 0x4e, 0xdc, 0x7a, 0x00, 0xc5, 0x28, 0x0e, 0xec, 0xa8, 0x66, 0x91, 0xd0,
2868 0x5c, 0x71, 0xdb, 0xce, 0xec, 0x94, 0xd4, 0xa2, 0x1d, 0x09, 0xaf, 0x40, 0xc5, 0xf4, 0xb5, 0xd9,
2869 0xe3, 0x7c, 0x66, 0x3b, 0xb3, 0x53, 0x54, 0xcb, 0xa6, 0x1f, 0x3f, 0x6c, 0xd6, 0xbe, 0xca, 0x40,
2870 0x35, 0xfd, 0x71, 0x01, 0xb7, 0xa0, 0x68, 0x39, 0x3a, 0xe1, 0xa9, 0x25, 0xbe, 0x6c, 0xed, 0x3c,
2871 0xe7, 0x7b, 0x44, 0xfd, 0x30, 0xe4, 0xab, 0xb1, 0xe6, 0xd6, 0xdf, 0x25, 0x28, 0x46, 0x30, 0xbe,
2872 0x00, 0x39, 0x97, 0x04, 0x63, 0x6e, 0x2e, 0xbf, 0x9f, 0x41, 0x92, 0xca, 0xdb, 0x0c, 0xf7, 0x5d,
2873 0x62, 0xf3, 0x14, 0x08, 0x71, 0xd6, 0x66, 0xf3, 0x6a, 0x51, 0x62, 0xf0, 0x5b, 0x8f, 0x33, 0x99,
2874 0x50, 0x3b, 0xf0, 0xa3, 0x79, 0x0d, 0xf1, 0x66, 0x08, 0xe3, 0x77, 0x60, 0x3d, 0xf0, 0x88, 0x69,
2875 0xa5, 0xb8, 0x39, 0xce, 0x45, 0x91, 0x20, 0x26, 0xef, 0xc1, 0xa5, 0xc8, 0xae, 0x41, 0x03, 0xa2,
2876 0x8f, 0xa9, 0x31, 0x53, 0x2a, 0xf0, 0xd7, 0x8d, 0x8b, 0x21, 0xa1, 0x15, 0xca, 0x23, 0xdd, 0xda,
2877 0xd7, 0x12, 0xac, 0x47, 0xf7, 0x34, 0x23, 0x0e, 0xd6, 0x11, 0x00, 0xb1, 0x6d, 0x27, 0x48, 0x86,
2878 0x6b, 0x31, 0x95, 0x17, 0xf4, 0xea, 0x8d, 0x58, 0x49, 0x4d, 0x18, 0xd8, 0x9a, 0x00, 0xcc, 0x24,
2879 0x67, 0x86, 0xed, 0x32, 0x94, 0xc3, 0x2f, 0x47, 0xfc, 0xf3, 0xa3, 0xb8, 0xd9, 0x83, 0x80, 0xd8,
2880 0x85, 0x0e, 0x6f, 0x42, 0xfe, 0x84, 0x8e, 0x4c, 0x3b, 0x7c, 0x0f, 0x16, 0x8d, 0xe8, 0xfd, 0x25,
2881 0x17, 0xbf, 0xbf, 0xec, 0xff, 0x46, 0x82, 0x0d, 0xdd, 0x99, 0xcc, 0xfb, 0xbb, 0x8f, 0xe6, 0x9e,
2882 0x17, 0xfc, 0x8f, 0xa5, 0xcf, 0x3f, 0x1a, 0x99, 0xc1, 0x78, 0x7a, 0x52, 0xd7, 0x9d, 0xc9, 0xee,
2883 0xc8, 0xb1, 0x88, 0x3d, 0x9a, 0x7d, 0x3f, 0xe5, 0x7f, 0xf4, 0x1b, 0x23, 0x6a, 0xdf, 0x18, 0x39,
2884 0x89, 0xaf, 0xa9, 0xf7, 0x66, 0x7f, 0xff, 0x27, 0x49, 0x7f, 0xca, 0x64, 0x0f, 0x7a, 0xfb, 0x7f,
2885 0xce, 0x6c, 0x1d, 0x88, 0xee, 0x7a, 0x51, 0x78, 0x54, 0x3a, 0xb4, 0xa8, 0xce, 0x86, 0xfc, 0xff,
2886 0x00, 0x00, 0x00, 0xff, 0xff, 0x3e, 0xe8, 0xef, 0xc4, 0x9b, 0x1d, 0x00, 0x00,
2887}
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.proto b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.proto
new file mode 100644
index 0000000..ed08fcb
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.proto
@@ -0,0 +1,883 @@
1// Protocol Buffers - Google's data interchange format
2// Copyright 2008 Google Inc. All rights reserved.
3// https://developers.google.com/protocol-buffers/
4//
5// Redistribution and use in source and binary forms, with or without
6// modification, are permitted provided that the following conditions are
7// met:
8//
9// * Redistributions of source code must retain the above copyright
10// notice, this list of conditions and the following disclaimer.
11// * Redistributions in binary form must reproduce the above
12// copyright notice, this list of conditions and the following disclaimer
13// in the documentation and/or other materials provided with the
14// distribution.
15// * Neither the name of Google Inc. nor the names of its
16// contributors may be used to endorse or promote products derived from
17// this software without specific prior written permission.
18//
19// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
31// Author: kenton@google.com (Kenton Varda)
32// Based on original Protocol Buffers design by
33// Sanjay Ghemawat, Jeff Dean, and others.
34//
35// The messages in this file describe the definitions found in .proto files.
36// A valid .proto file can be translated directly to a FileDescriptorProto
37// without any other information (e.g. without reading its imports).
38
39
40syntax = "proto2";
41
42package google.protobuf;
43option go_package = "github.com/golang/protobuf/protoc-gen-go/descriptor;descriptor";
44option java_package = "com.google.protobuf";
45option java_outer_classname = "DescriptorProtos";
46option csharp_namespace = "Google.Protobuf.Reflection";
47option objc_class_prefix = "GPB";
48option cc_enable_arenas = true;
49
50// descriptor.proto must be optimized for speed because reflection-based
51// algorithms don't work during bootstrapping.
52option optimize_for = SPEED;
53
54// The protocol compiler can output a FileDescriptorSet containing the .proto
55// files it parses.
56message FileDescriptorSet {
57 repeated FileDescriptorProto file = 1;
58}
59
60// Describes a complete .proto file.
61message FileDescriptorProto {
62 optional string name = 1; // file name, relative to root of source tree
63 optional string package = 2; // e.g. "foo", "foo.bar", etc.
64
65 // Names of files imported by this file.
66 repeated string dependency = 3;
67 // Indexes of the public imported files in the dependency list above.
68 repeated int32 public_dependency = 10;
69 // Indexes of the weak imported files in the dependency list.
70 // For Google-internal migration only. Do not use.
71 repeated int32 weak_dependency = 11;
72
73 // All top-level definitions in this file.
74 repeated DescriptorProto message_type = 4;
75 repeated EnumDescriptorProto enum_type = 5;
76 repeated ServiceDescriptorProto service = 6;
77 repeated FieldDescriptorProto extension = 7;
78
79 optional FileOptions options = 8;
80
81 // This field contains optional information about the original source code.
82 // You may safely remove this entire field without harming runtime
83 // functionality of the descriptors -- the information is needed only by
84 // development tools.
85 optional SourceCodeInfo source_code_info = 9;
86
87 // The syntax of the proto file.
88 // The supported values are "proto2" and "proto3".
89 optional string syntax = 12;
90}
91
92// Describes a message type.
93message DescriptorProto {
94 optional string name = 1;
95
96 repeated FieldDescriptorProto field = 2;
97 repeated FieldDescriptorProto extension = 6;
98
99 repeated DescriptorProto nested_type = 3;
100 repeated EnumDescriptorProto enum_type = 4;
101
102 message ExtensionRange {
103 optional int32 start = 1;
104 optional int32 end = 2;
105
106 optional ExtensionRangeOptions options = 3;
107 }
108 repeated ExtensionRange extension_range = 5;
109
110 repeated OneofDescriptorProto oneof_decl = 8;
111
112 optional MessageOptions options = 7;
113
114 // Range of reserved tag numbers. Reserved tag numbers may not be used by
115 // fields or extension ranges in the same message. Reserved ranges may
116 // not overlap.
117 message ReservedRange {
118 optional int32 start = 1; // Inclusive.
119 optional int32 end = 2; // Exclusive.
120 }
121 repeated ReservedRange reserved_range = 9;
122 // Reserved field names, which may not be used by fields in the same message.
123 // A given name may only be reserved once.
124 repeated string reserved_name = 10;
125}
126
127message ExtensionRangeOptions {
128 // The parser stores options it doesn't recognize here. See above.
129 repeated UninterpretedOption uninterpreted_option = 999;
130
131 // Clients can define custom options in extensions of this message. See above.
132 extensions 1000 to max;
133}
134
135// Describes a field within a message.
136message FieldDescriptorProto {
137 enum Type {
138 // 0 is reserved for errors.
139 // Order is weird for historical reasons.
140 TYPE_DOUBLE = 1;
141 TYPE_FLOAT = 2;
142 // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if
143 // negative values are likely.
144 TYPE_INT64 = 3;
145 TYPE_UINT64 = 4;
146 // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if
147 // negative values are likely.
148 TYPE_INT32 = 5;
149 TYPE_FIXED64 = 6;
150 TYPE_FIXED32 = 7;
151 TYPE_BOOL = 8;
152 TYPE_STRING = 9;
153 // Tag-delimited aggregate.
154 // Group type is deprecated and not supported in proto3. However, Proto3
155 // implementations should still be able to parse the group wire format and
156 // treat group fields as unknown fields.
157 TYPE_GROUP = 10;
158 TYPE_MESSAGE = 11; // Length-delimited aggregate.
159
160 // New in version 2.
161 TYPE_BYTES = 12;
162 TYPE_UINT32 = 13;
163 TYPE_ENUM = 14;
164 TYPE_SFIXED32 = 15;
165 TYPE_SFIXED64 = 16;
166 TYPE_SINT32 = 17; // Uses ZigZag encoding.
167 TYPE_SINT64 = 18; // Uses ZigZag encoding.
168 };
169
170 enum Label {
171 // 0 is reserved for errors
172 LABEL_OPTIONAL = 1;
173 LABEL_REQUIRED = 2;
174 LABEL_REPEATED = 3;
175 };
176
177 optional string name = 1;
178 optional int32 number = 3;
179 optional Label label = 4;
180
181 // If type_name is set, this need not be set. If both this and type_name
182 // are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
183 optional Type type = 5;
184
185 // For message and enum types, this is the name of the type. If the name
186 // starts with a '.', it is fully-qualified. Otherwise, C++-like scoping
187 // rules are used to find the type (i.e. first the nested types within this
188 // message are searched, then within the parent, on up to the root
189 // namespace).
190 optional string type_name = 6;
191
192 // For extensions, this is the name of the type being extended. It is
193 // resolved in the same manner as type_name.
194 optional string extendee = 2;
195
196 // For numeric types, contains the original text representation of the value.
197 // For booleans, "true" or "false".
198 // For strings, contains the default text contents (not escaped in any way).
199 // For bytes, contains the C escaped value. All bytes >= 128 are escaped.
200 // TODO(kenton): Base-64 encode?
201 optional string default_value = 7;
202
203 // If set, gives the index of a oneof in the containing type's oneof_decl
204 // list. This field is a member of that oneof.
205 optional int32 oneof_index = 9;
206
207 // JSON name of this field. The value is set by protocol compiler. If the
208 // user has set a "json_name" option on this field, that option's value
209 // will be used. Otherwise, it's deduced from the field's name by converting
210 // it to camelCase.
211 optional string json_name = 10;
212
213 optional FieldOptions options = 8;
214}
215
216// Describes a oneof.
217message OneofDescriptorProto {
218 optional string name = 1;
219 optional OneofOptions options = 2;
220}
221
222// Describes an enum type.
223message EnumDescriptorProto {
224 optional string name = 1;
225
226 repeated EnumValueDescriptorProto value = 2;
227
228 optional EnumOptions options = 3;
229
230 // Range of reserved numeric values. Reserved values may not be used by
231 // entries in the same enum. Reserved ranges may not overlap.
232 //
233 // Note that this is distinct from DescriptorProto.ReservedRange in that it
234 // is inclusive such that it can appropriately represent the entire int32
235 // domain.
236 message EnumReservedRange {
237 optional int32 start = 1; // Inclusive.
238 optional int32 end = 2; // Inclusive.
239 }
240
241 // Range of reserved numeric values. Reserved numeric values may not be used
242 // by enum values in the same enum declaration. Reserved ranges may not
243 // overlap.
244 repeated EnumReservedRange reserved_range = 4;
245
246 // Reserved enum value names, which may not be reused. A given name may only
247 // be reserved once.
248 repeated string reserved_name = 5;
249}
250
251// Describes a value within an enum.
252message EnumValueDescriptorProto {
253 optional string name = 1;
254 optional int32 number = 2;
255
256 optional EnumValueOptions options = 3;
257}
258
259// Describes a service.
260message ServiceDescriptorProto {
261 optional string name = 1;
262 repeated MethodDescriptorProto method = 2;
263
264 optional ServiceOptions options = 3;
265}
266
267// Describes a method of a service.
268message MethodDescriptorProto {
269 optional string name = 1;
270
271 // Input and output type names. These are resolved in the same way as
272 // FieldDescriptorProto.type_name, but must refer to a message type.
273 optional string input_type = 2;
274 optional string output_type = 3;
275
276 optional MethodOptions options = 4;
277
278 // Identifies if client streams multiple client messages
279 optional bool client_streaming = 5 [default=false];
280 // Identifies if server streams multiple server messages
281 optional bool server_streaming = 6 [default=false];
282}
283
284
285// ===================================================================
286// Options
287
288// Each of the definitions above may have "options" attached. These are
289// just annotations which may cause code to be generated slightly differently
290// or may contain hints for code that manipulates protocol messages.
291//
292// Clients may define custom options as extensions of the *Options messages.
293// These extensions may not yet be known at parsing time, so the parser cannot
294// store the values in them. Instead it stores them in a field in the *Options
295// message called uninterpreted_option. This field must have the same name
296// across all *Options messages. We then use this field to populate the
297// extensions when we build a descriptor, at which point all protos have been
298// parsed and so all extensions are known.
299//
300// Extension numbers for custom options may be chosen as follows:
301// * For options which will only be used within a single application or
302// organization, or for experimental options, use field numbers 50000
303// through 99999. It is up to you to ensure that you do not use the
304// same number for multiple options.
305// * For options which will be published and used publicly by multiple
306// independent entities, e-mail protobuf-global-extension-registry@google.com
307// to reserve extension numbers. Simply provide your project name (e.g.
308// Objective-C plugin) and your project website (if available) -- there's no
309// need to explain how you intend to use them. Usually you only need one
310// extension number. You can declare multiple options with only one extension
311// number by putting them in a sub-message. See the Custom Options section of
312// the docs for examples:
313// https://developers.google.com/protocol-buffers/docs/proto#options
314// If this turns out to be popular, a web service will be set up
315// to automatically assign option numbers.
316
317
318message FileOptions {
319
320 // Sets the Java package where classes generated from this .proto will be
321 // placed. By default, the proto package is used, but this is often
322 // inappropriate because proto packages do not normally start with backwards
323 // domain names.
324 optional string java_package = 1;
325
326
327 // If set, all the classes from the .proto file are wrapped in a single
328 // outer class with the given name. This applies to both Proto1
329 // (equivalent to the old "--one_java_file" option) and Proto2 (where
330 // a .proto always translates to a single class, but you may want to
331 // explicitly choose the class name).
332 optional string java_outer_classname = 8;
333
334 // If set true, then the Java code generator will generate a separate .java
335 // file for each top-level message, enum, and service defined in the .proto
336 // file. Thus, these types will *not* be nested inside the outer class
337 // named by java_outer_classname. However, the outer class will still be
338 // generated to contain the file's getDescriptor() method as well as any
339 // top-level extensions defined in the file.
340 optional bool java_multiple_files = 10 [default=false];
341
342 // This option does nothing.
343 optional bool java_generate_equals_and_hash = 20 [deprecated=true];
344
345 // If set true, then the Java2 code generator will generate code that
346 // throws an exception whenever an attempt is made to assign a non-UTF-8
347 // byte sequence to a string field.
348 // Message reflection will do the same.
349 // However, an extension field still accepts non-UTF-8 byte sequences.
350 // This option has no effect on when used with the lite runtime.
351 optional bool java_string_check_utf8 = 27 [default=false];
352
353
354 // Generated classes can be optimized for speed or code size.
355 enum OptimizeMode {
356 SPEED = 1; // Generate complete code for parsing, serialization,
357 // etc.
358 CODE_SIZE = 2; // Use ReflectionOps to implement these methods.
359 LITE_RUNTIME = 3; // Generate code using MessageLite and the lite runtime.
360 }
361 optional OptimizeMode optimize_for = 9 [default=SPEED];
362
363 // Sets the Go package where structs generated from this .proto will be
364 // placed. If omitted, the Go package will be derived from the following:
365 // - The basename of the package import path, if provided.
366 // - Otherwise, the package statement in the .proto file, if present.
367 // - Otherwise, the basename of the .proto file, without extension.
368 optional string go_package = 11;
369
370
371
372 // Should generic services be generated in each language? "Generic" services
373 // are not specific to any particular RPC system. They are generated by the
374 // main code generators in each language (without additional plugins).
375 // Generic services were the only kind of service generation supported by
376 // early versions of google.protobuf.
377 //
378 // Generic services are now considered deprecated in favor of using plugins
379 // that generate code specific to your particular RPC system. Therefore,
380 // these default to false. Old code which depends on generic services should
381 // explicitly set them to true.
382 optional bool cc_generic_services = 16 [default=false];
383 optional bool java_generic_services = 17 [default=false];
384 optional bool py_generic_services = 18 [default=false];
385 optional bool php_generic_services = 42 [default=false];
386
387 // Is this file deprecated?
388 // Depending on the target platform, this can emit Deprecated annotations
389 // for everything in the file, or it will be completely ignored; in the very
390 // least, this is a formalization for deprecating files.
391 optional bool deprecated = 23 [default=false];
392
393 // Enables the use of arenas for the proto messages in this file. This applies
394 // only to generated classes for C++.
395 optional bool cc_enable_arenas = 31 [default=false];
396
397
398 // Sets the objective c class prefix which is prepended to all objective c
399 // generated classes from this .proto. There is no default.
400 optional string objc_class_prefix = 36;
401
402 // Namespace for generated classes; defaults to the package.
403 optional string csharp_namespace = 37;
404
405 // By default Swift generators will take the proto package and CamelCase it
406 // replacing '.' with underscore and use that to prefix the types/symbols
407 // defined. When this options is provided, they will use this value instead
408 // to prefix the types/symbols defined.
409 optional string swift_prefix = 39;
410
411 // Sets the php class prefix which is prepended to all php generated classes
412 // from this .proto. Default is empty.
413 optional string php_class_prefix = 40;
414
415 // Use this option to change the namespace of php generated classes. Default
416 // is empty. When this option is empty, the package name will be used for
417 // determining the namespace.
418 optional string php_namespace = 41;
419
420
421 // Use this option to change the namespace of php generated metadata classes.
422 // Default is empty. When this option is empty, the proto file name will be used
423 // for determining the namespace.
424 optional string php_metadata_namespace = 44;
425
426 // Use this option to change the package of ruby generated classes. Default
427 // is empty. When this option is not set, the package name will be used for
428 // determining the ruby package.
429 optional string ruby_package = 45;
430
431 // The parser stores options it doesn't recognize here.
432 // See the documentation for the "Options" section above.
433 repeated UninterpretedOption uninterpreted_option = 999;
434
435 // Clients can define custom options in extensions of this message.
436 // See the documentation for the "Options" section above.
437 extensions 1000 to max;
438
439 reserved 38;
440}
441
442message MessageOptions {
443 // Set true to use the old proto1 MessageSet wire format for extensions.
444 // This is provided for backwards-compatibility with the MessageSet wire
445 // format. You should not use this for any other reason: It's less
446 // efficient, has fewer features, and is more complicated.
447 //
448 // The message must be defined exactly as follows:
449 // message Foo {
450 // option message_set_wire_format = true;
451 // extensions 4 to max;
452 // }
453 // Note that the message cannot have any defined fields; MessageSets only
454 // have extensions.
455 //
456 // All extensions of your type must be singular messages; e.g. they cannot
457 // be int32s, enums, or repeated messages.
458 //
459 // Because this is an option, the above two restrictions are not enforced by
460 // the protocol compiler.
461 optional bool message_set_wire_format = 1 [default=false];
462
463 // Disables the generation of the standard "descriptor()" accessor, which can
464 // conflict with a field of the same name. This is meant to make migration
465 // from proto1 easier; new code should avoid fields named "descriptor".
466 optional bool no_standard_descriptor_accessor = 2 [default=false];
467
468 // Is this message deprecated?
469 // Depending on the target platform, this can emit Deprecated annotations
470 // for the message, or it will be completely ignored; in the very least,
471 // this is a formalization for deprecating messages.
472 optional bool deprecated = 3 [default=false];
473
474 // Whether the message is an automatically generated map entry type for the
475 // maps field.
476 //
477 // For maps fields:
478 // map<KeyType, ValueType> map_field = 1;
479 // The parsed descriptor looks like:
480 // message MapFieldEntry {
481 // option map_entry = true;
482 // optional KeyType key = 1;
483 // optional ValueType value = 2;
484 // }
485 // repeated MapFieldEntry map_field = 1;
486 //
487 // Implementations may choose not to generate the map_entry=true message, but
488 // use a native map in the target language to hold the keys and values.
489 // The reflection APIs in such implementions still need to work as
490 // if the field is a repeated message field.
491 //
492 // NOTE: Do not set the option in .proto files. Always use the maps syntax
493 // instead. The option should only be implicitly set by the proto compiler
494 // parser.
495 optional bool map_entry = 7;
496
497 reserved 8; // javalite_serializable
498 reserved 9; // javanano_as_lite
499
500 // The parser stores options it doesn't recognize here. See above.
501 repeated UninterpretedOption uninterpreted_option = 999;
502
503 // Clients can define custom options in extensions of this message. See above.
504 extensions 1000 to max;
505}
506
507message FieldOptions {
508 // The ctype option instructs the C++ code generator to use a different
509 // representation of the field than it normally would. See the specific
510 // options below. This option is not yet implemented in the open source
511 // release -- sorry, we'll try to include it in a future version!
512 optional CType ctype = 1 [default = STRING];
513 enum CType {
514 // Default mode.
515 STRING = 0;
516
517 CORD = 1;
518
519 STRING_PIECE = 2;
520 }
521 // The packed option can be enabled for repeated primitive fields to enable
522 // a more efficient representation on the wire. Rather than repeatedly
523 // writing the tag and type for each element, the entire array is encoded as
524 // a single length-delimited blob. In proto3, only explicit setting it to
525 // false will avoid using packed encoding.
526 optional bool packed = 2;
527
528 // The jstype option determines the JavaScript type used for values of the
529 // field. The option is permitted only for 64 bit integral and fixed types
530 // (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING
531 // is represented as JavaScript string, which avoids loss of precision that
532 // can happen when a large value is converted to a floating point JavaScript.
533 // Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
534 // use the JavaScript "number" type. The behavior of the default option
535 // JS_NORMAL is implementation dependent.
536 //
537 // This option is an enum to permit additional types to be added, e.g.
538 // goog.math.Integer.
539 optional JSType jstype = 6 [default = JS_NORMAL];
540 enum JSType {
541 // Use the default type.
542 JS_NORMAL = 0;
543
544 // Use JavaScript strings.
545 JS_STRING = 1;
546
547 // Use JavaScript numbers.
548 JS_NUMBER = 2;
549 }
550
551 // Should this field be parsed lazily? Lazy applies only to message-type
552 // fields. It means that when the outer message is initially parsed, the
553 // inner message's contents will not be parsed but instead stored in encoded
554 // form. The inner message will actually be parsed when it is first accessed.
555 //
556 // This is only a hint. Implementations are free to choose whether to use
557 // eager or lazy parsing regardless of the value of this option. However,
558 // setting this option true suggests that the protocol author believes that
559 // using lazy parsing on this field is worth the additional bookkeeping
560 // overhead typically needed to implement it.
561 //
562 // This option does not affect the public interface of any generated code;
563 // all method signatures remain the same. Furthermore, thread-safety of the
564 // interface is not affected by this option; const methods remain safe to
565 // call from multiple threads concurrently, while non-const methods continue
566 // to require exclusive access.
567 //
568 //
569 // Note that implementations may choose not to check required fields within
570 // a lazy sub-message. That is, calling IsInitialized() on the outer message
571 // may return true even if the inner message has missing required fields.
572 // This is necessary because otherwise the inner message would have to be
573 // parsed in order to perform the check, defeating the purpose of lazy
574 // parsing. An implementation which chooses not to check required fields
575 // must be consistent about it. That is, for any particular sub-message, the
576 // implementation must either *always* check its required fields, or *never*
577 // check its required fields, regardless of whether or not the message has
578 // been parsed.
579 optional bool lazy = 5 [default=false];
580
581 // Is this field deprecated?
582 // Depending on the target platform, this can emit Deprecated annotations
583 // for accessors, or it will be completely ignored; in the very least, this
584 // is a formalization for deprecating fields.
585 optional bool deprecated = 3 [default=false];
586
587 // For Google-internal migration only. Do not use.
588 optional bool weak = 10 [default=false];
589
590
591 // The parser stores options it doesn't recognize here. See above.
592 repeated UninterpretedOption uninterpreted_option = 999;
593
594 // Clients can define custom options in extensions of this message. See above.
595 extensions 1000 to max;
596
597 reserved 4; // removed jtype
598}
599
600message OneofOptions {
601 // The parser stores options it doesn't recognize here. See above.
602 repeated UninterpretedOption uninterpreted_option = 999;
603
604 // Clients can define custom options in extensions of this message. See above.
605 extensions 1000 to max;
606}
607
608message EnumOptions {
609
610 // Set this option to true to allow mapping different tag names to the same
611 // value.
612 optional bool allow_alias = 2;
613
614 // Is this enum deprecated?
615 // Depending on the target platform, this can emit Deprecated annotations
616 // for the enum, or it will be completely ignored; in the very least, this
617 // is a formalization for deprecating enums.
618 optional bool deprecated = 3 [default=false];
619
620 reserved 5; // javanano_as_lite
621
622 // The parser stores options it doesn't recognize here. See above.
623 repeated UninterpretedOption uninterpreted_option = 999;
624
625 // Clients can define custom options in extensions of this message. See above.
626 extensions 1000 to max;
627}
628
629message EnumValueOptions {
630 // Is this enum value deprecated?
631 // Depending on the target platform, this can emit Deprecated annotations
632 // for the enum value, or it will be completely ignored; in the very least,
633 // this is a formalization for deprecating enum values.
634 optional bool deprecated = 1 [default=false];
635
636 // The parser stores options it doesn't recognize here. See above.
637 repeated UninterpretedOption uninterpreted_option = 999;
638
639 // Clients can define custom options in extensions of this message. See above.
640 extensions 1000 to max;
641}
642
643message ServiceOptions {
644
645 // Note: Field numbers 1 through 32 are reserved for Google's internal RPC
646 // framework. We apologize for hoarding these numbers to ourselves, but
647 // we were already using them long before we decided to release Protocol
648 // Buffers.
649
650 // Is this service deprecated?
651 // Depending on the target platform, this can emit Deprecated annotations
652 // for the service, or it will be completely ignored; in the very least,
653 // this is a formalization for deprecating services.
654 optional bool deprecated = 33 [default=false];
655
656 // The parser stores options it doesn't recognize here. See above.
657 repeated UninterpretedOption uninterpreted_option = 999;
658
659 // Clients can define custom options in extensions of this message. See above.
660 extensions 1000 to max;
661}
662
663message MethodOptions {
664
665 // Note: Field numbers 1 through 32 are reserved for Google's internal RPC
666 // framework. We apologize for hoarding these numbers to ourselves, but
667 // we were already using them long before we decided to release Protocol
668 // Buffers.
669
670 // Is this method deprecated?
671 // Depending on the target platform, this can emit Deprecated annotations
672 // for the method, or it will be completely ignored; in the very least,
673 // this is a formalization for deprecating methods.
674 optional bool deprecated = 33 [default=false];
675
676 // Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
677 // or neither? HTTP based RPC implementation may choose GET verb for safe
678 // methods, and PUT verb for idempotent methods instead of the default POST.
679 enum IdempotencyLevel {
680 IDEMPOTENCY_UNKNOWN = 0;
681 NO_SIDE_EFFECTS = 1; // implies idempotent
682 IDEMPOTENT = 2; // idempotent, but may have side effects
683 }
684 optional IdempotencyLevel idempotency_level =
685 34 [default=IDEMPOTENCY_UNKNOWN];
686
687 // The parser stores options it doesn't recognize here. See above.
688 repeated UninterpretedOption uninterpreted_option = 999;
689
690 // Clients can define custom options in extensions of this message. See above.
691 extensions 1000 to max;
692}
693
694
695// A message representing a option the parser does not recognize. This only
696// appears in options protos created by the compiler::Parser class.
697// DescriptorPool resolves these when building Descriptor objects. Therefore,
698// options protos in descriptor objects (e.g. returned by Descriptor::options(),
699// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
700// in them.
701message UninterpretedOption {
702 // The name of the uninterpreted option. Each string represents a segment in
703 // a dot-separated name. is_extension is true iff a segment represents an
704 // extension (denoted with parentheses in options specs in .proto files).
705 // E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
706 // "foo.(bar.baz).qux".
707 message NamePart {
708 required string name_part = 1;
709 required bool is_extension = 2;
710 }
711 repeated NamePart name = 2;
712
713 // The value of the uninterpreted option, in whatever type the tokenizer
714 // identified it as during parsing. Exactly one of these should be set.
715 optional string identifier_value = 3;
716 optional uint64 positive_int_value = 4;
717 optional int64 negative_int_value = 5;
718 optional double double_value = 6;
719 optional bytes string_value = 7;
720 optional string aggregate_value = 8;
721}
722
723// ===================================================================
724// Optional source code info
725
726// Encapsulates information about the original source file from which a
727// FileDescriptorProto was generated.
728message SourceCodeInfo {
729 // A Location identifies a piece of source code in a .proto file which
730 // corresponds to a particular definition. This information is intended
731 // to be useful to IDEs, code indexers, documentation generators, and similar
732 // tools.
733 //
734 // For example, say we have a file like:
735 // message Foo {
736 // optional string foo = 1;
737 // }
738 // Let's look at just the field definition:
739 // optional string foo = 1;
740 // ^ ^^ ^^ ^ ^^^
741 // a bc de f ghi
742 // We have the following locations:
743 // span path represents
744 // [a,i) [ 4, 0, 2, 0 ] The whole field definition.
745 // [a,b) [ 4, 0, 2, 0, 4 ] The label (optional).
746 // [c,d) [ 4, 0, 2, 0, 5 ] The type (string).
747 // [e,f) [ 4, 0, 2, 0, 1 ] The name (foo).
748 // [g,h) [ 4, 0, 2, 0, 3 ] The number (1).
749 //
750 // Notes:
751 // - A location may refer to a repeated field itself (i.e. not to any
752 // particular index within it). This is used whenever a set of elements are
753 // logically enclosed in a single code segment. For example, an entire
754 // extend block (possibly containing multiple extension definitions) will
755 // have an outer location whose path refers to the "extensions" repeated
756 // field without an index.
757 // - Multiple locations may have the same path. This happens when a single
758 // logical declaration is spread out across multiple places. The most
759 // obvious example is the "extend" block again -- there may be multiple
760 // extend blocks in the same scope, each of which will have the same path.
761 // - A location's span is not always a subset of its parent's span. For
762 // example, the "extendee" of an extension declaration appears at the
763 // beginning of the "extend" block and is shared by all extensions within
764 // the block.
765 // - Just because a location's span is a subset of some other location's span
766 // does not mean that it is a descendent. For example, a "group" defines
767 // both a type and a field in a single declaration. Thus, the locations
768 // corresponding to the type and field and their components will overlap.
769 // - Code which tries to interpret locations should probably be designed to
770 // ignore those that it doesn't understand, as more types of locations could
771 // be recorded in the future.
772 repeated Location location = 1;
773 message Location {
774 // Identifies which part of the FileDescriptorProto was defined at this
775 // location.
776 //
777 // Each element is a field number or an index. They form a path from
778 // the root FileDescriptorProto to the place where the definition. For
779 // example, this path:
780 // [ 4, 3, 2, 7, 1 ]
781 // refers to:
782 // file.message_type(3) // 4, 3
783 // .field(7) // 2, 7
784 // .name() // 1
785 // This is because FileDescriptorProto.message_type has field number 4:
786 // repeated DescriptorProto message_type = 4;
787 // and DescriptorProto.field has field number 2:
788 // repeated FieldDescriptorProto field = 2;
789 // and FieldDescriptorProto.name has field number 1:
790 // optional string name = 1;
791 //
792 // Thus, the above path gives the location of a field name. If we removed
793 // the last element:
794 // [ 4, 3, 2, 7 ]
795 // this path refers to the whole field declaration (from the beginning
796 // of the label to the terminating semicolon).
797 repeated int32 path = 1 [packed=true];
798
799 // Always has exactly three or four elements: start line, start column,
800 // end line (optional, otherwise assumed same as start line), end column.
801 // These are packed into a single field for efficiency. Note that line
802 // and column numbers are zero-based -- typically you will want to add
803 // 1 to each before displaying to a user.
804 repeated int32 span = 2 [packed=true];
805
806 // If this SourceCodeInfo represents a complete declaration, these are any
807 // comments appearing before and after the declaration which appear to be
808 // attached to the declaration.
809 //
810 // A series of line comments appearing on consecutive lines, with no other
811 // tokens appearing on those lines, will be treated as a single comment.
812 //
813 // leading_detached_comments will keep paragraphs of comments that appear
814 // before (but not connected to) the current element. Each paragraph,
815 // separated by empty lines, will be one comment element in the repeated
816 // field.
817 //
818 // Only the comment content is provided; comment markers (e.g. //) are
819 // stripped out. For block comments, leading whitespace and an asterisk
820 // will be stripped from the beginning of each line other than the first.
821 // Newlines are included in the output.
822 //
823 // Examples:
824 //
825 // optional int32 foo = 1; // Comment attached to foo.
826 // // Comment attached to bar.
827 // optional int32 bar = 2;
828 //
829 // optional string baz = 3;
830 // // Comment attached to baz.
831 // // Another line attached to baz.
832 //
833 // // Comment attached to qux.
834 // //
835 // // Another line attached to qux.
836 // optional double qux = 4;
837 //
838 // // Detached comment for corge. This is not leading or trailing comments
839 // // to qux or corge because there are blank lines separating it from
840 // // both.
841 //
842 // // Detached comment for corge paragraph 2.
843 //
844 // optional string corge = 5;
845 // /* Block comment attached
846 // * to corge. Leading asterisks
847 // * will be removed. */
848 // /* Block comment attached to
849 // * grault. */
850 // optional int32 grault = 6;
851 //
852 // // ignored detached comments.
853 optional string leading_comments = 3;
854 optional string trailing_comments = 4;
855 repeated string leading_detached_comments = 6;
856 }
857}
858
859// Describes the relationship between generated code and its original source
860// file. A GeneratedCodeInfo message is associated with only one generated
861// source file, but may contain references to different source .proto files.
862message GeneratedCodeInfo {
863 // An Annotation connects some span of text in generated code to an element
864 // of its generating .proto file.
865 repeated Annotation annotation = 1;
866 message Annotation {
867 // Identifies the element in the original source .proto file. This field
868 // is formatted the same as SourceCodeInfo.Location.path.
869 repeated int32 path = 1 [packed=true];
870
871 // Identifies the filesystem path to the original source .proto.
872 optional string source_file = 2;
873
874 // Identifies the starting offset in bytes in the generated code
875 // that relates to the identified object.
876 optional int32 begin = 3;
877
878 // Identifies the ending offset in bytes in the generated code that
879 // relates to the identified offset. The end offset should be one past
880 // the last relevant byte (so the length of the text = end - begin).
881 optional int32 end = 4;
882 }
883}
diff --git a/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go b/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go
index e3c56d3..78ee523 100644
--- a/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go
+++ b/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go
@@ -1,11 +1,13 @@
1// Code generated by protoc-gen-go. DO NOT EDIT. 1// Code generated by protoc-gen-go. DO NOT EDIT.
2// source: google/protobuf/any.proto 2// source: google/protobuf/any.proto
3 3
4package any // import "github.com/golang/protobuf/ptypes/any" 4package any
5 5
6import proto "github.com/golang/protobuf/proto" 6import (
7import fmt "fmt" 7 fmt "fmt"
8import math "math" 8 proto "github.com/golang/protobuf/proto"
9 math "math"
10)
9 11
10// Reference imports to suppress errors if they are not otherwise used. 12// Reference imports to suppress errors if they are not otherwise used.
11var _ = proto.Marshal 13var _ = proto.Marshal
@@ -16,7 +18,7 @@ var _ = math.Inf
16// is compatible with the proto package it is being compiled against. 18// is compatible with the proto package it is being compiled against.
17// A compilation error at this line likely means your copy of the 19// A compilation error at this line likely means your copy of the
18// proto package needs to be updated. 20// proto package needs to be updated.
19const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package 21const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
20 22
21// `Any` contains an arbitrary serialized protocol buffer message along with a 23// `Any` contains an arbitrary serialized protocol buffer message along with a
22// URL that describes the type of the serialized message. 24// URL that describes the type of the serialized message.
@@ -99,17 +101,18 @@ const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
99// } 101// }
100// 102//
101type Any struct { 103type Any struct {
102 // A URL/resource name whose content describes the type of the 104 // A URL/resource name that uniquely identifies the type of the serialized
103 // serialized protocol buffer message. 105 // protocol buffer message. The last segment of the URL's path must represent
106 // the fully qualified name of the type (as in
107 // `path/google.protobuf.Duration`). The name should be in a canonical form
108 // (e.g., leading "." is not accepted).
104 // 109 //
105 // For URLs which use the scheme `http`, `https`, or no scheme, the 110 // In practice, teams usually precompile into the binary all types that they
106 // following restrictions and interpretations apply: 111 // expect it to use in the context of Any. However, for URLs which use the
112 // scheme `http`, `https`, or no scheme, one can optionally set up a type
113 // server that maps type URLs to message definitions as follows:
107 // 114 //
108 // * If no scheme is provided, `https` is assumed. 115 // * If no scheme is provided, `https` is assumed.
109 // * The last segment of the URL's path must represent the fully
110 // qualified name of the type (as in `path/google.protobuf.Duration`).
111 // The name should be in a canonical form (e.g., leading "." is
112 // not accepted).
113 // * An HTTP GET on the URL must yield a [google.protobuf.Type][] 116 // * An HTTP GET on the URL must yield a [google.protobuf.Type][]
114 // value in binary format, or produce an error. 117 // value in binary format, or produce an error.
115 // * Applications are allowed to cache lookup results based on the 118 // * Applications are allowed to cache lookup results based on the
@@ -118,6 +121,10 @@ type Any struct {
118 // on changes to types. (Use versioned type names to manage 121 // on changes to types. (Use versioned type names to manage
119 // breaking changes.) 122 // breaking changes.)
120 // 123 //
124 // Note: this functionality is not currently available in the official
125 // protobuf release, and it is not used for type URLs beginning with
126 // type.googleapis.com.
127 //
121 // Schemes other than `http`, `https` (or the empty scheme) might be 128 // Schemes other than `http`, `https` (or the empty scheme) might be
122 // used with implementation specific semantics. 129 // used with implementation specific semantics.
123 // 130 //
@@ -133,17 +140,19 @@ func (m *Any) Reset() { *m = Any{} }
133func (m *Any) String() string { return proto.CompactTextString(m) } 140func (m *Any) String() string { return proto.CompactTextString(m) }
134func (*Any) ProtoMessage() {} 141func (*Any) ProtoMessage() {}
135func (*Any) Descriptor() ([]byte, []int) { 142func (*Any) Descriptor() ([]byte, []int) {
136 return fileDescriptor_any_744b9ca530f228db, []int{0} 143 return fileDescriptor_b53526c13ae22eb4, []int{0}
137} 144}
145
138func (*Any) XXX_WellKnownType() string { return "Any" } 146func (*Any) XXX_WellKnownType() string { return "Any" }
147
139func (m *Any) XXX_Unmarshal(b []byte) error { 148func (m *Any) XXX_Unmarshal(b []byte) error {
140 return xxx_messageInfo_Any.Unmarshal(m, b) 149 return xxx_messageInfo_Any.Unmarshal(m, b)
141} 150}
142func (m *Any) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 151func (m *Any) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
143 return xxx_messageInfo_Any.Marshal(b, m, deterministic) 152 return xxx_messageInfo_Any.Marshal(b, m, deterministic)
144} 153}
145func (dst *Any) XXX_Merge(src proto.Message) { 154func (m *Any) XXX_Merge(src proto.Message) {
146 xxx_messageInfo_Any.Merge(dst, src) 155 xxx_messageInfo_Any.Merge(m, src)
147} 156}
148func (m *Any) XXX_Size() int { 157func (m *Any) XXX_Size() int {
149 return xxx_messageInfo_Any.Size(m) 158 return xxx_messageInfo_Any.Size(m)
@@ -172,9 +181,9 @@ func init() {
172 proto.RegisterType((*Any)(nil), "google.protobuf.Any") 181 proto.RegisterType((*Any)(nil), "google.protobuf.Any")
173} 182}
174 183
175func init() { proto.RegisterFile("google/protobuf/any.proto", fileDescriptor_any_744b9ca530f228db) } 184func init() { proto.RegisterFile("google/protobuf/any.proto", fileDescriptor_b53526c13ae22eb4) }
176 185
177var fileDescriptor_any_744b9ca530f228db = []byte{ 186var fileDescriptor_b53526c13ae22eb4 = []byte{
178 // 185 bytes of a gzipped FileDescriptorProto 187 // 185 bytes of a gzipped FileDescriptorProto
179 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4c, 0xcf, 0xcf, 0x4f, 188 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4c, 0xcf, 0xcf, 0x4f,
180 0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0xcc, 0xab, 0xd4, 189 0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0xcc, 0xab, 0xd4,
diff --git a/vendor/github.com/golang/protobuf/ptypes/any/any.proto b/vendor/github.com/golang/protobuf/ptypes/any/any.proto
index c748667..4932942 100644
--- a/vendor/github.com/golang/protobuf/ptypes/any/any.proto
+++ b/vendor/github.com/golang/protobuf/ptypes/any/any.proto
@@ -120,17 +120,18 @@ option objc_class_prefix = "GPB";
120// } 120// }
121// 121//
122message Any { 122message Any {
123 // A URL/resource name whose content describes the type of the 123 // A URL/resource name that uniquely identifies the type of the serialized
124 // serialized protocol buffer message. 124 // protocol buffer message. The last segment of the URL's path must represent
125 // the fully qualified name of the type (as in
126 // `path/google.protobuf.Duration`). The name should be in a canonical form
127 // (e.g., leading "." is not accepted).
125 // 128 //
126 // For URLs which use the scheme `http`, `https`, or no scheme, the 129 // In practice, teams usually precompile into the binary all types that they
127 // following restrictions and interpretations apply: 130 // expect it to use in the context of Any. However, for URLs which use the
131 // scheme `http`, `https`, or no scheme, one can optionally set up a type
132 // server that maps type URLs to message definitions as follows:
128 // 133 //
129 // * If no scheme is provided, `https` is assumed. 134 // * If no scheme is provided, `https` is assumed.
130 // * The last segment of the URL's path must represent the fully
131 // qualified name of the type (as in `path/google.protobuf.Duration`).
132 // The name should be in a canonical form (e.g., leading "." is
133 // not accepted).
134 // * An HTTP GET on the URL must yield a [google.protobuf.Type][] 135 // * An HTTP GET on the URL must yield a [google.protobuf.Type][]
135 // value in binary format, or produce an error. 136 // value in binary format, or produce an error.
136 // * Applications are allowed to cache lookup results based on the 137 // * Applications are allowed to cache lookup results based on the
@@ -139,6 +140,10 @@ message Any {
139 // on changes to types. (Use versioned type names to manage 140 // on changes to types. (Use versioned type names to manage
140 // breaking changes.) 141 // breaking changes.)
141 // 142 //
143 // Note: this functionality is not currently available in the official
144 // protobuf release, and it is not used for type URLs beginning with
145 // type.googleapis.com.
146 //
142 // Schemes other than `http`, `https` (or the empty scheme) might be 147 // Schemes other than `http`, `https` (or the empty scheme) might be
143 // used with implementation specific semantics. 148 // used with implementation specific semantics.
144 // 149 //
diff --git a/vendor/github.com/golang/protobuf/ptypes/duration.go b/vendor/github.com/golang/protobuf/ptypes/duration.go
index 65cb0f8..26d1ca2 100644
--- a/vendor/github.com/golang/protobuf/ptypes/duration.go
+++ b/vendor/github.com/golang/protobuf/ptypes/duration.go
@@ -82,7 +82,7 @@ func Duration(p *durpb.Duration) (time.Duration, error) {
82 return 0, fmt.Errorf("duration: %v is out of range for time.Duration", p) 82 return 0, fmt.Errorf("duration: %v is out of range for time.Duration", p)
83 } 83 }
84 if p.Nanos != 0 { 84 if p.Nanos != 0 {
85 d += time.Duration(p.Nanos) 85 d += time.Duration(p.Nanos) * time.Nanosecond
86 if (d < 0) != (p.Nanos < 0) { 86 if (d < 0) != (p.Nanos < 0) {
87 return 0, fmt.Errorf("duration: %v is out of range for time.Duration", p) 87 return 0, fmt.Errorf("duration: %v is out of range for time.Duration", p)
88 } 88 }
diff --git a/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go b/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go
index a7beb2c..0d681ee 100644
--- a/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go
+++ b/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go
@@ -1,11 +1,13 @@
1// Code generated by protoc-gen-go. DO NOT EDIT. 1// Code generated by protoc-gen-go. DO NOT EDIT.
2// source: google/protobuf/duration.proto 2// source: google/protobuf/duration.proto
3 3
4package duration // import "github.com/golang/protobuf/ptypes/duration" 4package duration
5 5
6import proto "github.com/golang/protobuf/proto" 6import (
7import fmt "fmt" 7 fmt "fmt"
8import math "math" 8 proto "github.com/golang/protobuf/proto"
9 math "math"
10)
9 11
10// Reference imports to suppress errors if they are not otherwise used. 12// Reference imports to suppress errors if they are not otherwise used.
11var _ = proto.Marshal 13var _ = proto.Marshal
@@ -16,7 +18,7 @@ var _ = math.Inf
16// is compatible with the proto package it is being compiled against. 18// is compatible with the proto package it is being compiled against.
17// A compilation error at this line likely means your copy of the 19// A compilation error at this line likely means your copy of the
18// proto package needs to be updated. 20// proto package needs to be updated.
19const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package 21const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
20 22
21// A Duration represents a signed, fixed-length span of time represented 23// A Duration represents a signed, fixed-length span of time represented
22// as a count of seconds and fractions of seconds at nanosecond 24// as a count of seconds and fractions of seconds at nanosecond
@@ -99,17 +101,19 @@ func (m *Duration) Reset() { *m = Duration{} }
99func (m *Duration) String() string { return proto.CompactTextString(m) } 101func (m *Duration) String() string { return proto.CompactTextString(m) }
100func (*Duration) ProtoMessage() {} 102func (*Duration) ProtoMessage() {}
101func (*Duration) Descriptor() ([]byte, []int) { 103func (*Duration) Descriptor() ([]byte, []int) {
102 return fileDescriptor_duration_e7d612259e3f0613, []int{0} 104 return fileDescriptor_23597b2ebd7ac6c5, []int{0}
103} 105}
106
104func (*Duration) XXX_WellKnownType() string { return "Duration" } 107func (*Duration) XXX_WellKnownType() string { return "Duration" }
108
105func (m *Duration) XXX_Unmarshal(b []byte) error { 109func (m *Duration) XXX_Unmarshal(b []byte) error {
106 return xxx_messageInfo_Duration.Unmarshal(m, b) 110 return xxx_messageInfo_Duration.Unmarshal(m, b)
107} 111}
108func (m *Duration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 112func (m *Duration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
109 return xxx_messageInfo_Duration.Marshal(b, m, deterministic) 113 return xxx_messageInfo_Duration.Marshal(b, m, deterministic)
110} 114}
111func (dst *Duration) XXX_Merge(src proto.Message) { 115func (m *Duration) XXX_Merge(src proto.Message) {
112 xxx_messageInfo_Duration.Merge(dst, src) 116 xxx_messageInfo_Duration.Merge(m, src)
113} 117}
114func (m *Duration) XXX_Size() int { 118func (m *Duration) XXX_Size() int {
115 return xxx_messageInfo_Duration.Size(m) 119 return xxx_messageInfo_Duration.Size(m)
@@ -138,11 +142,9 @@ func init() {
138 proto.RegisterType((*Duration)(nil), "google.protobuf.Duration") 142 proto.RegisterType((*Duration)(nil), "google.protobuf.Duration")
139} 143}
140 144
141func init() { 145func init() { proto.RegisterFile("google/protobuf/duration.proto", fileDescriptor_23597b2ebd7ac6c5) }
142 proto.RegisterFile("google/protobuf/duration.proto", fileDescriptor_duration_e7d612259e3f0613)
143}
144 146
145var fileDescriptor_duration_e7d612259e3f0613 = []byte{ 147var fileDescriptor_23597b2ebd7ac6c5 = []byte{
146 // 190 bytes of a gzipped FileDescriptorProto 148 // 190 bytes of a gzipped FileDescriptorProto
147 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xcf, 0xcf, 0x4f, 149 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xcf, 0xcf, 0x4f,
148 0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0x29, 0x2d, 0x4a, 150 0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0x29, 0x2d, 0x4a,
diff --git a/vendor/github.com/golang/protobuf/ptypes/timestamp.go b/vendor/github.com/golang/protobuf/ptypes/timestamp.go
index 47f10db..8da0df0 100644
--- a/vendor/github.com/golang/protobuf/ptypes/timestamp.go
+++ b/vendor/github.com/golang/protobuf/ptypes/timestamp.go
@@ -111,11 +111,9 @@ func TimestampNow() *tspb.Timestamp {
111// TimestampProto converts the time.Time to a google.protobuf.Timestamp proto. 111// TimestampProto converts the time.Time to a google.protobuf.Timestamp proto.
112// It returns an error if the resulting Timestamp is invalid. 112// It returns an error if the resulting Timestamp is invalid.
113func TimestampProto(t time.Time) (*tspb.Timestamp, error) { 113func TimestampProto(t time.Time) (*tspb.Timestamp, error) {
114 seconds := t.Unix()
115 nanos := int32(t.Sub(time.Unix(seconds, 0)))
116 ts := &tspb.Timestamp{ 114 ts := &tspb.Timestamp{
117 Seconds: seconds, 115 Seconds: t.Unix(),
118 Nanos: nanos, 116 Nanos: int32(t.Nanosecond()),
119 } 117 }
120 if err := validateTimestamp(ts); err != nil { 118 if err := validateTimestamp(ts); err != nil {
121 return nil, err 119 return nil, err
diff --git a/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go
index 8e76ae9..31cd846 100644
--- a/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go
+++ b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go
@@ -1,11 +1,13 @@
1// Code generated by protoc-gen-go. DO NOT EDIT. 1// Code generated by protoc-gen-go. DO NOT EDIT.
2// source: google/protobuf/timestamp.proto 2// source: google/protobuf/timestamp.proto
3 3
4package timestamp // import "github.com/golang/protobuf/ptypes/timestamp" 4package timestamp
5 5
6import proto "github.com/golang/protobuf/proto" 6import (
7import fmt "fmt" 7 fmt "fmt"
8import math "math" 8 proto "github.com/golang/protobuf/proto"
9 math "math"
10)
9 11
10// Reference imports to suppress errors if they are not otherwise used. 12// Reference imports to suppress errors if they are not otherwise used.
11var _ = proto.Marshal 13var _ = proto.Marshal
@@ -16,7 +18,7 @@ var _ = math.Inf
16// is compatible with the proto package it is being compiled against. 18// is compatible with the proto package it is being compiled against.
17// A compilation error at this line likely means your copy of the 19// A compilation error at this line likely means your copy of the
18// proto package needs to be updated. 20// proto package needs to be updated.
19const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package 21const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
20 22
21// A Timestamp represents a point in time independent of any time zone 23// A Timestamp represents a point in time independent of any time zone
22// or calendar, represented as seconds and fractions of seconds at 24// or calendar, represented as seconds and fractions of seconds at
@@ -81,7 +83,9 @@ const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
81// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional 83// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
82// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), 84// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
83// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone 85// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
84// is required, though only UTC (as indicated by "Z") is presently supported. 86// is required. A proto3 JSON serializer should always use UTC (as indicated by
87// "Z") when printing the Timestamp type and a proto3 JSON parser should be
88// able to accept both UTC and other timezones (as indicated by an offset).
85// 89//
86// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 90// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
87// 01:30 UTC on January 15, 2017. 91// 01:30 UTC on January 15, 2017.
@@ -92,8 +96,8 @@ const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
92// to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) 96// to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime)
93// with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one 97// with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one
94// can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( 98// can use the Joda Time's [`ISODateTimeFormat.dateTime()`](
95// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime--) 99// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime--
96// to obtain a formatter capable of generating timestamps in this format. 100// ) to obtain a formatter capable of generating timestamps in this format.
97// 101//
98// 102//
99type Timestamp struct { 103type Timestamp struct {
@@ -115,17 +119,19 @@ func (m *Timestamp) Reset() { *m = Timestamp{} }
115func (m *Timestamp) String() string { return proto.CompactTextString(m) } 119func (m *Timestamp) String() string { return proto.CompactTextString(m) }
116func (*Timestamp) ProtoMessage() {} 120func (*Timestamp) ProtoMessage() {}
117func (*Timestamp) Descriptor() ([]byte, []int) { 121func (*Timestamp) Descriptor() ([]byte, []int) {
118 return fileDescriptor_timestamp_b826e8e5fba671a8, []int{0} 122 return fileDescriptor_292007bbfe81227e, []int{0}
119} 123}
124
120func (*Timestamp) XXX_WellKnownType() string { return "Timestamp" } 125func (*Timestamp) XXX_WellKnownType() string { return "Timestamp" }
126
121func (m *Timestamp) XXX_Unmarshal(b []byte) error { 127func (m *Timestamp) XXX_Unmarshal(b []byte) error {
122 return xxx_messageInfo_Timestamp.Unmarshal(m, b) 128 return xxx_messageInfo_Timestamp.Unmarshal(m, b)
123} 129}
124func (m *Timestamp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 130func (m *Timestamp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
125 return xxx_messageInfo_Timestamp.Marshal(b, m, deterministic) 131 return xxx_messageInfo_Timestamp.Marshal(b, m, deterministic)
126} 132}
127func (dst *Timestamp) XXX_Merge(src proto.Message) { 133func (m *Timestamp) XXX_Merge(src proto.Message) {
128 xxx_messageInfo_Timestamp.Merge(dst, src) 134 xxx_messageInfo_Timestamp.Merge(m, src)
129} 135}
130func (m *Timestamp) XXX_Size() int { 136func (m *Timestamp) XXX_Size() int {
131 return xxx_messageInfo_Timestamp.Size(m) 137 return xxx_messageInfo_Timestamp.Size(m)
@@ -154,11 +160,9 @@ func init() {
154 proto.RegisterType((*Timestamp)(nil), "google.protobuf.Timestamp") 160 proto.RegisterType((*Timestamp)(nil), "google.protobuf.Timestamp")
155} 161}
156 162
157func init() { 163func init() { proto.RegisterFile("google/protobuf/timestamp.proto", fileDescriptor_292007bbfe81227e) }
158 proto.RegisterFile("google/protobuf/timestamp.proto", fileDescriptor_timestamp_b826e8e5fba671a8)
159}
160 164
161var fileDescriptor_timestamp_b826e8e5fba671a8 = []byte{ 165var fileDescriptor_292007bbfe81227e = []byte{
162 // 191 bytes of a gzipped FileDescriptorProto 166 // 191 bytes of a gzipped FileDescriptorProto
163 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4f, 0xcf, 0xcf, 0x4f, 167 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4f, 0xcf, 0xcf, 0x4f,
164 0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0xc9, 0xcc, 0x4d, 168 0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0xc9, 0xcc, 0x4d,
diff --git a/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
index 06750ab..eafb3fa 100644
--- a/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
+++ b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
@@ -103,7 +103,9 @@ option objc_class_prefix = "GPB";
103// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional 103// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
104// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), 104// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
105// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone 105// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
106// is required, though only UTC (as indicated by "Z") is presently supported. 106// is required. A proto3 JSON serializer should always use UTC (as indicated by
107// "Z") when printing the Timestamp type and a proto3 JSON parser should be
108// able to accept both UTC and other timezones (as indicated by an offset).
107// 109//
108// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 110// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
109// 01:30 UTC on January 15, 2017. 111// 01:30 UTC on January 15, 2017.
@@ -114,8 +116,8 @@ option objc_class_prefix = "GPB";
114// to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) 116// to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime)
115// with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one 117// with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one
116// can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( 118// can use the Joda Time's [`ISODateTimeFormat.dateTime()`](
117// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime--) 119// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime--
118// to obtain a formatter capable of generating timestamps in this format. 120// ) to obtain a formatter capable of generating timestamps in this format.
119// 121//
120// 122//
121message Timestamp { 123message Timestamp {
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-03 05:20:26 +0000