diff options
Diffstat (limited to 'vendor/github.com/golang/protobuf/protoc-gen-go')
-rw-r--r-- | vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go | 2887 | ||||
-rw-r--r-- | vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.proto | 883 |
2 files changed, 3770 insertions, 0 deletions
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 | |||
4 | package descriptor | ||
5 | |||
6 | import ( | ||
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. | ||
13 | var _ = proto.Marshal | ||
14 | var _ = fmt.Errorf | ||
15 | var _ = 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. | ||
21 | const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package | ||
22 | |||
23 | type FieldDescriptorProto_Type int32 | ||
24 | |||
25 | const ( | ||
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 | |||
57 | var 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 | |||
78 | var 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 | |||
99 | func (x FieldDescriptorProto_Type) Enum() *FieldDescriptorProto_Type { | ||
100 | p := new(FieldDescriptorProto_Type) | ||
101 | *p = x | ||
102 | return p | ||
103 | } | ||
104 | |||
105 | func (x FieldDescriptorProto_Type) String() string { | ||
106 | return proto.EnumName(FieldDescriptorProto_Type_name, int32(x)) | ||
107 | } | ||
108 | |||
109 | func (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 | |||
118 | func (FieldDescriptorProto_Type) EnumDescriptor() ([]byte, []int) { | ||
119 | return fileDescriptor_e5baabe45344a177, []int{4, 0} | ||
120 | } | ||
121 | |||
122 | type FieldDescriptorProto_Label int32 | ||
123 | |||
124 | const ( | ||
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 | |||
131 | var FieldDescriptorProto_Label_name = map[int32]string{ | ||
132 | 1: "LABEL_OPTIONAL", | ||
133 | 2: "LABEL_REQUIRED", | ||
134 | 3: "LABEL_REPEATED", | ||
135 | } | ||
136 | |||
137 | var FieldDescriptorProto_Label_value = map[string]int32{ | ||
138 | "LABEL_OPTIONAL": 1, | ||
139 | "LABEL_REQUIRED": 2, | ||
140 | "LABEL_REPEATED": 3, | ||
141 | } | ||
142 | |||
143 | func (x FieldDescriptorProto_Label) Enum() *FieldDescriptorProto_Label { | ||
144 | p := new(FieldDescriptorProto_Label) | ||
145 | *p = x | ||
146 | return p | ||
147 | } | ||
148 | |||
149 | func (x FieldDescriptorProto_Label) String() string { | ||
150 | return proto.EnumName(FieldDescriptorProto_Label_name, int32(x)) | ||
151 | } | ||
152 | |||
153 | func (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 | |||
162 | func (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. | ||
167 | type FileOptions_OptimizeMode int32 | ||
168 | |||
169 | const ( | ||
170 | FileOptions_SPEED FileOptions_OptimizeMode = 1 | ||
171 | // etc. | ||
172 | FileOptions_CODE_SIZE FileOptions_OptimizeMode = 2 | ||
173 | FileOptions_LITE_RUNTIME FileOptions_OptimizeMode = 3 | ||
174 | ) | ||
175 | |||
176 | var FileOptions_OptimizeMode_name = map[int32]string{ | ||
177 | 1: "SPEED", | ||
178 | 2: "CODE_SIZE", | ||
179 | 3: "LITE_RUNTIME", | ||
180 | } | ||
181 | |||
182 | var FileOptions_OptimizeMode_value = map[string]int32{ | ||
183 | "SPEED": 1, | ||
184 | "CODE_SIZE": 2, | ||
185 | "LITE_RUNTIME": 3, | ||
186 | } | ||
187 | |||
188 | func (x FileOptions_OptimizeMode) Enum() *FileOptions_OptimizeMode { | ||
189 | p := new(FileOptions_OptimizeMode) | ||
190 | *p = x | ||
191 | return p | ||
192 | } | ||
193 | |||
194 | func (x FileOptions_OptimizeMode) String() string { | ||
195 | return proto.EnumName(FileOptions_OptimizeMode_name, int32(x)) | ||
196 | } | ||
197 | |||
198 | func (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 | |||
207 | func (FileOptions_OptimizeMode) EnumDescriptor() ([]byte, []int) { | ||
208 | return fileDescriptor_e5baabe45344a177, []int{10, 0} | ||
209 | } | ||
210 | |||
211 | type FieldOptions_CType int32 | ||
212 | |||
213 | const ( | ||
214 | // Default mode. | ||
215 | FieldOptions_STRING FieldOptions_CType = 0 | ||
216 | FieldOptions_CORD FieldOptions_CType = 1 | ||
217 | FieldOptions_STRING_PIECE FieldOptions_CType = 2 | ||
218 | ) | ||
219 | |||
220 | var FieldOptions_CType_name = map[int32]string{ | ||
221 | 0: "STRING", | ||
222 | 1: "CORD", | ||
223 | 2: "STRING_PIECE", | ||
224 | } | ||
225 | |||
226 | var FieldOptions_CType_value = map[string]int32{ | ||
227 | "STRING": 0, | ||
228 | "CORD": 1, | ||
229 | "STRING_PIECE": 2, | ||
230 | } | ||
231 | |||
232 | func (x FieldOptions_CType) Enum() *FieldOptions_CType { | ||
233 | p := new(FieldOptions_CType) | ||
234 | *p = x | ||
235 | return p | ||
236 | } | ||
237 | |||
238 | func (x FieldOptions_CType) String() string { | ||
239 | return proto.EnumName(FieldOptions_CType_name, int32(x)) | ||
240 | } | ||
241 | |||
242 | func (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 | |||
251 | func (FieldOptions_CType) EnumDescriptor() ([]byte, []int) { | ||
252 | return fileDescriptor_e5baabe45344a177, []int{12, 0} | ||
253 | } | ||
254 | |||
255 | type FieldOptions_JSType int32 | ||
256 | |||
257 | const ( | ||
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 | |||
266 | var FieldOptions_JSType_name = map[int32]string{ | ||
267 | 0: "JS_NORMAL", | ||
268 | 1: "JS_STRING", | ||
269 | 2: "JS_NUMBER", | ||
270 | } | ||
271 | |||
272 | var FieldOptions_JSType_value = map[string]int32{ | ||
273 | "JS_NORMAL": 0, | ||
274 | "JS_STRING": 1, | ||
275 | "JS_NUMBER": 2, | ||
276 | } | ||
277 | |||
278 | func (x FieldOptions_JSType) Enum() *FieldOptions_JSType { | ||
279 | p := new(FieldOptions_JSType) | ||
280 | *p = x | ||
281 | return p | ||
282 | } | ||
283 | |||
284 | func (x FieldOptions_JSType) String() string { | ||
285 | return proto.EnumName(FieldOptions_JSType_name, int32(x)) | ||
286 | } | ||
287 | |||
288 | func (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 | |||
297 | func (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. | ||
304 | type MethodOptions_IdempotencyLevel int32 | ||
305 | |||
306 | const ( | ||
307 | MethodOptions_IDEMPOTENCY_UNKNOWN MethodOptions_IdempotencyLevel = 0 | ||
308 | MethodOptions_NO_SIDE_EFFECTS MethodOptions_IdempotencyLevel = 1 | ||
309 | MethodOptions_IDEMPOTENT MethodOptions_IdempotencyLevel = 2 | ||
310 | ) | ||
311 | |||
312 | var MethodOptions_IdempotencyLevel_name = map[int32]string{ | ||
313 | 0: "IDEMPOTENCY_UNKNOWN", | ||
314 | 1: "NO_SIDE_EFFECTS", | ||
315 | 2: "IDEMPOTENT", | ||
316 | } | ||
317 | |||
318 | var MethodOptions_IdempotencyLevel_value = map[string]int32{ | ||
319 | "IDEMPOTENCY_UNKNOWN": 0, | ||
320 | "NO_SIDE_EFFECTS": 1, | ||
321 | "IDEMPOTENT": 2, | ||
322 | } | ||
323 | |||
324 | func (x MethodOptions_IdempotencyLevel) Enum() *MethodOptions_IdempotencyLevel { | ||
325 | p := new(MethodOptions_IdempotencyLevel) | ||
326 | *p = x | ||
327 | return p | ||
328 | } | ||
329 | |||
330 | func (x MethodOptions_IdempotencyLevel) String() string { | ||
331 | return proto.EnumName(MethodOptions_IdempotencyLevel_name, int32(x)) | ||
332 | } | ||
333 | |||
334 | func (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 | |||
343 | func (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. | ||
349 | type 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 | |||
356 | func (m *FileDescriptorSet) Reset() { *m = FileDescriptorSet{} } | ||
357 | func (m *FileDescriptorSet) String() string { return proto.CompactTextString(m) } | ||
358 | func (*FileDescriptorSet) ProtoMessage() {} | ||
359 | func (*FileDescriptorSet) Descriptor() ([]byte, []int) { | ||
360 | return fileDescriptor_e5baabe45344a177, []int{0} | ||
361 | } | ||
362 | |||
363 | func (m *FileDescriptorSet) XXX_Unmarshal(b []byte) error { | ||
364 | return xxx_messageInfo_FileDescriptorSet.Unmarshal(m, b) | ||
365 | } | ||
366 | func (m *FileDescriptorSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
367 | return xxx_messageInfo_FileDescriptorSet.Marshal(b, m, deterministic) | ||
368 | } | ||
369 | func (m *FileDescriptorSet) XXX_Merge(src proto.Message) { | ||
370 | xxx_messageInfo_FileDescriptorSet.Merge(m, src) | ||
371 | } | ||
372 | func (m *FileDescriptorSet) XXX_Size() int { | ||
373 | return xxx_messageInfo_FileDescriptorSet.Size(m) | ||
374 | } | ||
375 | func (m *FileDescriptorSet) XXX_DiscardUnknown() { | ||
376 | xxx_messageInfo_FileDescriptorSet.DiscardUnknown(m) | ||
377 | } | ||
378 | |||
379 | var xxx_messageInfo_FileDescriptorSet proto.InternalMessageInfo | ||
380 | |||
381 | func (m *FileDescriptorSet) GetFile() []*FileDescriptorProto { | ||
382 | if m != nil { | ||
383 | return m.File | ||
384 | } | ||
385 | return nil | ||
386 | } | ||
387 | |||
388 | // Describes a complete .proto file. | ||
389 | type 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 | |||
418 | func (m *FileDescriptorProto) Reset() { *m = FileDescriptorProto{} } | ||
419 | func (m *FileDescriptorProto) String() string { return proto.CompactTextString(m) } | ||
420 | func (*FileDescriptorProto) ProtoMessage() {} | ||
421 | func (*FileDescriptorProto) Descriptor() ([]byte, []int) { | ||
422 | return fileDescriptor_e5baabe45344a177, []int{1} | ||
423 | } | ||
424 | |||
425 | func (m *FileDescriptorProto) XXX_Unmarshal(b []byte) error { | ||
426 | return xxx_messageInfo_FileDescriptorProto.Unmarshal(m, b) | ||
427 | } | ||
428 | func (m *FileDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
429 | return xxx_messageInfo_FileDescriptorProto.Marshal(b, m, deterministic) | ||
430 | } | ||
431 | func (m *FileDescriptorProto) XXX_Merge(src proto.Message) { | ||
432 | xxx_messageInfo_FileDescriptorProto.Merge(m, src) | ||
433 | } | ||
434 | func (m *FileDescriptorProto) XXX_Size() int { | ||
435 | return xxx_messageInfo_FileDescriptorProto.Size(m) | ||
436 | } | ||
437 | func (m *FileDescriptorProto) XXX_DiscardUnknown() { | ||
438 | xxx_messageInfo_FileDescriptorProto.DiscardUnknown(m) | ||
439 | } | ||
440 | |||
441 | var xxx_messageInfo_FileDescriptorProto proto.InternalMessageInfo | ||
442 | |||
443 | func (m *FileDescriptorProto) GetName() string { | ||
444 | if m != nil && m.Name != nil { | ||
445 | return *m.Name | ||
446 | } | ||
447 | return "" | ||
448 | } | ||
449 | |||
450 | func (m *FileDescriptorProto) GetPackage() string { | ||
451 | if m != nil && m.Package != nil { | ||
452 | return *m.Package | ||
453 | } | ||
454 | return "" | ||
455 | } | ||
456 | |||
457 | func (m *FileDescriptorProto) GetDependency() []string { | ||
458 | if m != nil { | ||
459 | return m.Dependency | ||
460 | } | ||
461 | return nil | ||
462 | } | ||
463 | |||
464 | func (m *FileDescriptorProto) GetPublicDependency() []int32 { | ||
465 | if m != nil { | ||
466 | return m.PublicDependency | ||
467 | } | ||
468 | return nil | ||
469 | } | ||
470 | |||
471 | func (m *FileDescriptorProto) GetWeakDependency() []int32 { | ||
472 | if m != nil { | ||
473 | return m.WeakDependency | ||
474 | } | ||
475 | return nil | ||
476 | } | ||
477 | |||
478 | func (m *FileDescriptorProto) GetMessageType() []*DescriptorProto { | ||
479 | if m != nil { | ||
480 | return m.MessageType | ||
481 | } | ||
482 | return nil | ||
483 | } | ||
484 | |||
485 | func (m *FileDescriptorProto) GetEnumType() []*EnumDescriptorProto { | ||
486 | if m != nil { | ||
487 | return m.EnumType | ||
488 | } | ||
489 | return nil | ||
490 | } | ||
491 | |||
492 | func (m *FileDescriptorProto) GetService() []*ServiceDescriptorProto { | ||
493 | if m != nil { | ||
494 | return m.Service | ||
495 | } | ||
496 | return nil | ||
497 | } | ||
498 | |||
499 | func (m *FileDescriptorProto) GetExtension() []*FieldDescriptorProto { | ||
500 | if m != nil { | ||
501 | return m.Extension | ||
502 | } | ||
503 | return nil | ||
504 | } | ||
505 | |||
506 | func (m *FileDescriptorProto) GetOptions() *FileOptions { | ||
507 | if m != nil { | ||
508 | return m.Options | ||
509 | } | ||
510 | return nil | ||
511 | } | ||
512 | |||
513 | func (m *FileDescriptorProto) GetSourceCodeInfo() *SourceCodeInfo { | ||
514 | if m != nil { | ||
515 | return m.SourceCodeInfo | ||
516 | } | ||
517 | return nil | ||
518 | } | ||
519 | |||
520 | func (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. | ||
528 | type 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 | |||
546 | func (m *DescriptorProto) Reset() { *m = DescriptorProto{} } | ||
547 | func (m *DescriptorProto) String() string { return proto.CompactTextString(m) } | ||
548 | func (*DescriptorProto) ProtoMessage() {} | ||
549 | func (*DescriptorProto) Descriptor() ([]byte, []int) { | ||
550 | return fileDescriptor_e5baabe45344a177, []int{2} | ||
551 | } | ||
552 | |||
553 | func (m *DescriptorProto) XXX_Unmarshal(b []byte) error { | ||
554 | return xxx_messageInfo_DescriptorProto.Unmarshal(m, b) | ||
555 | } | ||
556 | func (m *DescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
557 | return xxx_messageInfo_DescriptorProto.Marshal(b, m, deterministic) | ||
558 | } | ||
559 | func (m *DescriptorProto) XXX_Merge(src proto.Message) { | ||
560 | xxx_messageInfo_DescriptorProto.Merge(m, src) | ||
561 | } | ||
562 | func (m *DescriptorProto) XXX_Size() int { | ||
563 | return xxx_messageInfo_DescriptorProto.Size(m) | ||
564 | } | ||
565 | func (m *DescriptorProto) XXX_DiscardUnknown() { | ||
566 | xxx_messageInfo_DescriptorProto.DiscardUnknown(m) | ||
567 | } | ||
568 | |||
569 | var xxx_messageInfo_DescriptorProto proto.InternalMessageInfo | ||
570 | |||
571 | func (m *DescriptorProto) GetName() string { | ||
572 | if m != nil && m.Name != nil { | ||
573 | return *m.Name | ||
574 | } | ||
575 | return "" | ||
576 | } | ||
577 | |||
578 | func (m *DescriptorProto) GetField() []*FieldDescriptorProto { | ||
579 | if m != nil { | ||
580 | return m.Field | ||
581 | } | ||
582 | return nil | ||
583 | } | ||
584 | |||
585 | func (m *DescriptorProto) GetExtension() []*FieldDescriptorProto { | ||
586 | if m != nil { | ||
587 | return m.Extension | ||
588 | } | ||
589 | return nil | ||
590 | } | ||
591 | |||
592 | func (m *DescriptorProto) GetNestedType() []*DescriptorProto { | ||
593 | if m != nil { | ||
594 | return m.NestedType | ||
595 | } | ||
596 | return nil | ||
597 | } | ||
598 | |||
599 | func (m *DescriptorProto) GetEnumType() []*EnumDescriptorProto { | ||
600 | if m != nil { | ||
601 | return m.EnumType | ||
602 | } | ||
603 | return nil | ||
604 | } | ||
605 | |||
606 | func (m *DescriptorProto) GetExtensionRange() []*DescriptorProto_ExtensionRange { | ||
607 | if m != nil { | ||
608 | return m.ExtensionRange | ||
609 | } | ||
610 | return nil | ||
611 | } | ||
612 | |||
613 | func (m *DescriptorProto) GetOneofDecl() []*OneofDescriptorProto { | ||
614 | if m != nil { | ||
615 | return m.OneofDecl | ||
616 | } | ||
617 | return nil | ||
618 | } | ||
619 | |||
620 | func (m *DescriptorProto) GetOptions() *MessageOptions { | ||
621 | if m != nil { | ||
622 | return m.Options | ||
623 | } | ||
624 | return nil | ||
625 | } | ||
626 | |||
627 | func (m *DescriptorProto) GetReservedRange() []*DescriptorProto_ReservedRange { | ||
628 | if m != nil { | ||
629 | return m.ReservedRange | ||
630 | } | ||
631 | return nil | ||
632 | } | ||
633 | |||
634 | func (m *DescriptorProto) GetReservedName() []string { | ||
635 | if m != nil { | ||
636 | return m.ReservedName | ||
637 | } | ||
638 | return nil | ||
639 | } | ||
640 | |||
641 | type 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 | |||
650 | func (m *DescriptorProto_ExtensionRange) Reset() { *m = DescriptorProto_ExtensionRange{} } | ||
651 | func (m *DescriptorProto_ExtensionRange) String() string { return proto.CompactTextString(m) } | ||
652 | func (*DescriptorProto_ExtensionRange) ProtoMessage() {} | ||
653 | func (*DescriptorProto_ExtensionRange) Descriptor() ([]byte, []int) { | ||
654 | return fileDescriptor_e5baabe45344a177, []int{2, 0} | ||
655 | } | ||
656 | |||
657 | func (m *DescriptorProto_ExtensionRange) XXX_Unmarshal(b []byte) error { | ||
658 | return xxx_messageInfo_DescriptorProto_ExtensionRange.Unmarshal(m, b) | ||
659 | } | ||
660 | func (m *DescriptorProto_ExtensionRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
661 | return xxx_messageInfo_DescriptorProto_ExtensionRange.Marshal(b, m, deterministic) | ||
662 | } | ||
663 | func (m *DescriptorProto_ExtensionRange) XXX_Merge(src proto.Message) { | ||
664 | xxx_messageInfo_DescriptorProto_ExtensionRange.Merge(m, src) | ||
665 | } | ||
666 | func (m *DescriptorProto_ExtensionRange) XXX_Size() int { | ||
667 | return xxx_messageInfo_DescriptorProto_ExtensionRange.Size(m) | ||
668 | } | ||
669 | func (m *DescriptorProto_ExtensionRange) XXX_DiscardUnknown() { | ||
670 | xxx_messageInfo_DescriptorProto_ExtensionRange.DiscardUnknown(m) | ||
671 | } | ||
672 | |||
673 | var xxx_messageInfo_DescriptorProto_ExtensionRange proto.InternalMessageInfo | ||
674 | |||
675 | func (m *DescriptorProto_ExtensionRange) GetStart() int32 { | ||
676 | if m != nil && m.Start != nil { | ||
677 | return *m.Start | ||
678 | } | ||
679 | return 0 | ||
680 | } | ||
681 | |||
682 | func (m *DescriptorProto_ExtensionRange) GetEnd() int32 { | ||
683 | if m != nil && m.End != nil { | ||
684 | return *m.End | ||
685 | } | ||
686 | return 0 | ||
687 | } | ||
688 | |||
689 | func (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. | ||
699 | type 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 | |||
707 | func (m *DescriptorProto_ReservedRange) Reset() { *m = DescriptorProto_ReservedRange{} } | ||
708 | func (m *DescriptorProto_ReservedRange) String() string { return proto.CompactTextString(m) } | ||
709 | func (*DescriptorProto_ReservedRange) ProtoMessage() {} | ||
710 | func (*DescriptorProto_ReservedRange) Descriptor() ([]byte, []int) { | ||
711 | return fileDescriptor_e5baabe45344a177, []int{2, 1} | ||
712 | } | ||
713 | |||
714 | func (m *DescriptorProto_ReservedRange) XXX_Unmarshal(b []byte) error { | ||
715 | return xxx_messageInfo_DescriptorProto_ReservedRange.Unmarshal(m, b) | ||
716 | } | ||
717 | func (m *DescriptorProto_ReservedRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
718 | return xxx_messageInfo_DescriptorProto_ReservedRange.Marshal(b, m, deterministic) | ||
719 | } | ||
720 | func (m *DescriptorProto_ReservedRange) XXX_Merge(src proto.Message) { | ||
721 | xxx_messageInfo_DescriptorProto_ReservedRange.Merge(m, src) | ||
722 | } | ||
723 | func (m *DescriptorProto_ReservedRange) XXX_Size() int { | ||
724 | return xxx_messageInfo_DescriptorProto_ReservedRange.Size(m) | ||
725 | } | ||
726 | func (m *DescriptorProto_ReservedRange) XXX_DiscardUnknown() { | ||
727 | xxx_messageInfo_DescriptorProto_ReservedRange.DiscardUnknown(m) | ||
728 | } | ||
729 | |||
730 | var xxx_messageInfo_DescriptorProto_ReservedRange proto.InternalMessageInfo | ||
731 | |||
732 | func (m *DescriptorProto_ReservedRange) GetStart() int32 { | ||
733 | if m != nil && m.Start != nil { | ||
734 | return *m.Start | ||
735 | } | ||
736 | return 0 | ||
737 | } | ||
738 | |||
739 | func (m *DescriptorProto_ReservedRange) GetEnd() int32 { | ||
740 | if m != nil && m.End != nil { | ||
741 | return *m.End | ||
742 | } | ||
743 | return 0 | ||
744 | } | ||
745 | |||
746 | type 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 | |||
755 | func (m *ExtensionRangeOptions) Reset() { *m = ExtensionRangeOptions{} } | ||
756 | func (m *ExtensionRangeOptions) String() string { return proto.CompactTextString(m) } | ||
757 | func (*ExtensionRangeOptions) ProtoMessage() {} | ||
758 | func (*ExtensionRangeOptions) Descriptor() ([]byte, []int) { | ||
759 | return fileDescriptor_e5baabe45344a177, []int{3} | ||
760 | } | ||
761 | |||
762 | var extRange_ExtensionRangeOptions = []proto.ExtensionRange{ | ||
763 | {Start: 1000, End: 536870911}, | ||
764 | } | ||
765 | |||
766 | func (*ExtensionRangeOptions) ExtensionRangeArray() []proto.ExtensionRange { | ||
767 | return extRange_ExtensionRangeOptions | ||
768 | } | ||
769 | |||
770 | func (m *ExtensionRangeOptions) XXX_Unmarshal(b []byte) error { | ||
771 | return xxx_messageInfo_ExtensionRangeOptions.Unmarshal(m, b) | ||
772 | } | ||
773 | func (m *ExtensionRangeOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
774 | return xxx_messageInfo_ExtensionRangeOptions.Marshal(b, m, deterministic) | ||
775 | } | ||
776 | func (m *ExtensionRangeOptions) XXX_Merge(src proto.Message) { | ||
777 | xxx_messageInfo_ExtensionRangeOptions.Merge(m, src) | ||
778 | } | ||
779 | func (m *ExtensionRangeOptions) XXX_Size() int { | ||
780 | return xxx_messageInfo_ExtensionRangeOptions.Size(m) | ||
781 | } | ||
782 | func (m *ExtensionRangeOptions) XXX_DiscardUnknown() { | ||
783 | xxx_messageInfo_ExtensionRangeOptions.DiscardUnknown(m) | ||
784 | } | ||
785 | |||
786 | var xxx_messageInfo_ExtensionRangeOptions proto.InternalMessageInfo | ||
787 | |||
788 | func (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. | ||
796 | type 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 | |||
832 | func (m *FieldDescriptorProto) Reset() { *m = FieldDescriptorProto{} } | ||
833 | func (m *FieldDescriptorProto) String() string { return proto.CompactTextString(m) } | ||
834 | func (*FieldDescriptorProto) ProtoMessage() {} | ||
835 | func (*FieldDescriptorProto) Descriptor() ([]byte, []int) { | ||
836 | return fileDescriptor_e5baabe45344a177, []int{4} | ||
837 | } | ||
838 | |||
839 | func (m *FieldDescriptorProto) XXX_Unmarshal(b []byte) error { | ||
840 | return xxx_messageInfo_FieldDescriptorProto.Unmarshal(m, b) | ||
841 | } | ||
842 | func (m *FieldDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
843 | return xxx_messageInfo_FieldDescriptorProto.Marshal(b, m, deterministic) | ||
844 | } | ||
845 | func (m *FieldDescriptorProto) XXX_Merge(src proto.Message) { | ||
846 | xxx_messageInfo_FieldDescriptorProto.Merge(m, src) | ||
847 | } | ||
848 | func (m *FieldDescriptorProto) XXX_Size() int { | ||
849 | return xxx_messageInfo_FieldDescriptorProto.Size(m) | ||
850 | } | ||
851 | func (m *FieldDescriptorProto) XXX_DiscardUnknown() { | ||
852 | xxx_messageInfo_FieldDescriptorProto.DiscardUnknown(m) | ||
853 | } | ||
854 | |||
855 | var xxx_messageInfo_FieldDescriptorProto proto.InternalMessageInfo | ||
856 | |||
857 | func (m *FieldDescriptorProto) GetName() string { | ||
858 | if m != nil && m.Name != nil { | ||
859 | return *m.Name | ||
860 | } | ||
861 | return "" | ||
862 | } | ||
863 | |||
864 | func (m *FieldDescriptorProto) GetNumber() int32 { | ||
865 | if m != nil && m.Number != nil { | ||
866 | return *m.Number | ||
867 | } | ||
868 | return 0 | ||
869 | } | ||
870 | |||
871 | func (m *FieldDescriptorProto) GetLabel() FieldDescriptorProto_Label { | ||
872 | if m != nil && m.Label != nil { | ||
873 | return *m.Label | ||
874 | } | ||
875 | return FieldDescriptorProto_LABEL_OPTIONAL | ||
876 | } | ||
877 | |||
878 | func (m *FieldDescriptorProto) GetType() FieldDescriptorProto_Type { | ||
879 | if m != nil && m.Type != nil { | ||
880 | return *m.Type | ||
881 | } | ||
882 | return FieldDescriptorProto_TYPE_DOUBLE | ||
883 | } | ||
884 | |||
885 | func (m *FieldDescriptorProto) GetTypeName() string { | ||
886 | if m != nil && m.TypeName != nil { | ||
887 | return *m.TypeName | ||
888 | } | ||
889 | return "" | ||
890 | } | ||
891 | |||
892 | func (m *FieldDescriptorProto) GetExtendee() string { | ||
893 | if m != nil && m.Extendee != nil { | ||
894 | return *m.Extendee | ||
895 | } | ||
896 | return "" | ||
897 | } | ||
898 | |||
899 | func (m *FieldDescriptorProto) GetDefaultValue() string { | ||
900 | if m != nil && m.DefaultValue != nil { | ||
901 | return *m.DefaultValue | ||
902 | } | ||
903 | return "" | ||
904 | } | ||
905 | |||
906 | func (m *FieldDescriptorProto) GetOneofIndex() int32 { | ||
907 | if m != nil && m.OneofIndex != nil { | ||
908 | return *m.OneofIndex | ||
909 | } | ||
910 | return 0 | ||
911 | } | ||
912 | |||
913 | func (m *FieldDescriptorProto) GetJsonName() string { | ||
914 | if m != nil && m.JsonName != nil { | ||
915 | return *m.JsonName | ||
916 | } | ||
917 | return "" | ||
918 | } | ||
919 | |||
920 | func (m *FieldDescriptorProto) GetOptions() *FieldOptions { | ||
921 | if m != nil { | ||
922 | return m.Options | ||
923 | } | ||
924 | return nil | ||
925 | } | ||
926 | |||
927 | // Describes a oneof. | ||
928 | type 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 | |||
936 | func (m *OneofDescriptorProto) Reset() { *m = OneofDescriptorProto{} } | ||
937 | func (m *OneofDescriptorProto) String() string { return proto.CompactTextString(m) } | ||
938 | func (*OneofDescriptorProto) ProtoMessage() {} | ||
939 | func (*OneofDescriptorProto) Descriptor() ([]byte, []int) { | ||
940 | return fileDescriptor_e5baabe45344a177, []int{5} | ||
941 | } | ||
942 | |||
943 | func (m *OneofDescriptorProto) XXX_Unmarshal(b []byte) error { | ||
944 | return xxx_messageInfo_OneofDescriptorProto.Unmarshal(m, b) | ||
945 | } | ||
946 | func (m *OneofDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
947 | return xxx_messageInfo_OneofDescriptorProto.Marshal(b, m, deterministic) | ||
948 | } | ||
949 | func (m *OneofDescriptorProto) XXX_Merge(src proto.Message) { | ||
950 | xxx_messageInfo_OneofDescriptorProto.Merge(m, src) | ||
951 | } | ||
952 | func (m *OneofDescriptorProto) XXX_Size() int { | ||
953 | return xxx_messageInfo_OneofDescriptorProto.Size(m) | ||
954 | } | ||
955 | func (m *OneofDescriptorProto) XXX_DiscardUnknown() { | ||
956 | xxx_messageInfo_OneofDescriptorProto.DiscardUnknown(m) | ||
957 | } | ||
958 | |||
959 | var xxx_messageInfo_OneofDescriptorProto proto.InternalMessageInfo | ||
960 | |||
961 | func (m *OneofDescriptorProto) GetName() string { | ||
962 | if m != nil && m.Name != nil { | ||
963 | return *m.Name | ||
964 | } | ||
965 | return "" | ||
966 | } | ||
967 | |||
968 | func (m *OneofDescriptorProto) GetOptions() *OneofOptions { | ||
969 | if m != nil { | ||
970 | return m.Options | ||
971 | } | ||
972 | return nil | ||
973 | } | ||
974 | |||
975 | // Describes an enum type. | ||
976 | type 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 | |||
992 | func (m *EnumDescriptorProto) Reset() { *m = EnumDescriptorProto{} } | ||
993 | func (m *EnumDescriptorProto) String() string { return proto.CompactTextString(m) } | ||
994 | func (*EnumDescriptorProto) ProtoMessage() {} | ||
995 | func (*EnumDescriptorProto) Descriptor() ([]byte, []int) { | ||
996 | return fileDescriptor_e5baabe45344a177, []int{6} | ||
997 | } | ||
998 | |||
999 | func (m *EnumDescriptorProto) XXX_Unmarshal(b []byte) error { | ||
1000 | return xxx_messageInfo_EnumDescriptorProto.Unmarshal(m, b) | ||
1001 | } | ||
1002 | func (m *EnumDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1003 | return xxx_messageInfo_EnumDescriptorProto.Marshal(b, m, deterministic) | ||
1004 | } | ||
1005 | func (m *EnumDescriptorProto) XXX_Merge(src proto.Message) { | ||
1006 | xxx_messageInfo_EnumDescriptorProto.Merge(m, src) | ||
1007 | } | ||
1008 | func (m *EnumDescriptorProto) XXX_Size() int { | ||
1009 | return xxx_messageInfo_EnumDescriptorProto.Size(m) | ||
1010 | } | ||
1011 | func (m *EnumDescriptorProto) XXX_DiscardUnknown() { | ||
1012 | xxx_messageInfo_EnumDescriptorProto.DiscardUnknown(m) | ||
1013 | } | ||
1014 | |||
1015 | var xxx_messageInfo_EnumDescriptorProto proto.InternalMessageInfo | ||
1016 | |||
1017 | func (m *EnumDescriptorProto) GetName() string { | ||
1018 | if m != nil && m.Name != nil { | ||
1019 | return *m.Name | ||
1020 | } | ||
1021 | return "" | ||
1022 | } | ||
1023 | |||
1024 | func (m *EnumDescriptorProto) GetValue() []*EnumValueDescriptorProto { | ||
1025 | if m != nil { | ||
1026 | return m.Value | ||
1027 | } | ||
1028 | return nil | ||
1029 | } | ||
1030 | |||
1031 | func (m *EnumDescriptorProto) GetOptions() *EnumOptions { | ||
1032 | if m != nil { | ||
1033 | return m.Options | ||
1034 | } | ||
1035 | return nil | ||
1036 | } | ||
1037 | |||
1038 | func (m *EnumDescriptorProto) GetReservedRange() []*EnumDescriptorProto_EnumReservedRange { | ||
1039 | if m != nil { | ||
1040 | return m.ReservedRange | ||
1041 | } | ||
1042 | return nil | ||
1043 | } | ||
1044 | |||
1045 | func (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. | ||
1058 | type 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 | |||
1066 | func (m *EnumDescriptorProto_EnumReservedRange) Reset() { *m = EnumDescriptorProto_EnumReservedRange{} } | ||
1067 | func (m *EnumDescriptorProto_EnumReservedRange) String() string { return proto.CompactTextString(m) } | ||
1068 | func (*EnumDescriptorProto_EnumReservedRange) ProtoMessage() {} | ||
1069 | func (*EnumDescriptorProto_EnumReservedRange) Descriptor() ([]byte, []int) { | ||
1070 | return fileDescriptor_e5baabe45344a177, []int{6, 0} | ||
1071 | } | ||
1072 | |||
1073 | func (m *EnumDescriptorProto_EnumReservedRange) XXX_Unmarshal(b []byte) error { | ||
1074 | return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Unmarshal(m, b) | ||
1075 | } | ||
1076 | func (m *EnumDescriptorProto_EnumReservedRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1077 | return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Marshal(b, m, deterministic) | ||
1078 | } | ||
1079 | func (m *EnumDescriptorProto_EnumReservedRange) XXX_Merge(src proto.Message) { | ||
1080 | xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Merge(m, src) | ||
1081 | } | ||
1082 | func (m *EnumDescriptorProto_EnumReservedRange) XXX_Size() int { | ||
1083 | return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Size(m) | ||
1084 | } | ||
1085 | func (m *EnumDescriptorProto_EnumReservedRange) XXX_DiscardUnknown() { | ||
1086 | xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.DiscardUnknown(m) | ||
1087 | } | ||
1088 | |||
1089 | var xxx_messageInfo_EnumDescriptorProto_EnumReservedRange proto.InternalMessageInfo | ||
1090 | |||
1091 | func (m *EnumDescriptorProto_EnumReservedRange) GetStart() int32 { | ||
1092 | if m != nil && m.Start != nil { | ||
1093 | return *m.Start | ||
1094 | } | ||
1095 | return 0 | ||
1096 | } | ||
1097 | |||
1098 | func (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. | ||
1106 | type 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 | |||
1115 | func (m *EnumValueDescriptorProto) Reset() { *m = EnumValueDescriptorProto{} } | ||
1116 | func (m *EnumValueDescriptorProto) String() string { return proto.CompactTextString(m) } | ||
1117 | func (*EnumValueDescriptorProto) ProtoMessage() {} | ||
1118 | func (*EnumValueDescriptorProto) Descriptor() ([]byte, []int) { | ||
1119 | return fileDescriptor_e5baabe45344a177, []int{7} | ||
1120 | } | ||
1121 | |||
1122 | func (m *EnumValueDescriptorProto) XXX_Unmarshal(b []byte) error { | ||
1123 | return xxx_messageInfo_EnumValueDescriptorProto.Unmarshal(m, b) | ||
1124 | } | ||
1125 | func (m *EnumValueDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1126 | return xxx_messageInfo_EnumValueDescriptorProto.Marshal(b, m, deterministic) | ||
1127 | } | ||
1128 | func (m *EnumValueDescriptorProto) XXX_Merge(src proto.Message) { | ||
1129 | xxx_messageInfo_EnumValueDescriptorProto.Merge(m, src) | ||
1130 | } | ||
1131 | func (m *EnumValueDescriptorProto) XXX_Size() int { | ||
1132 | return xxx_messageInfo_EnumValueDescriptorProto.Size(m) | ||
1133 | } | ||
1134 | func (m *EnumValueDescriptorProto) XXX_DiscardUnknown() { | ||
1135 | xxx_messageInfo_EnumValueDescriptorProto.DiscardUnknown(m) | ||
1136 | } | ||
1137 | |||
1138 | var xxx_messageInfo_EnumValueDescriptorProto proto.InternalMessageInfo | ||
1139 | |||
1140 | func (m *EnumValueDescriptorProto) GetName() string { | ||
1141 | if m != nil && m.Name != nil { | ||
1142 | return *m.Name | ||
1143 | } | ||
1144 | return "" | ||
1145 | } | ||
1146 | |||
1147 | func (m *EnumValueDescriptorProto) GetNumber() int32 { | ||
1148 | if m != nil && m.Number != nil { | ||
1149 | return *m.Number | ||
1150 | } | ||
1151 | return 0 | ||
1152 | } | ||
1153 | |||
1154 | func (m *EnumValueDescriptorProto) GetOptions() *EnumValueOptions { | ||
1155 | if m != nil { | ||
1156 | return m.Options | ||
1157 | } | ||
1158 | return nil | ||
1159 | } | ||
1160 | |||
1161 | // Describes a service. | ||
1162 | type 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 | |||
1171 | func (m *ServiceDescriptorProto) Reset() { *m = ServiceDescriptorProto{} } | ||
1172 | func (m *ServiceDescriptorProto) String() string { return proto.CompactTextString(m) } | ||
1173 | func (*ServiceDescriptorProto) ProtoMessage() {} | ||
1174 | func (*ServiceDescriptorProto) Descriptor() ([]byte, []int) { | ||
1175 | return fileDescriptor_e5baabe45344a177, []int{8} | ||
1176 | } | ||
1177 | |||
1178 | func (m *ServiceDescriptorProto) XXX_Unmarshal(b []byte) error { | ||
1179 | return xxx_messageInfo_ServiceDescriptorProto.Unmarshal(m, b) | ||
1180 | } | ||
1181 | func (m *ServiceDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1182 | return xxx_messageInfo_ServiceDescriptorProto.Marshal(b, m, deterministic) | ||
1183 | } | ||
1184 | func (m *ServiceDescriptorProto) XXX_Merge(src proto.Message) { | ||
1185 | xxx_messageInfo_ServiceDescriptorProto.Merge(m, src) | ||
1186 | } | ||
1187 | func (m *ServiceDescriptorProto) XXX_Size() int { | ||
1188 | return xxx_messageInfo_ServiceDescriptorProto.Size(m) | ||
1189 | } | ||
1190 | func (m *ServiceDescriptorProto) XXX_DiscardUnknown() { | ||
1191 | xxx_messageInfo_ServiceDescriptorProto.DiscardUnknown(m) | ||
1192 | } | ||
1193 | |||
1194 | var xxx_messageInfo_ServiceDescriptorProto proto.InternalMessageInfo | ||
1195 | |||
1196 | func (m *ServiceDescriptorProto) GetName() string { | ||
1197 | if m != nil && m.Name != nil { | ||
1198 | return *m.Name | ||
1199 | } | ||
1200 | return "" | ||
1201 | } | ||
1202 | |||
1203 | func (m *ServiceDescriptorProto) GetMethod() []*MethodDescriptorProto { | ||
1204 | if m != nil { | ||
1205 | return m.Method | ||
1206 | } | ||
1207 | return nil | ||
1208 | } | ||
1209 | |||
1210 | func (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. | ||
1218 | type 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 | |||
1234 | func (m *MethodDescriptorProto) Reset() { *m = MethodDescriptorProto{} } | ||
1235 | func (m *MethodDescriptorProto) String() string { return proto.CompactTextString(m) } | ||
1236 | func (*MethodDescriptorProto) ProtoMessage() {} | ||
1237 | func (*MethodDescriptorProto) Descriptor() ([]byte, []int) { | ||
1238 | return fileDescriptor_e5baabe45344a177, []int{9} | ||
1239 | } | ||
1240 | |||
1241 | func (m *MethodDescriptorProto) XXX_Unmarshal(b []byte) error { | ||
1242 | return xxx_messageInfo_MethodDescriptorProto.Unmarshal(m, b) | ||
1243 | } | ||
1244 | func (m *MethodDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1245 | return xxx_messageInfo_MethodDescriptorProto.Marshal(b, m, deterministic) | ||
1246 | } | ||
1247 | func (m *MethodDescriptorProto) XXX_Merge(src proto.Message) { | ||
1248 | xxx_messageInfo_MethodDescriptorProto.Merge(m, src) | ||
1249 | } | ||
1250 | func (m *MethodDescriptorProto) XXX_Size() int { | ||
1251 | return xxx_messageInfo_MethodDescriptorProto.Size(m) | ||
1252 | } | ||
1253 | func (m *MethodDescriptorProto) XXX_DiscardUnknown() { | ||
1254 | xxx_messageInfo_MethodDescriptorProto.DiscardUnknown(m) | ||
1255 | } | ||
1256 | |||
1257 | var xxx_messageInfo_MethodDescriptorProto proto.InternalMessageInfo | ||
1258 | |||
1259 | const Default_MethodDescriptorProto_ClientStreaming bool = false | ||
1260 | const Default_MethodDescriptorProto_ServerStreaming bool = false | ||
1261 | |||
1262 | func (m *MethodDescriptorProto) GetName() string { | ||
1263 | if m != nil && m.Name != nil { | ||
1264 | return *m.Name | ||
1265 | } | ||
1266 | return "" | ||
1267 | } | ||
1268 | |||
1269 | func (m *MethodDescriptorProto) GetInputType() string { | ||
1270 | if m != nil && m.InputType != nil { | ||
1271 | return *m.InputType | ||
1272 | } | ||
1273 | return "" | ||
1274 | } | ||
1275 | |||
1276 | func (m *MethodDescriptorProto) GetOutputType() string { | ||
1277 | if m != nil && m.OutputType != nil { | ||
1278 | return *m.OutputType | ||
1279 | } | ||
1280 | return "" | ||
1281 | } | ||
1282 | |||
1283 | func (m *MethodDescriptorProto) GetOptions() *MethodOptions { | ||
1284 | if m != nil { | ||
1285 | return m.Options | ||
1286 | } | ||
1287 | return nil | ||
1288 | } | ||
1289 | |||
1290 | func (m *MethodDescriptorProto) GetClientStreaming() bool { | ||
1291 | if m != nil && m.ClientStreaming != nil { | ||
1292 | return *m.ClientStreaming | ||
1293 | } | ||
1294 | return Default_MethodDescriptorProto_ClientStreaming | ||
1295 | } | ||
1296 | |||
1297 | func (m *MethodDescriptorProto) GetServerStreaming() bool { | ||
1298 | if m != nil && m.ServerStreaming != nil { | ||
1299 | return *m.ServerStreaming | ||
1300 | } | ||
1301 | return Default_MethodDescriptorProto_ServerStreaming | ||
1302 | } | ||
1303 | |||
1304 | type 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 | |||
1395 | func (m *FileOptions) Reset() { *m = FileOptions{} } | ||
1396 | func (m *FileOptions) String() string { return proto.CompactTextString(m) } | ||
1397 | func (*FileOptions) ProtoMessage() {} | ||
1398 | func (*FileOptions) Descriptor() ([]byte, []int) { | ||
1399 | return fileDescriptor_e5baabe45344a177, []int{10} | ||
1400 | } | ||
1401 | |||
1402 | var extRange_FileOptions = []proto.ExtensionRange{ | ||
1403 | {Start: 1000, End: 536870911}, | ||
1404 | } | ||
1405 | |||
1406 | func (*FileOptions) ExtensionRangeArray() []proto.ExtensionRange { | ||
1407 | return extRange_FileOptions | ||
1408 | } | ||
1409 | |||
1410 | func (m *FileOptions) XXX_Unmarshal(b []byte) error { | ||
1411 | return xxx_messageInfo_FileOptions.Unmarshal(m, b) | ||
1412 | } | ||
1413 | func (m *FileOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1414 | return xxx_messageInfo_FileOptions.Marshal(b, m, deterministic) | ||
1415 | } | ||
1416 | func (m *FileOptions) XXX_Merge(src proto.Message) { | ||
1417 | xxx_messageInfo_FileOptions.Merge(m, src) | ||
1418 | } | ||
1419 | func (m *FileOptions) XXX_Size() int { | ||
1420 | return xxx_messageInfo_FileOptions.Size(m) | ||
1421 | } | ||
1422 | func (m *FileOptions) XXX_DiscardUnknown() { | ||
1423 | xxx_messageInfo_FileOptions.DiscardUnknown(m) | ||
1424 | } | ||
1425 | |||
1426 | var xxx_messageInfo_FileOptions proto.InternalMessageInfo | ||
1427 | |||
1428 | const Default_FileOptions_JavaMultipleFiles bool = false | ||
1429 | const Default_FileOptions_JavaStringCheckUtf8 bool = false | ||
1430 | const Default_FileOptions_OptimizeFor FileOptions_OptimizeMode = FileOptions_SPEED | ||
1431 | const Default_FileOptions_CcGenericServices bool = false | ||
1432 | const Default_FileOptions_JavaGenericServices bool = false | ||
1433 | const Default_FileOptions_PyGenericServices bool = false | ||
1434 | const Default_FileOptions_PhpGenericServices bool = false | ||
1435 | const Default_FileOptions_Deprecated bool = false | ||
1436 | const Default_FileOptions_CcEnableArenas bool = false | ||
1437 | |||
1438 | func (m *FileOptions) GetJavaPackage() string { | ||
1439 | if m != nil && m.JavaPackage != nil { | ||
1440 | return *m.JavaPackage | ||
1441 | } | ||
1442 | return "" | ||
1443 | } | ||
1444 | |||
1445 | func (m *FileOptions) GetJavaOuterClassname() string { | ||
1446 | if m != nil && m.JavaOuterClassname != nil { | ||
1447 | return *m.JavaOuterClassname | ||
1448 | } | ||
1449 | return "" | ||
1450 | } | ||
1451 | |||
1452 | func (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. | ||
1460 | func (m *FileOptions) GetJavaGenerateEqualsAndHash() bool { | ||
1461 | if m != nil && m.JavaGenerateEqualsAndHash != nil { | ||
1462 | return *m.JavaGenerateEqualsAndHash | ||
1463 | } | ||
1464 | return false | ||
1465 | } | ||
1466 | |||
1467 | func (m *FileOptions) GetJavaStringCheckUtf8() bool { | ||
1468 | if m != nil && m.JavaStringCheckUtf8 != nil { | ||
1469 | return *m.JavaStringCheckUtf8 | ||
1470 | } | ||
1471 | return Default_FileOptions_JavaStringCheckUtf8 | ||
1472 | } | ||
1473 | |||
1474 | func (m *FileOptions) GetOptimizeFor() FileOptions_OptimizeMode { | ||
1475 | if m != nil && m.OptimizeFor != nil { | ||
1476 | return *m.OptimizeFor | ||
1477 | } | ||
1478 | return Default_FileOptions_OptimizeFor | ||
1479 | } | ||
1480 | |||
1481 | func (m *FileOptions) GetGoPackage() string { | ||
1482 | if m != nil && m.GoPackage != nil { | ||
1483 | return *m.GoPackage | ||
1484 | } | ||
1485 | return "" | ||
1486 | } | ||
1487 | |||
1488 | func (m *FileOptions) GetCcGenericServices() bool { | ||
1489 | if m != nil && m.CcGenericServices != nil { | ||
1490 | return *m.CcGenericServices | ||
1491 | } | ||
1492 | return Default_FileOptions_CcGenericServices | ||
1493 | } | ||
1494 | |||
1495 | func (m *FileOptions) GetJavaGenericServices() bool { | ||
1496 | if m != nil && m.JavaGenericServices != nil { | ||
1497 | return *m.JavaGenericServices | ||
1498 | } | ||
1499 | return Default_FileOptions_JavaGenericServices | ||
1500 | } | ||
1501 | |||
1502 | func (m *FileOptions) GetPyGenericServices() bool { | ||
1503 | if m != nil && m.PyGenericServices != nil { | ||
1504 | return *m.PyGenericServices | ||
1505 | } | ||
1506 | return Default_FileOptions_PyGenericServices | ||
1507 | } | ||
1508 | |||
1509 | func (m *FileOptions) GetPhpGenericServices() bool { | ||
1510 | if m != nil && m.PhpGenericServices != nil { | ||
1511 | return *m.PhpGenericServices | ||
1512 | } | ||
1513 | return Default_FileOptions_PhpGenericServices | ||
1514 | } | ||
1515 | |||
1516 | func (m *FileOptions) GetDeprecated() bool { | ||
1517 | if m != nil && m.Deprecated != nil { | ||
1518 | return *m.Deprecated | ||
1519 | } | ||
1520 | return Default_FileOptions_Deprecated | ||
1521 | } | ||
1522 | |||
1523 | func (m *FileOptions) GetCcEnableArenas() bool { | ||
1524 | if m != nil && m.CcEnableArenas != nil { | ||
1525 | return *m.CcEnableArenas | ||
1526 | } | ||
1527 | return Default_FileOptions_CcEnableArenas | ||
1528 | } | ||
1529 | |||
1530 | func (m *FileOptions) GetObjcClassPrefix() string { | ||
1531 | if m != nil && m.ObjcClassPrefix != nil { | ||
1532 | return *m.ObjcClassPrefix | ||
1533 | } | ||
1534 | return "" | ||
1535 | } | ||
1536 | |||
1537 | func (m *FileOptions) GetCsharpNamespace() string { | ||
1538 | if m != nil && m.CsharpNamespace != nil { | ||
1539 | return *m.CsharpNamespace | ||
1540 | } | ||
1541 | return "" | ||
1542 | } | ||
1543 | |||
1544 | func (m *FileOptions) GetSwiftPrefix() string { | ||
1545 | if m != nil && m.SwiftPrefix != nil { | ||
1546 | return *m.SwiftPrefix | ||
1547 | } | ||
1548 | return "" | ||
1549 | } | ||
1550 | |||
1551 | func (m *FileOptions) GetPhpClassPrefix() string { | ||
1552 | if m != nil && m.PhpClassPrefix != nil { | ||
1553 | return *m.PhpClassPrefix | ||
1554 | } | ||
1555 | return "" | ||
1556 | } | ||
1557 | |||
1558 | func (m *FileOptions) GetPhpNamespace() string { | ||
1559 | if m != nil && m.PhpNamespace != nil { | ||
1560 | return *m.PhpNamespace | ||
1561 | } | ||
1562 | return "" | ||
1563 | } | ||
1564 | |||
1565 | func (m *FileOptions) GetPhpMetadataNamespace() string { | ||
1566 | if m != nil && m.PhpMetadataNamespace != nil { | ||
1567 | return *m.PhpMetadataNamespace | ||
1568 | } | ||
1569 | return "" | ||
1570 | } | ||
1571 | |||
1572 | func (m *FileOptions) GetRubyPackage() string { | ||
1573 | if m != nil && m.RubyPackage != nil { | ||
1574 | return *m.RubyPackage | ||
1575 | } | ||
1576 | return "" | ||
1577 | } | ||
1578 | |||
1579 | func (m *FileOptions) GetUninterpretedOption() []*UninterpretedOption { | ||
1580 | if m != nil { | ||
1581 | return m.UninterpretedOption | ||
1582 | } | ||
1583 | return nil | ||
1584 | } | ||
1585 | |||
1586 | type 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 | |||
1645 | func (m *MessageOptions) Reset() { *m = MessageOptions{} } | ||
1646 | func (m *MessageOptions) String() string { return proto.CompactTextString(m) } | ||
1647 | func (*MessageOptions) ProtoMessage() {} | ||
1648 | func (*MessageOptions) Descriptor() ([]byte, []int) { | ||
1649 | return fileDescriptor_e5baabe45344a177, []int{11} | ||
1650 | } | ||
1651 | |||
1652 | var extRange_MessageOptions = []proto.ExtensionRange{ | ||
1653 | {Start: 1000, End: 536870911}, | ||
1654 | } | ||
1655 | |||
1656 | func (*MessageOptions) ExtensionRangeArray() []proto.ExtensionRange { | ||
1657 | return extRange_MessageOptions | ||
1658 | } | ||
1659 | |||
1660 | func (m *MessageOptions) XXX_Unmarshal(b []byte) error { | ||
1661 | return xxx_messageInfo_MessageOptions.Unmarshal(m, b) | ||
1662 | } | ||
1663 | func (m *MessageOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1664 | return xxx_messageInfo_MessageOptions.Marshal(b, m, deterministic) | ||
1665 | } | ||
1666 | func (m *MessageOptions) XXX_Merge(src proto.Message) { | ||
1667 | xxx_messageInfo_MessageOptions.Merge(m, src) | ||
1668 | } | ||
1669 | func (m *MessageOptions) XXX_Size() int { | ||
1670 | return xxx_messageInfo_MessageOptions.Size(m) | ||
1671 | } | ||
1672 | func (m *MessageOptions) XXX_DiscardUnknown() { | ||
1673 | xxx_messageInfo_MessageOptions.DiscardUnknown(m) | ||
1674 | } | ||
1675 | |||
1676 | var xxx_messageInfo_MessageOptions proto.InternalMessageInfo | ||
1677 | |||
1678 | const Default_MessageOptions_MessageSetWireFormat bool = false | ||
1679 | const Default_MessageOptions_NoStandardDescriptorAccessor bool = false | ||
1680 | const Default_MessageOptions_Deprecated bool = false | ||
1681 | |||
1682 | func (m *MessageOptions) GetMessageSetWireFormat() bool { | ||
1683 | if m != nil && m.MessageSetWireFormat != nil { | ||
1684 | return *m.MessageSetWireFormat | ||
1685 | } | ||
1686 | return Default_MessageOptions_MessageSetWireFormat | ||
1687 | } | ||
1688 | |||
1689 | func (m *MessageOptions) GetNoStandardDescriptorAccessor() bool { | ||
1690 | if m != nil && m.NoStandardDescriptorAccessor != nil { | ||
1691 | return *m.NoStandardDescriptorAccessor | ||
1692 | } | ||
1693 | return Default_MessageOptions_NoStandardDescriptorAccessor | ||
1694 | } | ||
1695 | |||
1696 | func (m *MessageOptions) GetDeprecated() bool { | ||
1697 | if m != nil && m.Deprecated != nil { | ||
1698 | return *m.Deprecated | ||
1699 | } | ||
1700 | return Default_MessageOptions_Deprecated | ||
1701 | } | ||
1702 | |||
1703 | func (m *MessageOptions) GetMapEntry() bool { | ||
1704 | if m != nil && m.MapEntry != nil { | ||
1705 | return *m.MapEntry | ||
1706 | } | ||
1707 | return false | ||
1708 | } | ||
1709 | |||
1710 | func (m *MessageOptions) GetUninterpretedOption() []*UninterpretedOption { | ||
1711 | if m != nil { | ||
1712 | return m.UninterpretedOption | ||
1713 | } | ||
1714 | return nil | ||
1715 | } | ||
1716 | |||
1717 | type 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 | |||
1785 | func (m *FieldOptions) Reset() { *m = FieldOptions{} } | ||
1786 | func (m *FieldOptions) String() string { return proto.CompactTextString(m) } | ||
1787 | func (*FieldOptions) ProtoMessage() {} | ||
1788 | func (*FieldOptions) Descriptor() ([]byte, []int) { | ||
1789 | return fileDescriptor_e5baabe45344a177, []int{12} | ||
1790 | } | ||
1791 | |||
1792 | var extRange_FieldOptions = []proto.ExtensionRange{ | ||
1793 | {Start: 1000, End: 536870911}, | ||
1794 | } | ||
1795 | |||
1796 | func (*FieldOptions) ExtensionRangeArray() []proto.ExtensionRange { | ||
1797 | return extRange_FieldOptions | ||
1798 | } | ||
1799 | |||
1800 | func (m *FieldOptions) XXX_Unmarshal(b []byte) error { | ||
1801 | return xxx_messageInfo_FieldOptions.Unmarshal(m, b) | ||
1802 | } | ||
1803 | func (m *FieldOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1804 | return xxx_messageInfo_FieldOptions.Marshal(b, m, deterministic) | ||
1805 | } | ||
1806 | func (m *FieldOptions) XXX_Merge(src proto.Message) { | ||
1807 | xxx_messageInfo_FieldOptions.Merge(m, src) | ||
1808 | } | ||
1809 | func (m *FieldOptions) XXX_Size() int { | ||
1810 | return xxx_messageInfo_FieldOptions.Size(m) | ||
1811 | } | ||
1812 | func (m *FieldOptions) XXX_DiscardUnknown() { | ||
1813 | xxx_messageInfo_FieldOptions.DiscardUnknown(m) | ||
1814 | } | ||
1815 | |||
1816 | var xxx_messageInfo_FieldOptions proto.InternalMessageInfo | ||
1817 | |||
1818 | const Default_FieldOptions_Ctype FieldOptions_CType = FieldOptions_STRING | ||
1819 | const Default_FieldOptions_Jstype FieldOptions_JSType = FieldOptions_JS_NORMAL | ||
1820 | const Default_FieldOptions_Lazy bool = false | ||
1821 | const Default_FieldOptions_Deprecated bool = false | ||
1822 | const Default_FieldOptions_Weak bool = false | ||
1823 | |||
1824 | func (m *FieldOptions) GetCtype() FieldOptions_CType { | ||
1825 | if m != nil && m.Ctype != nil { | ||
1826 | return *m.Ctype | ||
1827 | } | ||
1828 | return Default_FieldOptions_Ctype | ||
1829 | } | ||
1830 | |||
1831 | func (m *FieldOptions) GetPacked() bool { | ||
1832 | if m != nil && m.Packed != nil { | ||
1833 | return *m.Packed | ||
1834 | } | ||
1835 | return false | ||
1836 | } | ||
1837 | |||
1838 | func (m *FieldOptions) GetJstype() FieldOptions_JSType { | ||
1839 | if m != nil && m.Jstype != nil { | ||
1840 | return *m.Jstype | ||
1841 | } | ||
1842 | return Default_FieldOptions_Jstype | ||
1843 | } | ||
1844 | |||
1845 | func (m *FieldOptions) GetLazy() bool { | ||
1846 | if m != nil && m.Lazy != nil { | ||
1847 | return *m.Lazy | ||
1848 | } | ||
1849 | return Default_FieldOptions_Lazy | ||
1850 | } | ||
1851 | |||
1852 | func (m *FieldOptions) GetDeprecated() bool { | ||
1853 | if m != nil && m.Deprecated != nil { | ||
1854 | return *m.Deprecated | ||
1855 | } | ||
1856 | return Default_FieldOptions_Deprecated | ||
1857 | } | ||
1858 | |||
1859 | func (m *FieldOptions) GetWeak() bool { | ||
1860 | if m != nil && m.Weak != nil { | ||
1861 | return *m.Weak | ||
1862 | } | ||
1863 | return Default_FieldOptions_Weak | ||
1864 | } | ||
1865 | |||
1866 | func (m *FieldOptions) GetUninterpretedOption() []*UninterpretedOption { | ||
1867 | if m != nil { | ||
1868 | return m.UninterpretedOption | ||
1869 | } | ||
1870 | return nil | ||
1871 | } | ||
1872 | |||
1873 | type 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 | |||
1882 | func (m *OneofOptions) Reset() { *m = OneofOptions{} } | ||
1883 | func (m *OneofOptions) String() string { return proto.CompactTextString(m) } | ||
1884 | func (*OneofOptions) ProtoMessage() {} | ||
1885 | func (*OneofOptions) Descriptor() ([]byte, []int) { | ||
1886 | return fileDescriptor_e5baabe45344a177, []int{13} | ||
1887 | } | ||
1888 | |||
1889 | var extRange_OneofOptions = []proto.ExtensionRange{ | ||
1890 | {Start: 1000, End: 536870911}, | ||
1891 | } | ||
1892 | |||
1893 | func (*OneofOptions) ExtensionRangeArray() []proto.ExtensionRange { | ||
1894 | return extRange_OneofOptions | ||
1895 | } | ||
1896 | |||
1897 | func (m *OneofOptions) XXX_Unmarshal(b []byte) error { | ||
1898 | return xxx_messageInfo_OneofOptions.Unmarshal(m, b) | ||
1899 | } | ||
1900 | func (m *OneofOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1901 | return xxx_messageInfo_OneofOptions.Marshal(b, m, deterministic) | ||
1902 | } | ||
1903 | func (m *OneofOptions) XXX_Merge(src proto.Message) { | ||
1904 | xxx_messageInfo_OneofOptions.Merge(m, src) | ||
1905 | } | ||
1906 | func (m *OneofOptions) XXX_Size() int { | ||
1907 | return xxx_messageInfo_OneofOptions.Size(m) | ||
1908 | } | ||
1909 | func (m *OneofOptions) XXX_DiscardUnknown() { | ||
1910 | xxx_messageInfo_OneofOptions.DiscardUnknown(m) | ||
1911 | } | ||
1912 | |||
1913 | var xxx_messageInfo_OneofOptions proto.InternalMessageInfo | ||
1914 | |||
1915 | func (m *OneofOptions) GetUninterpretedOption() []*UninterpretedOption { | ||
1916 | if m != nil { | ||
1917 | return m.UninterpretedOption | ||
1918 | } | ||
1919 | return nil | ||
1920 | } | ||
1921 | |||
1922 | type 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 | |||
1939 | func (m *EnumOptions) Reset() { *m = EnumOptions{} } | ||
1940 | func (m *EnumOptions) String() string { return proto.CompactTextString(m) } | ||
1941 | func (*EnumOptions) ProtoMessage() {} | ||
1942 | func (*EnumOptions) Descriptor() ([]byte, []int) { | ||
1943 | return fileDescriptor_e5baabe45344a177, []int{14} | ||
1944 | } | ||
1945 | |||
1946 | var extRange_EnumOptions = []proto.ExtensionRange{ | ||
1947 | {Start: 1000, End: 536870911}, | ||
1948 | } | ||
1949 | |||
1950 | func (*EnumOptions) ExtensionRangeArray() []proto.ExtensionRange { | ||
1951 | return extRange_EnumOptions | ||
1952 | } | ||
1953 | |||
1954 | func (m *EnumOptions) XXX_Unmarshal(b []byte) error { | ||
1955 | return xxx_messageInfo_EnumOptions.Unmarshal(m, b) | ||
1956 | } | ||
1957 | func (m *EnumOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1958 | return xxx_messageInfo_EnumOptions.Marshal(b, m, deterministic) | ||
1959 | } | ||
1960 | func (m *EnumOptions) XXX_Merge(src proto.Message) { | ||
1961 | xxx_messageInfo_EnumOptions.Merge(m, src) | ||
1962 | } | ||
1963 | func (m *EnumOptions) XXX_Size() int { | ||
1964 | return xxx_messageInfo_EnumOptions.Size(m) | ||
1965 | } | ||
1966 | func (m *EnumOptions) XXX_DiscardUnknown() { | ||
1967 | xxx_messageInfo_EnumOptions.DiscardUnknown(m) | ||
1968 | } | ||
1969 | |||
1970 | var xxx_messageInfo_EnumOptions proto.InternalMessageInfo | ||
1971 | |||
1972 | const Default_EnumOptions_Deprecated bool = false | ||
1973 | |||
1974 | func (m *EnumOptions) GetAllowAlias() bool { | ||
1975 | if m != nil && m.AllowAlias != nil { | ||
1976 | return *m.AllowAlias | ||
1977 | } | ||
1978 | return false | ||
1979 | } | ||
1980 | |||
1981 | func (m *EnumOptions) GetDeprecated() bool { | ||
1982 | if m != nil && m.Deprecated != nil { | ||
1983 | return *m.Deprecated | ||
1984 | } | ||
1985 | return Default_EnumOptions_Deprecated | ||
1986 | } | ||
1987 | |||
1988 | func (m *EnumOptions) GetUninterpretedOption() []*UninterpretedOption { | ||
1989 | if m != nil { | ||
1990 | return m.UninterpretedOption | ||
1991 | } | ||
1992 | return nil | ||
1993 | } | ||
1994 | |||
1995 | type 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 | |||
2009 | func (m *EnumValueOptions) Reset() { *m = EnumValueOptions{} } | ||
2010 | func (m *EnumValueOptions) String() string { return proto.CompactTextString(m) } | ||
2011 | func (*EnumValueOptions) ProtoMessage() {} | ||
2012 | func (*EnumValueOptions) Descriptor() ([]byte, []int) { | ||
2013 | return fileDescriptor_e5baabe45344a177, []int{15} | ||
2014 | } | ||
2015 | |||
2016 | var extRange_EnumValueOptions = []proto.ExtensionRange{ | ||
2017 | {Start: 1000, End: 536870911}, | ||
2018 | } | ||
2019 | |||
2020 | func (*EnumValueOptions) ExtensionRangeArray() []proto.ExtensionRange { | ||
2021 | return extRange_EnumValueOptions | ||
2022 | } | ||
2023 | |||
2024 | func (m *EnumValueOptions) XXX_Unmarshal(b []byte) error { | ||
2025 | return xxx_messageInfo_EnumValueOptions.Unmarshal(m, b) | ||
2026 | } | ||
2027 | func (m *EnumValueOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2028 | return xxx_messageInfo_EnumValueOptions.Marshal(b, m, deterministic) | ||
2029 | } | ||
2030 | func (m *EnumValueOptions) XXX_Merge(src proto.Message) { | ||
2031 | xxx_messageInfo_EnumValueOptions.Merge(m, src) | ||
2032 | } | ||
2033 | func (m *EnumValueOptions) XXX_Size() int { | ||
2034 | return xxx_messageInfo_EnumValueOptions.Size(m) | ||
2035 | } | ||
2036 | func (m *EnumValueOptions) XXX_DiscardUnknown() { | ||
2037 | xxx_messageInfo_EnumValueOptions.DiscardUnknown(m) | ||
2038 | } | ||
2039 | |||
2040 | var xxx_messageInfo_EnumValueOptions proto.InternalMessageInfo | ||
2041 | |||
2042 | const Default_EnumValueOptions_Deprecated bool = false | ||
2043 | |||
2044 | func (m *EnumValueOptions) GetDeprecated() bool { | ||
2045 | if m != nil && m.Deprecated != nil { | ||
2046 | return *m.Deprecated | ||
2047 | } | ||
2048 | return Default_EnumValueOptions_Deprecated | ||
2049 | } | ||
2050 | |||
2051 | func (m *EnumValueOptions) GetUninterpretedOption() []*UninterpretedOption { | ||
2052 | if m != nil { | ||
2053 | return m.UninterpretedOption | ||
2054 | } | ||
2055 | return nil | ||
2056 | } | ||
2057 | |||
2058 | type 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 | |||
2072 | func (m *ServiceOptions) Reset() { *m = ServiceOptions{} } | ||
2073 | func (m *ServiceOptions) String() string { return proto.CompactTextString(m) } | ||
2074 | func (*ServiceOptions) ProtoMessage() {} | ||
2075 | func (*ServiceOptions) Descriptor() ([]byte, []int) { | ||
2076 | return fileDescriptor_e5baabe45344a177, []int{16} | ||
2077 | } | ||
2078 | |||
2079 | var extRange_ServiceOptions = []proto.ExtensionRange{ | ||
2080 | {Start: 1000, End: 536870911}, | ||
2081 | } | ||
2082 | |||
2083 | func (*ServiceOptions) ExtensionRangeArray() []proto.ExtensionRange { | ||
2084 | return extRange_ServiceOptions | ||
2085 | } | ||
2086 | |||
2087 | func (m *ServiceOptions) XXX_Unmarshal(b []byte) error { | ||
2088 | return xxx_messageInfo_ServiceOptions.Unmarshal(m, b) | ||
2089 | } | ||
2090 | func (m *ServiceOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2091 | return xxx_messageInfo_ServiceOptions.Marshal(b, m, deterministic) | ||
2092 | } | ||
2093 | func (m *ServiceOptions) XXX_Merge(src proto.Message) { | ||
2094 | xxx_messageInfo_ServiceOptions.Merge(m, src) | ||
2095 | } | ||
2096 | func (m *ServiceOptions) XXX_Size() int { | ||
2097 | return xxx_messageInfo_ServiceOptions.Size(m) | ||
2098 | } | ||
2099 | func (m *ServiceOptions) XXX_DiscardUnknown() { | ||
2100 | xxx_messageInfo_ServiceOptions.DiscardUnknown(m) | ||
2101 | } | ||
2102 | |||
2103 | var xxx_messageInfo_ServiceOptions proto.InternalMessageInfo | ||
2104 | |||
2105 | const Default_ServiceOptions_Deprecated bool = false | ||
2106 | |||
2107 | func (m *ServiceOptions) GetDeprecated() bool { | ||
2108 | if m != nil && m.Deprecated != nil { | ||
2109 | return *m.Deprecated | ||
2110 | } | ||
2111 | return Default_ServiceOptions_Deprecated | ||
2112 | } | ||
2113 | |||
2114 | func (m *ServiceOptions) GetUninterpretedOption() []*UninterpretedOption { | ||
2115 | if m != nil { | ||
2116 | return m.UninterpretedOption | ||
2117 | } | ||
2118 | return nil | ||
2119 | } | ||
2120 | |||
2121 | type 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 | |||
2136 | func (m *MethodOptions) Reset() { *m = MethodOptions{} } | ||
2137 | func (m *MethodOptions) String() string { return proto.CompactTextString(m) } | ||
2138 | func (*MethodOptions) ProtoMessage() {} | ||
2139 | func (*MethodOptions) Descriptor() ([]byte, []int) { | ||
2140 | return fileDescriptor_e5baabe45344a177, []int{17} | ||
2141 | } | ||
2142 | |||
2143 | var extRange_MethodOptions = []proto.ExtensionRange{ | ||
2144 | {Start: 1000, End: 536870911}, | ||
2145 | } | ||
2146 | |||
2147 | func (*MethodOptions) ExtensionRangeArray() []proto.ExtensionRange { | ||
2148 | return extRange_MethodOptions | ||
2149 | } | ||
2150 | |||
2151 | func (m *MethodOptions) XXX_Unmarshal(b []byte) error { | ||
2152 | return xxx_messageInfo_MethodOptions.Unmarshal(m, b) | ||
2153 | } | ||
2154 | func (m *MethodOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2155 | return xxx_messageInfo_MethodOptions.Marshal(b, m, deterministic) | ||
2156 | } | ||
2157 | func (m *MethodOptions) XXX_Merge(src proto.Message) { | ||
2158 | xxx_messageInfo_MethodOptions.Merge(m, src) | ||
2159 | } | ||
2160 | func (m *MethodOptions) XXX_Size() int { | ||
2161 | return xxx_messageInfo_MethodOptions.Size(m) | ||
2162 | } | ||
2163 | func (m *MethodOptions) XXX_DiscardUnknown() { | ||
2164 | xxx_messageInfo_MethodOptions.DiscardUnknown(m) | ||
2165 | } | ||
2166 | |||
2167 | var xxx_messageInfo_MethodOptions proto.InternalMessageInfo | ||
2168 | |||
2169 | const Default_MethodOptions_Deprecated bool = false | ||
2170 | const Default_MethodOptions_IdempotencyLevel MethodOptions_IdempotencyLevel = MethodOptions_IDEMPOTENCY_UNKNOWN | ||
2171 | |||
2172 | func (m *MethodOptions) GetDeprecated() bool { | ||
2173 | if m != nil && m.Deprecated != nil { | ||
2174 | return *m.Deprecated | ||
2175 | } | ||
2176 | return Default_MethodOptions_Deprecated | ||
2177 | } | ||
2178 | |||
2179 | func (m *MethodOptions) GetIdempotencyLevel() MethodOptions_IdempotencyLevel { | ||
2180 | if m != nil && m.IdempotencyLevel != nil { | ||
2181 | return *m.IdempotencyLevel | ||
2182 | } | ||
2183 | return Default_MethodOptions_IdempotencyLevel | ||
2184 | } | ||
2185 | |||
2186 | func (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. | ||
2199 | type 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 | |||
2214 | func (m *UninterpretedOption) Reset() { *m = UninterpretedOption{} } | ||
2215 | func (m *UninterpretedOption) String() string { return proto.CompactTextString(m) } | ||
2216 | func (*UninterpretedOption) ProtoMessage() {} | ||
2217 | func (*UninterpretedOption) Descriptor() ([]byte, []int) { | ||
2218 | return fileDescriptor_e5baabe45344a177, []int{18} | ||
2219 | } | ||
2220 | |||
2221 | func (m *UninterpretedOption) XXX_Unmarshal(b []byte) error { | ||
2222 | return xxx_messageInfo_UninterpretedOption.Unmarshal(m, b) | ||
2223 | } | ||
2224 | func (m *UninterpretedOption) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2225 | return xxx_messageInfo_UninterpretedOption.Marshal(b, m, deterministic) | ||
2226 | } | ||
2227 | func (m *UninterpretedOption) XXX_Merge(src proto.Message) { | ||
2228 | xxx_messageInfo_UninterpretedOption.Merge(m, src) | ||
2229 | } | ||
2230 | func (m *UninterpretedOption) XXX_Size() int { | ||
2231 | return xxx_messageInfo_UninterpretedOption.Size(m) | ||
2232 | } | ||
2233 | func (m *UninterpretedOption) XXX_DiscardUnknown() { | ||
2234 | xxx_messageInfo_UninterpretedOption.DiscardUnknown(m) | ||
2235 | } | ||
2236 | |||
2237 | var xxx_messageInfo_UninterpretedOption proto.InternalMessageInfo | ||
2238 | |||
2239 | func (m *UninterpretedOption) GetName() []*UninterpretedOption_NamePart { | ||
2240 | if m != nil { | ||
2241 | return m.Name | ||
2242 | } | ||
2243 | return nil | ||
2244 | } | ||
2245 | |||
2246 | func (m *UninterpretedOption) GetIdentifierValue() string { | ||
2247 | if m != nil && m.IdentifierValue != nil { | ||
2248 | return *m.IdentifierValue | ||
2249 | } | ||
2250 | return "" | ||
2251 | } | ||
2252 | |||
2253 | func (m *UninterpretedOption) GetPositiveIntValue() uint64 { | ||
2254 | if m != nil && m.PositiveIntValue != nil { | ||
2255 | return *m.PositiveIntValue | ||
2256 | } | ||
2257 | return 0 | ||
2258 | } | ||
2259 | |||
2260 | func (m *UninterpretedOption) GetNegativeIntValue() int64 { | ||
2261 | if m != nil && m.NegativeIntValue != nil { | ||
2262 | return *m.NegativeIntValue | ||
2263 | } | ||
2264 | return 0 | ||
2265 | } | ||
2266 | |||
2267 | func (m *UninterpretedOption) GetDoubleValue() float64 { | ||
2268 | if m != nil && m.DoubleValue != nil { | ||
2269 | return *m.DoubleValue | ||
2270 | } | ||
2271 | return 0 | ||
2272 | } | ||
2273 | |||
2274 | func (m *UninterpretedOption) GetStringValue() []byte { | ||
2275 | if m != nil { | ||
2276 | return m.StringValue | ||
2277 | } | ||
2278 | return nil | ||
2279 | } | ||
2280 | |||
2281 | func (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". | ||
2293 | type 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 | |||
2301 | func (m *UninterpretedOption_NamePart) Reset() { *m = UninterpretedOption_NamePart{} } | ||
2302 | func (m *UninterpretedOption_NamePart) String() string { return proto.CompactTextString(m) } | ||
2303 | func (*UninterpretedOption_NamePart) ProtoMessage() {} | ||
2304 | func (*UninterpretedOption_NamePart) Descriptor() ([]byte, []int) { | ||
2305 | return fileDescriptor_e5baabe45344a177, []int{18, 0} | ||
2306 | } | ||
2307 | |||
2308 | func (m *UninterpretedOption_NamePart) XXX_Unmarshal(b []byte) error { | ||
2309 | return xxx_messageInfo_UninterpretedOption_NamePart.Unmarshal(m, b) | ||
2310 | } | ||
2311 | func (m *UninterpretedOption_NamePart) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2312 | return xxx_messageInfo_UninterpretedOption_NamePart.Marshal(b, m, deterministic) | ||
2313 | } | ||
2314 | func (m *UninterpretedOption_NamePart) XXX_Merge(src proto.Message) { | ||
2315 | xxx_messageInfo_UninterpretedOption_NamePart.Merge(m, src) | ||
2316 | } | ||
2317 | func (m *UninterpretedOption_NamePart) XXX_Size() int { | ||
2318 | return xxx_messageInfo_UninterpretedOption_NamePart.Size(m) | ||
2319 | } | ||
2320 | func (m *UninterpretedOption_NamePart) XXX_DiscardUnknown() { | ||
2321 | xxx_messageInfo_UninterpretedOption_NamePart.DiscardUnknown(m) | ||
2322 | } | ||
2323 | |||
2324 | var xxx_messageInfo_UninterpretedOption_NamePart proto.InternalMessageInfo | ||
2325 | |||
2326 | func (m *UninterpretedOption_NamePart) GetNamePart() string { | ||
2327 | if m != nil && m.NamePart != nil { | ||
2328 | return *m.NamePart | ||
2329 | } | ||
2330 | return "" | ||
2331 | } | ||
2332 | |||
2333 | func (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. | ||
2342 | type 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 | |||
2392 | func (m *SourceCodeInfo) Reset() { *m = SourceCodeInfo{} } | ||
2393 | func (m *SourceCodeInfo) String() string { return proto.CompactTextString(m) } | ||
2394 | func (*SourceCodeInfo) ProtoMessage() {} | ||
2395 | func (*SourceCodeInfo) Descriptor() ([]byte, []int) { | ||
2396 | return fileDescriptor_e5baabe45344a177, []int{19} | ||
2397 | } | ||
2398 | |||
2399 | func (m *SourceCodeInfo) XXX_Unmarshal(b []byte) error { | ||
2400 | return xxx_messageInfo_SourceCodeInfo.Unmarshal(m, b) | ||
2401 | } | ||
2402 | func (m *SourceCodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2403 | return xxx_messageInfo_SourceCodeInfo.Marshal(b, m, deterministic) | ||
2404 | } | ||
2405 | func (m *SourceCodeInfo) XXX_Merge(src proto.Message) { | ||
2406 | xxx_messageInfo_SourceCodeInfo.Merge(m, src) | ||
2407 | } | ||
2408 | func (m *SourceCodeInfo) XXX_Size() int { | ||
2409 | return xxx_messageInfo_SourceCodeInfo.Size(m) | ||
2410 | } | ||
2411 | func (m *SourceCodeInfo) XXX_DiscardUnknown() { | ||
2412 | xxx_messageInfo_SourceCodeInfo.DiscardUnknown(m) | ||
2413 | } | ||
2414 | |||
2415 | var xxx_messageInfo_SourceCodeInfo proto.InternalMessageInfo | ||
2416 | |||
2417 | func (m *SourceCodeInfo) GetLocation() []*SourceCodeInfo_Location { | ||
2418 | if m != nil { | ||
2419 | return m.Location | ||
2420 | } | ||
2421 | return nil | ||
2422 | } | ||
2423 | |||
2424 | type 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 | |||
2510 | func (m *SourceCodeInfo_Location) Reset() { *m = SourceCodeInfo_Location{} } | ||
2511 | func (m *SourceCodeInfo_Location) String() string { return proto.CompactTextString(m) } | ||
2512 | func (*SourceCodeInfo_Location) ProtoMessage() {} | ||
2513 | func (*SourceCodeInfo_Location) Descriptor() ([]byte, []int) { | ||
2514 | return fileDescriptor_e5baabe45344a177, []int{19, 0} | ||
2515 | } | ||
2516 | |||
2517 | func (m *SourceCodeInfo_Location) XXX_Unmarshal(b []byte) error { | ||
2518 | return xxx_messageInfo_SourceCodeInfo_Location.Unmarshal(m, b) | ||
2519 | } | ||
2520 | func (m *SourceCodeInfo_Location) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2521 | return xxx_messageInfo_SourceCodeInfo_Location.Marshal(b, m, deterministic) | ||
2522 | } | ||
2523 | func (m *SourceCodeInfo_Location) XXX_Merge(src proto.Message) { | ||
2524 | xxx_messageInfo_SourceCodeInfo_Location.Merge(m, src) | ||
2525 | } | ||
2526 | func (m *SourceCodeInfo_Location) XXX_Size() int { | ||
2527 | return xxx_messageInfo_SourceCodeInfo_Location.Size(m) | ||
2528 | } | ||
2529 | func (m *SourceCodeInfo_Location) XXX_DiscardUnknown() { | ||
2530 | xxx_messageInfo_SourceCodeInfo_Location.DiscardUnknown(m) | ||
2531 | } | ||
2532 | |||
2533 | var xxx_messageInfo_SourceCodeInfo_Location proto.InternalMessageInfo | ||
2534 | |||
2535 | func (m *SourceCodeInfo_Location) GetPath() []int32 { | ||
2536 | if m != nil { | ||
2537 | return m.Path | ||
2538 | } | ||
2539 | return nil | ||
2540 | } | ||
2541 | |||
2542 | func (m *SourceCodeInfo_Location) GetSpan() []int32 { | ||
2543 | if m != nil { | ||
2544 | return m.Span | ||
2545 | } | ||
2546 | return nil | ||
2547 | } | ||
2548 | |||
2549 | func (m *SourceCodeInfo_Location) GetLeadingComments() string { | ||
2550 | if m != nil && m.LeadingComments != nil { | ||
2551 | return *m.LeadingComments | ||
2552 | } | ||
2553 | return "" | ||
2554 | } | ||
2555 | |||
2556 | func (m *SourceCodeInfo_Location) GetTrailingComments() string { | ||
2557 | if m != nil && m.TrailingComments != nil { | ||
2558 | return *m.TrailingComments | ||
2559 | } | ||
2560 | return "" | ||
2561 | } | ||
2562 | |||
2563 | func (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. | ||
2573 | type 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 | |||
2582 | func (m *GeneratedCodeInfo) Reset() { *m = GeneratedCodeInfo{} } | ||
2583 | func (m *GeneratedCodeInfo) String() string { return proto.CompactTextString(m) } | ||
2584 | func (*GeneratedCodeInfo) ProtoMessage() {} | ||
2585 | func (*GeneratedCodeInfo) Descriptor() ([]byte, []int) { | ||
2586 | return fileDescriptor_e5baabe45344a177, []int{20} | ||
2587 | } | ||
2588 | |||
2589 | func (m *GeneratedCodeInfo) XXX_Unmarshal(b []byte) error { | ||
2590 | return xxx_messageInfo_GeneratedCodeInfo.Unmarshal(m, b) | ||
2591 | } | ||
2592 | func (m *GeneratedCodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2593 | return xxx_messageInfo_GeneratedCodeInfo.Marshal(b, m, deterministic) | ||
2594 | } | ||
2595 | func (m *GeneratedCodeInfo) XXX_Merge(src proto.Message) { | ||
2596 | xxx_messageInfo_GeneratedCodeInfo.Merge(m, src) | ||
2597 | } | ||
2598 | func (m *GeneratedCodeInfo) XXX_Size() int { | ||
2599 | return xxx_messageInfo_GeneratedCodeInfo.Size(m) | ||
2600 | } | ||
2601 | func (m *GeneratedCodeInfo) XXX_DiscardUnknown() { | ||
2602 | xxx_messageInfo_GeneratedCodeInfo.DiscardUnknown(m) | ||
2603 | } | ||
2604 | |||
2605 | var xxx_messageInfo_GeneratedCodeInfo proto.InternalMessageInfo | ||
2606 | |||
2607 | func (m *GeneratedCodeInfo) GetAnnotation() []*GeneratedCodeInfo_Annotation { | ||
2608 | if m != nil { | ||
2609 | return m.Annotation | ||
2610 | } | ||
2611 | return nil | ||
2612 | } | ||
2613 | |||
2614 | type 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 | |||
2632 | func (m *GeneratedCodeInfo_Annotation) Reset() { *m = GeneratedCodeInfo_Annotation{} } | ||
2633 | func (m *GeneratedCodeInfo_Annotation) String() string { return proto.CompactTextString(m) } | ||
2634 | func (*GeneratedCodeInfo_Annotation) ProtoMessage() {} | ||
2635 | func (*GeneratedCodeInfo_Annotation) Descriptor() ([]byte, []int) { | ||
2636 | return fileDescriptor_e5baabe45344a177, []int{20, 0} | ||
2637 | } | ||
2638 | |||
2639 | func (m *GeneratedCodeInfo_Annotation) XXX_Unmarshal(b []byte) error { | ||
2640 | return xxx_messageInfo_GeneratedCodeInfo_Annotation.Unmarshal(m, b) | ||
2641 | } | ||
2642 | func (m *GeneratedCodeInfo_Annotation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2643 | return xxx_messageInfo_GeneratedCodeInfo_Annotation.Marshal(b, m, deterministic) | ||
2644 | } | ||
2645 | func (m *GeneratedCodeInfo_Annotation) XXX_Merge(src proto.Message) { | ||
2646 | xxx_messageInfo_GeneratedCodeInfo_Annotation.Merge(m, src) | ||
2647 | } | ||
2648 | func (m *GeneratedCodeInfo_Annotation) XXX_Size() int { | ||
2649 | return xxx_messageInfo_GeneratedCodeInfo_Annotation.Size(m) | ||
2650 | } | ||
2651 | func (m *GeneratedCodeInfo_Annotation) XXX_DiscardUnknown() { | ||
2652 | xxx_messageInfo_GeneratedCodeInfo_Annotation.DiscardUnknown(m) | ||
2653 | } | ||
2654 | |||
2655 | var xxx_messageInfo_GeneratedCodeInfo_Annotation proto.InternalMessageInfo | ||
2656 | |||
2657 | func (m *GeneratedCodeInfo_Annotation) GetPath() []int32 { | ||
2658 | if m != nil { | ||
2659 | return m.Path | ||
2660 | } | ||
2661 | return nil | ||
2662 | } | ||
2663 | |||
2664 | func (m *GeneratedCodeInfo_Annotation) GetSourceFile() string { | ||
2665 | if m != nil && m.SourceFile != nil { | ||
2666 | return *m.SourceFile | ||
2667 | } | ||
2668 | return "" | ||
2669 | } | ||
2670 | |||
2671 | func (m *GeneratedCodeInfo_Annotation) GetBegin() int32 { | ||
2672 | if m != nil && m.Begin != nil { | ||
2673 | return *m.Begin | ||
2674 | } | ||
2675 | return 0 | ||
2676 | } | ||
2677 | |||
2678 | func (m *GeneratedCodeInfo_Annotation) GetEnd() int32 { | ||
2679 | if m != nil && m.End != nil { | ||
2680 | return *m.End | ||
2681 | } | ||
2682 | return 0 | ||
2683 | } | ||
2684 | |||
2685 | func 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 | |||
2721 | func init() { proto.RegisterFile("google/protobuf/descriptor.proto", fileDescriptor_e5baabe45344a177) } | ||
2722 | |||
2723 | var 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 | |||
40 | syntax = "proto2"; | ||
41 | |||
42 | package google.protobuf; | ||
43 | option go_package = "github.com/golang/protobuf/protoc-gen-go/descriptor;descriptor"; | ||
44 | option java_package = "com.google.protobuf"; | ||
45 | option java_outer_classname = "DescriptorProtos"; | ||
46 | option csharp_namespace = "Google.Protobuf.Reflection"; | ||
47 | option objc_class_prefix = "GPB"; | ||
48 | option cc_enable_arenas = true; | ||
49 | |||
50 | // descriptor.proto must be optimized for speed because reflection-based | ||
51 | // algorithms don't work during bootstrapping. | ||
52 | option optimize_for = SPEED; | ||
53 | |||
54 | // The protocol compiler can output a FileDescriptorSet containing the .proto | ||
55 | // files it parses. | ||
56 | message FileDescriptorSet { | ||
57 | repeated FileDescriptorProto file = 1; | ||
58 | } | ||
59 | |||
60 | // Describes a complete .proto file. | ||
61 | message 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. | ||
93 | message 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 | |||
127 | message 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. | ||
136 | message 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. | ||
217 | message OneofDescriptorProto { | ||
218 | optional string name = 1; | ||
219 | optional OneofOptions options = 2; | ||
220 | } | ||
221 | |||
222 | // Describes an enum type. | ||
223 | message 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. | ||
252 | message EnumValueDescriptorProto { | ||
253 | optional string name = 1; | ||
254 | optional int32 number = 2; | ||
255 | |||
256 | optional EnumValueOptions options = 3; | ||
257 | } | ||
258 | |||
259 | // Describes a service. | ||
260 | message 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. | ||
268 | message 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 | |||
318 | message 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 | |||
442 | message 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 | |||
507 | message 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 | |||
600 | message 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 | |||
608 | message 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 | |||
629 | message 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 | |||
643 | message 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 | |||
663 | message 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. | ||
701 | message 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. | ||
728 | message 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. | ||
862 | message 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 | } | ||