| |
| module ietf-descriptor { |
| |
| |
| namespace "urn:opencord:params:xml:ns:voltha:ietf-descriptor"; |
| prefix descriptor; |
| |
| |
| organization "CORD"; |
| contact |
| " Any name"; |
| |
| description |
| ""; |
| |
| revision "2016-11-15" { |
| description "Initial revision."; |
| reference "reference"; |
| } |
| |
| |
| container FileDescriptorSet { |
| description |
| "The protocol compiler can output a FileDescriptorSet containing the .proto |
| files it parses."; |
| list file { |
| key "name"; |
| uses FileDescriptorProto; |
| |
| description |
| ""; |
| } |
| |
| } |
| |
| grouping FileDescriptorProto { |
| description |
| "Describes a complete .proto file."; |
| leaf name { |
| type string; |
| description |
| "file name, relative to root of source tree"; |
| } |
| |
| leaf package { |
| type string; |
| description |
| "e.g. foo , foo.bar , etc."; |
| } |
| |
| list dependency { |
| key "dependency"; |
| leaf dependency { |
| type string; |
| description |
| "Names of files imported by this file."; |
| } |
| description |
| "Names of files imported by this file."; |
| } |
| |
| list public_dependency { |
| key "public_dependency"; |
| leaf public_dependency { |
| type int32; |
| description |
| "Indexes of the public imported files in the dependency list above."; |
| } |
| description |
| "Indexes of the public imported files in the dependency list above."; |
| } |
| |
| list weak_dependency { |
| key "weak_dependency"; |
| leaf weak_dependency { |
| type int32; |
| description |
| "Indexes of the weak imported files in the dependency list. |
| For Google-internal migration only. Do not use."; |
| } |
| description |
| "Indexes of the weak imported files in the dependency list. |
| For Google-internal migration only. Do not use."; |
| } |
| |
| list message_type { |
| key "name"; |
| uses DescriptorProto; |
| |
| description |
| "All top-level definitions in this file."; |
| } |
| |
| list enum_type { |
| key "name"; |
| uses EnumDescriptorProto; |
| |
| description |
| ""; |
| } |
| |
| list service { |
| key "name"; |
| uses ServiceDescriptorProto; |
| |
| description |
| ""; |
| } |
| |
| list extension { |
| key "name"; |
| uses FieldDescriptorProto; |
| |
| description |
| ""; |
| } |
| |
| container options { |
| uses FileOptions; |
| |
| description |
| ""; |
| } |
| |
| container source_code_info { |
| uses SourceCodeInfo; |
| |
| description |
| "This field contains optional information about the original source code. |
| You may safely remove this entire field without harming runtime |
| functionality of the descriptors -- the information is needed only by |
| development tools."; |
| } |
| |
| leaf syntax { |
| type string; |
| description |
| "The syntax of the proto file. |
| The supported values are proto2 and proto3 ."; |
| } |
| |
| } |
| |
| grouping DescriptorProto { |
| description |
| "Describes a message type."; |
| leaf name { |
| type string; |
| description |
| ""; |
| } |
| |
| list field { |
| key "name"; |
| uses FieldDescriptorProto; |
| |
| description |
| ""; |
| } |
| |
| list extension { |
| key "name"; |
| uses FieldDescriptorProto; |
| |
| description |
| ""; |
| } |
| |
| list nested_type { |
| key "name"; |
| uses DescriptorProto; |
| |
| description |
| ""; |
| } |
| |
| list enum_type { |
| key "name"; |
| uses EnumDescriptorProto; |
| |
| description |
| ""; |
| } |
| |
| |
| list oneof_decl { |
| key "name"; |
| uses OneofDescriptorProto; |
| |
| description |
| ""; |
| } |
| |
| container options { |
| uses MessageOptions; |
| |
| description |
| ""; |
| } |
| |
| |
| list reserved_name { |
| key "reserved_name"; |
| leaf reserved_name { |
| type string; |
| description |
| "Reserved field names, which may not be used by fields in the same message. |
| A given name may only be reserved once."; |
| } |
| description |
| "Reserved field names, which may not be used by fields in the same message. |
| A given name may only be reserved once."; |
| } |
| |
| grouping ExtensionRange { |
| description |
| ""; |
| leaf start { |
| type int32; |
| description |
| ""; |
| } |
| |
| leaf end { |
| type int32; |
| description |
| ""; |
| } |
| |
| } |
| |
| grouping ReservedRange { |
| description |
| "Range of reserved tag numbers. Reserved tag numbers may not be used by |
| fields or extension ranges in the same message. Reserved ranges may |
| not overlap."; |
| leaf start { |
| type int32; |
| description |
| "Inclusive."; |
| } |
| |
| leaf end { |
| type int32; |
| description |
| "Exclusive."; |
| } |
| |
| } |
| |
| } |
| |
| grouping FieldDescriptorProto { |
| description |
| "Describes a field within a message."; |
| leaf name { |
| type string; |
| description |
| ""; |
| } |
| |
| leaf number { |
| type int32; |
| description |
| ""; |
| } |
| |
| leaf label { |
| type Label; |
| description |
| ""; |
| } |
| |
| leaf type { |
| type Type; |
| description |
| "If type_name is set, this need not be set. If both this and type_name |
| are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP."; |
| } |
| |
| leaf type_name { |
| type string; |
| description |
| "For message and enum types, this is the name of the type. If the name |
| starts with a '.', it is fully-qualified. Otherwise, C++-like scoping |
| rules are used to find the type (i.e. first the nested types within this |
| message are searched, then within the parent, on up to the root |
| namespace)."; |
| } |
| |
| leaf extendee { |
| type string; |
| description |
| "For extensions, this is the name of the type being extended. It is |
| resolved in the same manner as type_name."; |
| } |
| |
| leaf default_value { |
| type string; |
| description |
| "For numeric types, contains the original text representation of the value. |
| For booleans, true or false . |
| For strings, contains the default text contents (not escaped in any way). |
| For bytes, contains the C escaped value. All bytes >= 128 are escaped. |
| TODO(kenton): Base-64 encode?"; |
| } |
| |
| leaf oneof_index { |
| type int32; |
| description |
| "If set, gives the index of a oneof in the containing type's oneof_decl |
| list. This field is a member of that oneof."; |
| } |
| |
| leaf json_name { |
| type string; |
| description |
| "JSON name of this field. The value is set by protocol compiler. If the |
| user has set a json_name option on this field, that option's value |
| will be used. Otherwise, it's deduced from the field's name by converting |
| it to camelCase."; |
| } |
| |
| container options { |
| uses FieldOptions; |
| |
| description |
| ""; |
| } |
| |
| typedef Type { |
| type enumeration { |
| enum TYPE_DOUBLE { |
| description ""; |
| } |
| enum TYPE_FLOAT { |
| description ""; |
| } |
| enum TYPE_INT64 { |
| description ""; |
| } |
| enum TYPE_UINT64 { |
| description ""; |
| } |
| enum TYPE_INT32 { |
| description ""; |
| } |
| enum TYPE_FIXED64 { |
| description ""; |
| } |
| enum TYPE_FIXED32 { |
| description ""; |
| } |
| enum TYPE_BOOL { |
| description ""; |
| } |
| enum TYPE_STRING { |
| description ""; |
| } |
| enum TYPE_GROUP { |
| description ""; |
| } |
| enum TYPE_MESSAGE { |
| description ""; |
| } |
| enum TYPE_BYTES { |
| description ""; |
| } |
| enum TYPE_UINT32 { |
| description ""; |
| } |
| enum TYPE_ENUM { |
| description ""; |
| } |
| enum TYPE_SFIXED32 { |
| description ""; |
| } |
| enum TYPE_SFIXED64 { |
| description ""; |
| } |
| enum TYPE_SINT32 { |
| description ""; |
| } |
| enum TYPE_SINT64 { |
| description ""; |
| } |
| } |
| description |
| ""; |
| } |
| |
| typedef Label { |
| type enumeration { |
| enum LABEL_OPTIONAL { |
| description ""; |
| } |
| enum LABEL_REQUIRED { |
| description ""; |
| } |
| enum LABEL_REPEATED { |
| description ""; |
| } |
| } |
| description |
| ""; |
| } |
| |
| } |
| |
| grouping OneofDescriptorProto { |
| description |
| "Describes a oneof."; |
| leaf name { |
| type string; |
| description |
| ""; |
| } |
| |
| container options { |
| uses OneofOptions; |
| |
| description |
| ""; |
| } |
| |
| } |
| |
| grouping EnumDescriptorProto { |
| description |
| "Describes an enum type."; |
| leaf name { |
| type string; |
| description |
| ""; |
| } |
| |
| list value { |
| key "name"; |
| uses EnumValueDescriptorProto; |
| |
| description |
| ""; |
| } |
| |
| container options { |
| uses EnumOptions; |
| |
| description |
| ""; |
| } |
| |
| } |
| |
| grouping EnumValueDescriptorProto { |
| description |
| "Describes a value within an enum."; |
| leaf name { |
| type string; |
| description |
| ""; |
| } |
| |
| leaf number { |
| type int32; |
| description |
| ""; |
| } |
| |
| container options { |
| uses EnumValueOptions; |
| |
| description |
| ""; |
| } |
| |
| } |
| |
| grouping ServiceDescriptorProto { |
| description |
| "Describes a service."; |
| leaf name { |
| type string; |
| description |
| ""; |
| } |
| |
| list method { |
| key "name"; |
| uses MethodDescriptorProto; |
| |
| description |
| ""; |
| } |
| |
| container options { |
| uses ServiceOptions; |
| |
| description |
| ""; |
| } |
| |
| } |
| |
| grouping MethodDescriptorProto { |
| description |
| "Describes a method of a service."; |
| leaf name { |
| type string; |
| description |
| ""; |
| } |
| |
| leaf input_type { |
| type string; |
| description |
| "Input and output type names. These are resolved in the same way as |
| FieldDescriptorProto.type_name, but must refer to a message type."; |
| } |
| |
| leaf output_type { |
| type string; |
| description |
| ""; |
| } |
| |
| container options { |
| uses MethodOptions; |
| |
| description |
| ""; |
| } |
| |
| leaf client_streaming { |
| type boolean; |
| description |
| "Identifies if client streams multiple client messages"; |
| } |
| |
| leaf server_streaming { |
| type boolean; |
| description |
| "Identifies if server streams multiple server messages"; |
| } |
| |
| } |
| |
| grouping FileOptions { |
| description |
| "=================================================================== |
| Options |
| Each of the definitions above may have options attached. These are |
| just annotations which may cause code to be generated slightly differently |
| or may contain hints for code that manipulates protocol messages. |
| |
| Clients may define custom options as extensions of the Options messages. |
| These extensions may not yet be known at parsing time, so the parser cannot |
| store the values in them. Instead it stores them in a field in the Options |
| message called uninterpreted_option. This field must have the same name |
| across all Options messages. We then use this field to populate the |
| extensions when we build a descriptor, at which point all protos have been |
| parsed and so all extensions are known. |
| |
| Extension numbers for custom options may be chosen as follows: |
| For options which will only be used within a single application or |
| organization, or for experimental options, use field numbers 50000 |
| through 99999. It is up to you to ensure that you do not use the |
| same number for multiple options. |
| For options which will be published and used publicly by multiple |
| independent entities, e-mail protobuf-global-extension-registry@google.com |
| to reserve extension numbers. Simply provide your project name (e.g. |
| Objective-C plugin) and your project website (if available) -- there's no |
| need to explain how you intend to use them. Usually you only need one |
| extension number. You can declare multiple options with only one extension |
| number by putting them in a sub-message. See the Custom Options section of |
| the docs for examples: |
| https: developers.google.com protocol-buffers docs proto#options |
| If this turns out to be popular, a web service will be set up |
| to automatically assign option numbers."; |
| leaf java_package { |
| type string; |
| description |
| "Sets the Java package where classes generated from this .proto will be |
| placed. By default, the proto package is used, but this is often |
| inappropriate because proto packages do not normally start with backwards |
| domain names."; |
| } |
| |
| leaf java_outer_classname { |
| type string; |
| description |
| "If set, all the classes from the .proto file are wrapped in a single |
| outer class with the given name. This applies to both Proto1 |
| (equivalent to the old --one_java_file option) and Proto2 (where |
| a .proto always translates to a single class, but you may want to |
| explicitly choose the class name)."; |
| } |
| |
| leaf java_multiple_files { |
| type boolean; |
| description |
| "If set true, then the Java code generator will generate a separate .java |
| file for each top-level message, enum, and service defined in the .proto |
| file. Thus, these types will not be nested inside the outer class |
| named by java_outer_classname. However, the outer class will still be |
| generated to contain the file's getDescriptor() method as well as any |
| top-level extensions defined in the file."; |
| } |
| |
| leaf java_generate_equals_and_hash { |
| type boolean; |
| description |
| "If set true, then the Java code generator will generate equals() and |
| hashCode() methods for all messages defined in the .proto file. |
| This increases generated code size, potentially substantially for large |
| protos, which may harm a memory-constrained application. |
| - In the full runtime this is a speed optimization, as the |
| AbstractMessage base class includes reflection-based implementations of |
| these methods. |
| - In the lite runtime, setting this option changes the semantics of |
| equals() and hashCode() to more closely match those of the full runtime; |
| the generated methods compute their results based on field values rather |
| than object identity. (Implementations should not assume that hashcodes |
| will be consistent across runtimes or versions of the protocol compiler.)"; |
| } |
| |
| leaf java_string_check_utf8 { |
| type boolean; |
| description |
| "If set true, then the Java2 code generator will generate code that |
| throws an exception whenever an attempt is made to assign a non-UTF-8 |
| byte sequence to a string field. |
| Message reflection will do the same. |
| However, an extension field still accepts non-UTF-8 byte sequences. |
| This option has no effect on when used with the lite runtime."; |
| } |
| |
| leaf optimize_for { |
| type OptimizeMode; |
| description |
| ""; |
| } |
| |
| leaf go_package { |
| type string; |
| description |
| "Sets the Go package where structs generated from this .proto will be |
| placed. If omitted, the Go package will be derived from the following: |
| - The basename of the package import path, if provided. |
| - Otherwise, the package statement in the .proto file, if present. |
| - Otherwise, the basename of the .proto file, without extension."; |
| } |
| |
| leaf cc_generic_services { |
| type boolean; |
| description |
| "Should generic services be generated in each language? Generic services |
| are not specific to any particular RPC system. They are generated by the |
| main code generators in each language (without additional plugins). |
| Generic services were the only kind of service generation supported by |
| early versions of google.protobuf. |
| |
| Generic services are now considered deprecated in favor of using plugins |
| that generate code specific to your particular RPC system. Therefore, |
| these default to false. Old code which depends on generic services should |
| explicitly set them to true."; |
| } |
| |
| leaf java_generic_services { |
| type boolean; |
| description |
| ""; |
| } |
| |
| leaf py_generic_services { |
| type boolean; |
| description |
| ""; |
| } |
| |
| leaf deprecated { |
| type boolean; |
| description |
| "Is this file deprecated? |
| Depending on the target platform, this can emit Deprecated annotations |
| for everything in the file, or it will be completely ignored; in the very |
| least, this is a formalization for deprecating files."; |
| } |
| |
| leaf cc_enable_arenas { |
| type boolean; |
| description |
| "Enables the use of arenas for the proto messages in this file. This applies |
| only to generated classes for C++."; |
| } |
| |
| leaf objc_class_prefix { |
| type string; |
| description |
| "Sets the objective c class prefix which is prepended to all objective c |
| generated classes from this .proto. There is no default."; |
| } |
| |
| leaf csharp_namespace { |
| type string; |
| description |
| "Namespace for generated classes; defaults to the package."; |
| } |
| |
| list uninterpreted_option { |
| key "identifier_value"; |
| uses UninterpretedOption; |
| |
| description |
| "The parser stores options it doesn't recognize here. See above."; |
| } |
| |
| typedef OptimizeMode { |
| type enumeration { |
| enum SPEED { |
| description ""; |
| } |
| enum CODE_SIZE { |
| description ""; |
| } |
| enum LITE_RUNTIME { |
| description ""; |
| } |
| } |
| description |
| "Generated classes can be optimized for speed or code size."; |
| } |
| |
| } |
| |
| grouping MessageOptions { |
| description |
| ""; |
| leaf message_set_wire_format { |
| type boolean; |
| description |
| "Set true to use the old proto1 MessageSet wire format for extensions. |
| This is provided for backwards-compatibility with the MessageSet wire |
| format. You should not use this for any other reason: It's less |
| efficient, has fewer features, and is more complicated. |
| |
| The message must be defined exactly as follows: |
| message Foo |
| option message_set_wire_format = true; |
| extensions 4 to max; |
| |
| Note that the message cannot have any defined fields; MessageSets only |
| have extensions. |
| |
| All extensions of your type must be singular messages; e.g. they cannot |
| be int32s, enums, or repeated messages. |
| |
| Because this is an option, the above two restrictions are not enforced by |
| the protocol compiler."; |
| } |
| |
| leaf no_standard_descriptor_accessor { |
| type boolean; |
| description |
| "Disables the generation of the standard descriptor() accessor, which can |
| conflict with a field of the same name. This is meant to make migration |
| from proto1 easier; new code should avoid fields named descriptor ."; |
| } |
| |
| leaf deprecated { |
| type boolean; |
| description |
| "Is this message deprecated? |
| Depending on the target platform, this can emit Deprecated annotations |
| for the message, or it will be completely ignored; in the very least, |
| this is a formalization for deprecating messages."; |
| } |
| |
| leaf map_entry { |
| type boolean; |
| description |
| "Whether the message is an automatically generated map entry type for the |
| maps field. |
| |
| For maps fields: |
| map<KeyType, ValueType> map_field = 1; |
| The parsed descriptor looks like: |
| message MapFieldEntry |
| option map_entry = true; |
| optional KeyType key = 1; |
| optional ValueType value = 2; |
| |
| repeated MapFieldEntry map_field = 1; |
| |
| Implementations may choose not to generate the map_entry=true message, but |
| use a native map in the target language to hold the keys and values. |
| The reflection APIs in such implementions still need to work as |
| if the field is a repeated message field. |
| |
| NOTE: Do not set the option in .proto files. Always use the maps syntax |
| instead. The option should only be implicitly set by the proto compiler |
| parser."; |
| } |
| |
| list uninterpreted_option { |
| key "identifier_value"; |
| uses UninterpretedOption; |
| |
| description |
| "The parser stores options it doesn't recognize here. See above."; |
| } |
| |
| } |
| |
| grouping FieldOptions { |
| description |
| ""; |
| leaf ctype { |
| type CType; |
| description |
| "The ctype option instructs the C++ code generator to use a different |
| representation of the field than it normally would. See the specific |
| options below. This option is not yet implemented in the open source |
| release -- sorry, we'll try to include it in a future version!"; |
| } |
| |
| leaf packed { |
| type boolean; |
| description |
| "The packed option can be enabled for repeated primitive fields to enable |
| a more efficient representation on the wire. Rather than repeatedly |
| writing the tag and type for each element, the entire array is encoded as |
| a single length-delimited blob. In proto3, only explicit setting it to |
| false will avoid using packed encoding."; |
| } |
| |
| leaf jstype { |
| type JSType; |
| description |
| "The jstype option determines the JavaScript type used for values of the |
| field. The option is permitted only for 64 bit integral and fixed types |
| (int64, uint64, sint64, fixed64, sfixed64). By default these types are |
| represented as JavaScript strings. This avoids loss of precision that can |
| happen when a large value is converted to a floating point JavaScript |
| numbers. Specifying JS_NUMBER for the jstype causes the generated |
| JavaScript code to use the JavaScript number type instead of strings. |
| This option is an enum to permit additional types to be added, |
| e.g. goog.math.Integer."; |
| } |
| |
| leaf lazy { |
| type boolean; |
| description |
| "Should this field be parsed lazily? Lazy applies only to message-type |
| fields. It means that when the outer message is initially parsed, the |
| inner message's contents will not be parsed but instead stored in encoded |
| form. The inner message will actually be parsed when it is first accessed. |
| |
| This is only a hint. Implementations are free to choose whether to use |
| eager or lazy parsing regardless of the value of this option. However, |
| setting this option true suggests that the protocol author believes that |
| using lazy parsing on this field is worth the additional bookkeeping |
| overhead typically needed to implement it. |
| |
| This option does not affect the public interface of any generated code; |
| all method signatures remain the same. Furthermore, thread-safety of the |
| interface is not affected by this option; const methods remain safe to |
| call from multiple threads concurrently, while non-const methods continue |
| to require exclusive access. |
| |
| |
| Note that implementations may choose not to check required fields within |
| a lazy sub-message. That is, calling IsInitialized() on the outher message |
| may return true even if the inner message has missing required fields. |
| This is necessary because otherwise the inner message would have to be |
| parsed in order to perform the check, defeating the purpose of lazy |
| parsing. An implementation which chooses not to check required fields |
| must be consistent about it. That is, for any particular sub-message, the |
| implementation must either always check its required fields, or never |
| check its required fields, regardless of whether or not the message has |
| been parsed."; |
| } |
| |
| leaf deprecated { |
| type boolean; |
| description |
| "Is this field deprecated? |
| Depending on the target platform, this can emit Deprecated annotations |
| for accessors, or it will be completely ignored; in the very least, this |
| is a formalization for deprecating fields."; |
| } |
| |
| leaf weak { |
| type boolean; |
| description |
| "For Google-internal migration only. Do not use."; |
| } |
| |
| list uninterpreted_option { |
| key "identifier_value"; |
| uses UninterpretedOption; |
| |
| description |
| "The parser stores options it doesn't recognize here. See above."; |
| } |
| |
| typedef CType { |
| type enumeration { |
| enum STRING { |
| description ""; |
| } |
| enum CORD { |
| description ""; |
| } |
| enum STRING_PIECE { |
| description ""; |
| } |
| } |
| description |
| ""; |
| } |
| |
| typedef JSType { |
| type enumeration { |
| enum JS_NORMAL { |
| description ""; |
| } |
| enum JS_STRING { |
| description ""; |
| } |
| enum JS_NUMBER { |
| description ""; |
| } |
| } |
| description |
| ""; |
| } |
| |
| } |
| |
| grouping OneofOptions { |
| description |
| ""; |
| list uninterpreted_option { |
| key "identifier_value"; |
| uses UninterpretedOption; |
| |
| description |
| "The parser stores options it doesn't recognize here. See above."; |
| } |
| |
| } |
| |
| grouping EnumOptions { |
| description |
| ""; |
| leaf allow_alias { |
| type boolean; |
| description |
| "Set this option to true to allow mapping different tag names to the same |
| value."; |
| } |
| |
| leaf deprecated { |
| type boolean; |
| description |
| "Is this enum deprecated? |
| Depending on the target platform, this can emit Deprecated annotations |
| for the enum, or it will be completely ignored; in the very least, this |
| is a formalization for deprecating enums."; |
| } |
| |
| list uninterpreted_option { |
| key "identifier_value"; |
| uses UninterpretedOption; |
| |
| description |
| "The parser stores options it doesn't recognize here. See above."; |
| } |
| |
| } |
| |
| grouping EnumValueOptions { |
| description |
| ""; |
| leaf deprecated { |
| type boolean; |
| description |
| "Is this enum value deprecated? |
| Depending on the target platform, this can emit Deprecated annotations |
| for the enum value, or it will be completely ignored; in the very least, |
| this is a formalization for deprecating enum values."; |
| } |
| |
| list uninterpreted_option { |
| key "identifier_value"; |
| uses UninterpretedOption; |
| |
| description |
| "The parser stores options it doesn't recognize here. See above."; |
| } |
| |
| } |
| |
| grouping ServiceOptions { |
| description |
| ""; |
| leaf deprecated { |
| type boolean; |
| description |
| "Is this service deprecated? |
| Depending on the target platform, this can emit Deprecated annotations |
| for the service, or it will be completely ignored; in the very least, |
| this is a formalization for deprecating services. |
| Note: Field numbers 1 through 32 are reserved for Google's internal RPC |
| framework. We apologize for hoarding these numbers to ourselves, but |
| we were already using them long before we decided to release Protocol |
| Buffers."; |
| } |
| |
| list uninterpreted_option { |
| key "identifier_value"; |
| uses UninterpretedOption; |
| |
| description |
| "The parser stores options it doesn't recognize here. See above."; |
| } |
| |
| } |
| |
| grouping MethodOptions { |
| description |
| ""; |
| leaf deprecated { |
| type boolean; |
| description |
| "Is this method deprecated? |
| Depending on the target platform, this can emit Deprecated annotations |
| for the method, or it will be completely ignored; in the very least, |
| this is a formalization for deprecating methods. |
| Note: Field numbers 1 through 32 are reserved for Google's internal RPC |
| framework. We apologize for hoarding these numbers to ourselves, but |
| we were already using them long before we decided to release Protocol |
| Buffers."; |
| } |
| |
| list uninterpreted_option { |
| key "identifier_value"; |
| uses UninterpretedOption; |
| |
| description |
| "The parser stores options it doesn't recognize here. See above."; |
| } |
| |
| } |
| |
| grouping UninterpretedOption { |
| description |
| "A message representing a option the parser does not recognize. This only |
| appears in options protos created by the compiler::Parser class. |
| DescriptorPool resolves these when building Descriptor objects. Therefore, |
| options protos in descriptor objects (e.g. returned by Descriptor::options(), |
| or produced by Descriptor::CopyTo()) will never have UninterpretedOptions |
| in them."; |
| |
| leaf identifier_value { |
| type string; |
| description |
| "The value of the uninterpreted option, in whatever type the tokenizer |
| identified it as during parsing. Exactly one of these should be set."; |
| } |
| |
| leaf positive_int_value { |
| type uint64; |
| description |
| ""; |
| } |
| |
| leaf negative_int_value { |
| type int64; |
| description |
| ""; |
| } |
| |
| leaf double_value { |
| type decimal64 { |
| fraction-digits 5; |
| } |
| description |
| ""; |
| } |
| |
| leaf string_value { |
| type binary; |
| description |
| ""; |
| } |
| |
| leaf aggregate_value { |
| type string; |
| description |
| ""; |
| } |
| |
| grouping NamePart { |
| description |
| "The name of the uninterpreted option. Each string represents a segment in |
| a dot-separated name. is_extension is true iff a segment represents an |
| extension (denoted with parentheses in options specs in .proto files). |
| E.g., foo , false , bar.baz , true , qux , false represents |
| foo.(bar.baz).qux ."; |
| leaf name_part { |
| type string; |
| description |
| ""; |
| } |
| |
| leaf is_extension { |
| type boolean; |
| description |
| ""; |
| } |
| |
| } |
| |
| } |
| |
| grouping SourceCodeInfo { |
| description |
| "Encapsulates information about the original source file from which a |
| FileDescriptorProto was generated. |
| =================================================================== |
| Optional source code info"; |
| |
| grouping Location { |
| description |
| ""; |
| list path { |
| key "path"; |
| leaf path { |
| type int32; |
| description |
| "Identifies which part of the FileDescriptorProto was defined at this |
| location. |
| |
| Each element is a field number or an index. They form a path from |
| the root FileDescriptorProto to the place where the definition. For |
| example, this path: |
| 4, 3, 2, 7, 1 |
| refers to: |
| file.message_type(3) 4, 3 |
| .field(7) 2, 7 |
| .name() 1 |
| This is because FileDescriptorProto.message_type has field number 4: |
| repeated DescriptorProto message_type = 4; |
| and DescriptorProto.field has field number 2: |
| repeated FieldDescriptorProto field = 2; |
| and FieldDescriptorProto.name has field number 1: |
| optional string name = 1; |
| |
| Thus, the above path gives the location of a field name. If we removed |
| the last element: |
| 4, 3, 2, 7 |
| this path refers to the whole field declaration (from the beginning |
| of the label to the terminating semicolon)."; |
| } |
| description |
| "Identifies which part of the FileDescriptorProto was defined at this |
| location. |
| |
| Each element is a field number or an index. They form a path from |
| the root FileDescriptorProto to the place where the definition. For |
| example, this path: |
| 4, 3, 2, 7, 1 |
| refers to: |
| file.message_type(3) 4, 3 |
| .field(7) 2, 7 |
| .name() 1 |
| This is because FileDescriptorProto.message_type has field number 4: |
| repeated DescriptorProto message_type = 4; |
| and DescriptorProto.field has field number 2: |
| repeated FieldDescriptorProto field = 2; |
| and FieldDescriptorProto.name has field number 1: |
| optional string name = 1; |
| |
| Thus, the above path gives the location of a field name. If we removed |
| the last element: |
| 4, 3, 2, 7 |
| this path refers to the whole field declaration (from the beginning |
| of the label to the terminating semicolon)."; |
| } |
| |
| list span { |
| key "span"; |
| leaf span { |
| type int32; |
| description |
| "Always has exactly three or four elements: start line, start column, |
| end line (optional, otherwise assumed same as start line), end column. |
| These are packed into a single field for efficiency. Note that line |
| and column numbers are zero-based -- typically you will want to add |
| 1 to each before displaying to a user."; |
| } |
| description |
| "Always has exactly three or four elements: start line, start column, |
| end line (optional, otherwise assumed same as start line), end column. |
| These are packed into a single field for efficiency. Note that line |
| and column numbers are zero-based -- typically you will want to add |
| 1 to each before displaying to a user."; |
| } |
| |
| leaf leading_comments { |
| type string; |
| description |
| "If this SourceCodeInfo represents a complete declaration, these are any |
| comments appearing before and after the declaration which appear to be |
| attached to the declaration. |
| |
| A series of line comments appearing on consecutive lines, with no other |
| tokens appearing on those lines, will be treated as a single comment. |
| |
| leading_detached_comments will keep paragraphs of comments that appear |
| before (but not connected to) the current element. Each paragraph, |
| separated by empty lines, will be one comment element in the repeated |
| field. |
| |
| Only the comment content is provided; comment markers (e.g. ) are |
| stripped out. For block comments, leading whitespace and an asterisk |
| will be stripped from the beginning of each line other than the first. |
| Newlines are included in the output. |
| |
| Examples: |
| |
| optional int32 foo = 1; Comment attached to foo. |
| Comment attached to bar. |
| optional int32 bar = 2; |
| |
| optional string baz = 3; |
| Comment attached to baz. |
| Another line attached to baz. |
| |
| Comment attached to qux. |
| |
| Another line attached to qux. |
| optional double qux = 4; |
| |
| Detached comment for corge. This is not leading or trailing comments |
| to qux or corge because there are blank lines separating it from |
| both. |
| |
| Detached comment for corge paragraph 2. |
| |
| optional string corge = 5; |
| Block comment attached |
| to corge. Leading asterisks |
| will be removed. |
| Block comment attached to |
| grault. |
| optional int32 grault = 6; |
| |
| ignored detached comments."; |
| } |
| |
| leaf trailing_comments { |
| type string; |
| description |
| ""; |
| } |
| |
| list leading_detached_comments { |
| key "leading_detached_comments"; |
| leaf leading_detached_comments { |
| type string; |
| description |
| ""; |
| } |
| description |
| ""; |
| } |
| |
| } |
| |
| } |
| |
| container GeneratedCodeInfo { |
| description |
| "Describes the relationship between generated code and its original source |
| file. A GeneratedCodeInfo message is associated with only one generated |
| source file, but may contain references to different source .proto files."; |
| |
| grouping Annotation { |
| description |
| ""; |
| list path { |
| key "path"; |
| leaf path { |
| type int32; |
| description |
| "Identifies the element in the original source .proto file. This field |
| is formatted the same as SourceCodeInfo.Location.path."; |
| } |
| description |
| "Identifies the element in the original source .proto file. This field |
| is formatted the same as SourceCodeInfo.Location.path."; |
| } |
| |
| leaf source_file { |
| type string; |
| description |
| "Identifies the filesystem path to the original source .proto."; |
| } |
| |
| leaf begin { |
| type int32; |
| description |
| "Identifies the starting offset in bytes in the generated code |
| that relates to the identified object."; |
| } |
| |
| leaf end { |
| type int32; |
| description |
| "Identifies the ending offset in bytes in the generated code that |
| relates to the identified offset. The end offset should be one past |
| the last relevant byte (so the length of the text = end - begin)."; |
| } |
| |
| } |
| |
| } |
| |
| } |