descriptor.proto - jasagiri @ ウィキ

package google.protobuf;
option java_package = "com.google.protobuf";
option java_outer_classname = "DescriptorProtos";

option optimize_for = SPEED;

message FileDescriptorSet {

 repeated FileDescriptorProto file = 1;

}

message FileDescriptorProto {

 optional string name = 1;       // file name, relative to root of source tree
 optional string package = 2;    // e.g. "foo", "foo.bar", etc.

 // Names of files imported by this file.
 repeated string dependency = 3;

 // All top-level definitions in this file.
 repeated DescriptorProto message_type = 4;
 repeated EnumDescriptorProto enum_type = 5;
 repeated ServiceDescriptorProto service = 6;
 repeated FieldDescriptorProto extension = 7;

 optional FileOptions options = 8;

}

message DescriptorProto {

 optional string name = 1;

 repeated FieldDescriptorProto field = 2;
 repeated FieldDescriptorProto extension = 6;

 repeated DescriptorProto nested_type = 3;
 repeated EnumDescriptorProto enum_type = 4;

 message ExtensionRange {
   optional int32 start = 1;
   optional int32 end = 2;
 }
 repeated ExtensionRange extension_range = 5;

 optional MessageOptions options = 7;

}

message FieldDescriptorProto {

 enum Type {
   // 0 is reserved for errors.
   // Order is weird for historical reasons.
   TYPE_DOUBLE         = 1;
   TYPE_FLOAT          = 2;
   TYPE_INT64          = 3;   // Not ZigZag encoded.  Negative numbers
                              // take 10 bytes.  Use TYPE_SINT64 if negative
                              // values are likely.
   TYPE_UINT64         = 4;
   TYPE_INT32          = 5;   // Not ZigZag encoded.  Negative numbers
                              // take 10 bytes.  Use TYPE_SINT32 if negative
                              // values are likely.
   TYPE_FIXED64        = 6;
   TYPE_FIXED32        = 7;
   TYPE_BOOL           = 8;
   TYPE_STRING         = 9;
   TYPE_GROUP          = 10;  // Tag-delimited aggregate.
   TYPE_MESSAGE        = 11;  // Length-delimited aggregate.

   // New in version 2.
   TYPE_BYTES          = 12;
   TYPE_UINT32         = 13;
   TYPE_ENUM           = 14;
   TYPE_SFIXED32       = 15;
   TYPE_SFIXED64       = 16;
   TYPE_SINT32         = 17;  // Uses ZigZag encoding.
   TYPE_SINT64         = 18;  // Uses ZigZag encoding.
 };

 enum Label {
   // 0 is reserved for errors
   LABEL_OPTIONAL      = 1;
   LABEL_REQUIRED      = 2;
   LABEL_REPEATED      = 3;
   // TODO(sanjay): Should we add LABEL_MAP?
 };

 optional string name = 1;
 optional int32 number = 3;
 optional Label label = 4;

 // If type_name is set, this need not be set.  If both this and type_name
 // are set, this must be either TYPE_ENUM or TYPE_MESSAGE.
 optional Type type = 5;

 // 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).
 optional string type_name = 6;

 // For extensions, this is the name of the type being extended.  It is
 // resolved in the same manner as type_name.
 optional string extendee = 2;

 // 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?
 optional string default_value = 7;

 optional FieldOptions options = 8;

}

message EnumDescriptorProto {

 optional string name = 1;

 repeated EnumValueDescriptorProto value = 2;

 optional EnumOptions options = 3;

}

message EnumValueDescriptorProto {

 optional string name = 1;
 optional int32 number = 2;

 optional EnumValueOptions options = 3;

}

message ServiceDescriptorProto {

 optional string name = 1;
 repeated MethodDescriptorProto method = 2;

 optional ServiceOptions options = 3;

}

message MethodDescriptorProto {

 optional string name = 1;

 // Input and output type names.  These are resolved in the same way as
 // FieldDescriptorProto.type_name, but must refer to a message type.
 optional string input_type = 2;
 optional string output_type = 3;

 optional MethodOptions options = 4;

}

message FileOptions {

 // 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.
 optional string java_package = 1;

 // 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).
 optional string java_outer_classname = 8;

 // 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.
 optional bool java_multiple_files = 10 [default=false];

 // Generated classes can be optimized for speed or code size.
 enum OptimizeMode {
   SPEED = 1;        // Generate complete code for parsing, serialization,
                     // etc.
   CODE_SIZE = 2;    // Use ReflectionOps to implement these methods.
   LITE_RUNTIME = 3; // Generate code using MessageLite and the lite runtime.
 }
 optional OptimizeMode optimize_for = 9 [default=SPEED];

 // The parser stores options it doesn't recognize here. See above.
 repeated UninterpretedOption uninterpreted_option = 999;

 // Clients can define custom options in extensions of this message. See above.
 extensions 1000 to max;

}

message MessageOptions {

 // 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.
 optional bool message_set_wire_format = 1 [default=false];

 // 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".
 optional bool no_standard_descriptor_accessor = 2 [default=false];

 // The parser stores options it doesn't recognize here. See above.
 repeated UninterpretedOption uninterpreted_option = 999;

 // Clients can define custom options in extensions of this message. See above.
 extensions 1000 to max;

}

message FieldOptions {

 // 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!
 optional CType ctype = 1;
 enum CType {
   CORD = 1;

   STRING_PIECE = 2;
 }
 // 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.
 optional bool packed = 2;

 // 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.
 optional bool deprecated = 3 [default=false];

 // EXPERIMENTAL.  DO NOT USE.
 // For "map" fields, the name of the field in the enclosed type that
 // is the key for this map.  For example, suppose we have:
 //   message Item {
 //     required string name = 1;
 //     required string value = 2;
 //   }
 //   message Config {
 //     repeated Item items = 1 [experimental_map_key="name"];
 //   }
 // In this situation, the map key for Item will be set to "name".
 // TODO: Fully-implement this, then remove the "experimental_" prefix.
 optional string experimental_map_key = 9;

 // The parser stores options it doesn't recognize here. See above.
 repeated UninterpretedOption uninterpreted_option = 999;

 // Clients can define custom options in extensions of this message. See above.
 extensions 1000 to max;

}

message EnumOptions {

 // The parser stores options it doesn't recognize here. See above.
 repeated UninterpretedOption uninterpreted_option = 999;

 // Clients can define custom options in extensions of this message. See above.
 extensions 1000 to max;

}

message EnumValueOptions {

 // The parser stores options it doesn't recognize here. See above.
 repeated UninterpretedOption uninterpreted_option = 999;

 // Clients can define custom options in extensions of this message. See above.
 extensions 1000 to max;

}

message ServiceOptions {

 // 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.

 // The parser stores options it doesn't recognize here. See above.
 repeated UninterpretedOption uninterpreted_option = 999;

 // Clients can define custom options in extensions of this message. See above.
 extensions 1000 to max;

}

message MethodOptions {

 // 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.

 // The parser stores options it doesn't recognize here. See above.
 repeated UninterpretedOption uninterpreted_option = 999;

 // Clients can define custom options in extensions of this message. See above.
 extensions 1000 to max;

}

message UninterpretedOption {

 // 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".
 message NamePart {
   required string name_part = 1;
   required bool is_extension = 2;
 }
 repeated NamePart name = 2;

 // The value of the uninterpreted option, in whatever type the tokenizer
 // identified it as during parsing. Exactly one of these should be set.
 optional string identifier_value = 3;
 optional uint64 positive_int_value = 4;
 optional int64 negative_int_value = 5;
 optional double double_value = 6;
 optional bytes string_value = 7;

}