ruby-protocol-buffers 0.8.4

data/ext/extconf.disabled.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile "ruby_protobufs"

data/ext/varint.c

@@ -0,0 +1,65 @@
+#include "ruby.h"
+
+static VALUE Protobuf, Varint;
+static ID getbyte, putbyte;
+
+static VALUE varint_encode(VALUE module, VALUE io, VALUE int_valV)
+{
+    /* unsigned for the bit shifting ops */
+    unsigned long long int_val = (unsigned long long)NUM2LL(int_valV);
+    unsigned char byte;
+    while (1) {
+        byte = int_val & 0x7f;
+        int_val >>= 7;
+        if (int_val == 0) {
+            rb_funcall(io, putbyte, 1, INT2FIX(byte));
+            return Qnil;
+        } else {
+            rb_funcall(io, putbyte, 1, INT2FIX(byte | 0x80));
+        }
+    }
+}
+
+static VALUE varint_decode(VALUE module, VALUE io)
+{
+    unsigned long long int_val = 0;
+    unsigned shift = 0;
+    unsigned char byte;
+
+    while (1) {
+        if (shift >= 64) {
+            rb_raise(rb_eArgError, "too many bytes when decoding varint");
+        }
+        byte = (unsigned char)FIX2INT(rb_funcall(io, getbyte, 0));
+        int_val |= ((unsigned long long)(byte & 0x7f)) << shift;
+        shift += 7;
+        if ((byte & 0x80) == 0) {
+            /* return ULL2NUM(int_val); */
+            return LL2NUM((long long)int_val);
+        }
+    }
+}
+
+void Init_ruby_protobufs()
+{
+    Protobuf = rb_define_module("Protobuf");
+    Varint = rb_define_module_under(Protobuf, "Varint");
+
+    VALUE zero = INT2FIX(0);
+    VALUE test_io = rb_class_new_instance(1, &zero,
+            rb_const_get(rb_cObject, rb_intern("IO")));
+
+    /* hackish way to support both 1.8.6 and 1.8.7+ */
+    getbyte = rb_intern("getbyte");
+    if (!rb_respond_to(test_io, getbyte)) {
+        getbyte = rb_intern("getc");
+    }
+
+    /* TODO: check the api docs -- what happens to test_io here?
+     * does it just leak? */
+
+    putbyte = rb_intern("putc");
+
+    rb_define_module_function(Varint, "encode", varint_encode, 2);
+    rb_define_module_function(Varint, "decode", varint_decode, 1);
+}

data/lib/protocol_buffers.rb

@@ -0,0 +1,5 @@
+module ProtocolBuffers
+  VERSION = File.read(File.join(File.dirname(__FILE__), "..", "VERSION")).chomp
+end
+
+require 'protocol_buffers/runtime/message'

data/lib/protocol_buffers/compiler.rb

@@ -0,0 +1,48 @@
+require 'protocol_buffers/compiler/descriptor.pb'
+
+module ProtocolBuffers
+  class CompileError < StandardError; end
+
+  module Compiler
+    def self.compile(output_filename, input_files, opts = {})
+      input_files = Array(input_files) unless input_files.is_a?(Array)
+      raise(ArgumentError, "Need at least one input file") if input_files.empty?
+      other_opts = ""
+      (opts[:include_dirs] || []).each { |d| other_opts += " -I#{d}" }
+      input_files.each { |f| other_opts += " -I#{File.dirname(f)}" }
+
+      cmd = "protoc #{other_opts} -o#{output_filename} #{input_files.join(' ')}"
+      rc = system(cmd)
+      raise(CompileError, $?.exitstatus.to_s) unless rc
+      true
+    end
+
+    def self.compile_and_load(input_files, opts = {})
+      require 'tempfile'
+      require 'protocol_buffers/compiler/file_descriptor_to_ruby'
+
+      tempfile = Tempfile.new("protocol_buffers_spec")
+      compile(tempfile.path, input_files, opts)
+      descriptor_set = FileDescriptorSet.parse(tempfile)
+      tempfile.close(true)
+      descriptor_set.file.each do |file|
+        parsed = FileDescriptorToRuby.new(file)
+        output = Tempfile.new("protocol_buffers_spec_parsed")
+        parsed.write(output)
+        output.flush
+        load output.path
+        output.close(true)
+      end
+      true
+    end
+
+    def self.compile_and_load_string(input, opts = {})
+      require 'tempfile'
+      tempfile = Tempfile.new("protocol_buffers_load_string")
+      tempfile.write(input)
+      tempfile.flush
+      (opts[:include_dirs] ||= []) << File.dirname(tempfile.path)
+      compile_and_load(tempfile.path, opts)
+    end
+  end
+end

data/lib/protocol_buffers/compiler/descriptor.pb.rb

@@ -0,0 +1,236 @@
+#!/usr/bin/env ruby
+# Generated by the protocol buffer compiler. DO NOT EDIT!
+
+require 'protocol_buffers/runtime/message'
+
+# forward declarations
+class ::FileDescriptorSet < ::ProtocolBuffers::Message; end
+class ::FileDescriptorProto < ::ProtocolBuffers::Message; end
+class ::DescriptorProto < ::ProtocolBuffers::Message; end
+class ::FieldDescriptorProto < ::ProtocolBuffers::Message; end
+class ::EnumDescriptorProto < ::ProtocolBuffers::Message; end
+class ::EnumValueDescriptorProto < ::ProtocolBuffers::Message; end
+class ::ServiceDescriptorProto < ::ProtocolBuffers::Message; end
+class ::MethodDescriptorProto < ::ProtocolBuffers::Message; end
+class ::FileOptions < ::ProtocolBuffers::Message; end
+class ::MessageOptions < ::ProtocolBuffers::Message; end
+class ::FieldOptions < ::ProtocolBuffers::Message; end
+class ::EnumOptions < ::ProtocolBuffers::Message; end
+class ::EnumValueOptions < ::ProtocolBuffers::Message; end
+class ::ServiceOptions < ::ProtocolBuffers::Message; end
+class ::MethodOptions < ::ProtocolBuffers::Message; end
+class ::UninterpretedOption < ::ProtocolBuffers::Message; end
+
+class FileDescriptorSet < ::ProtocolBuffers::Message
+  repeated ::FileDescriptorProto, :file, 1
+
+  gen_methods! # new fields ignored after this point
+end
+
+class FileDescriptorProto < ::ProtocolBuffers::Message
+  optional :string, :name, 1
+  optional :string, :package_, 2
+  repeated :string, :dependency, 3
+  repeated ::DescriptorProto, :message_type, 4
+  repeated ::EnumDescriptorProto, :enum_type, 5
+  repeated ::ServiceDescriptorProto, :service_, 6
+  repeated ::FieldDescriptorProto, :extension, 7
+  optional ::FileOptions, :options, 8
+
+  gen_methods! # new fields ignored after this point
+end
+
+class DescriptorProto < ::ProtocolBuffers::Message
+  # forward declarations
+  class ::ExtensionRange < ::ProtocolBuffers::Message; end
+
+  # nested messages
+  class ExtensionRange < ::ProtocolBuffers::Message
+    optional :int32, :start, 1
+    optional :int32, :end, 2
+
+    gen_methods! # new fields ignored after this point
+  end
+
+  optional :string, :name, 1
+  repeated ::FieldDescriptorProto, :field, 2
+  repeated ::FieldDescriptorProto, :extension, 6
+  repeated ::DescriptorProto, :nested_type, 3
+  repeated ::EnumDescriptorProto, :enum_type, 4
+  repeated ::DescriptorProto::ExtensionRange, :extension_range, 5
+  optional ::MessageOptions, :options, 7
+
+  gen_methods! # new fields ignored after this point
+end
+
+class FieldDescriptorProto < ::ProtocolBuffers::Message
+  # forward declarations
+  module ::Type; end
+  module ::Label; end
+
+  # nested enums
+  module Type
+    include ::ProtocolBuffers::Enum
+    TYPE_DOUBLE = 1
+    TYPE_FLOAT = 2
+    TYPE_INT64 = 3
+    TYPE_UINT64 = 4
+    TYPE_INT32 = 5
+    TYPE_FIXED64 = 6
+    TYPE_FIXED32 = 7
+    TYPE_BOOL = 8
+    TYPE_STRING = 9
+    TYPE_GROUP = 10
+    TYPE_MESSAGE = 11
+    TYPE_BYTES = 12
+    TYPE_UINT32 = 13
+    TYPE_ENUM = 14
+    TYPE_SFIXED32 = 15
+    TYPE_SFIXED64 = 16
+    TYPE_SINT32 = 17
+    TYPE_SINT64 = 18
+  end
+
+  module Label
+    include ::ProtocolBuffers::Enum
+    LABEL_OPTIONAL = 1
+    LABEL_REQUIRED = 2
+    LABEL_REPEATED = 3
+  end
+
+  optional :string, :name, 1
+  optional :int32, :number, 3
+  optional ::FieldDescriptorProto::Label, :label, 4
+  optional ::FieldDescriptorProto::Type, :type, 5
+  optional :string, :type_name, 6
+  optional :string, :extendee, 2
+  optional :string, :default_value, 7
+  optional ::FieldOptions, :options, 8
+
+  gen_methods! # new fields ignored after this point
+end
+
+class EnumDescriptorProto < ::ProtocolBuffers::Message
+  optional :string, :name, 1
+  repeated ::EnumValueDescriptorProto, :value, 2
+  optional ::EnumOptions, :options, 3
+
+  gen_methods! # new fields ignored after this point
+end
+
+class EnumValueDescriptorProto < ::ProtocolBuffers::Message
+  optional :string, :name, 1
+  optional :int32, :number, 2
+  optional ::EnumValueOptions, :options, 3
+
+  gen_methods! # new fields ignored after this point
+end
+
+class ServiceDescriptorProto < ::ProtocolBuffers::Message
+  optional :string, :name, 1
+  repeated ::MethodDescriptorProto, :method, 2
+  optional ::ServiceOptions, :options, 3
+
+  gen_methods! # new fields ignored after this point
+end
+
+class MethodDescriptorProto < ::ProtocolBuffers::Message
+  optional :string, :name, 1
+  optional :string, :input_type, 2
+  optional :string, :output_type, 3
+  optional ::MethodOptions, :options, 4
+
+  gen_methods! # new fields ignored after this point
+end
+
+class FileOptions < ::ProtocolBuffers::Message
+  # forward declarations
+  module ::OptimizeMode; end
+
+  # nested enums
+  module OptimizeMode
+    include ::ProtocolBuffers::Enum
+    SPEED = 1
+    CODE_SIZE = 2
+  end
+
+  optional :string, :java_package, 1
+  optional :string, :java_outer_classname, 8
+  optional :bool, :java_multiple_files, 10, :default => false
+  optional ::FileOptions::OptimizeMode, :optimize_for, 9, :default => ::FileOptions::OptimizeMode::CODE_SIZE
+  repeated ::UninterpretedOption, :uninterpreted_option, 999
+
+  gen_methods! # new fields ignored after this point
+end
+
+class MessageOptions < ::ProtocolBuffers::Message
+  optional :bool, :message_set_wire_format, 1, :default => false
+  repeated ::UninterpretedOption, :uninterpreted_option, 999
+
+  gen_methods! # new fields ignored after this point
+end
+
+class FieldOptions < ::ProtocolBuffers::Message
+  # forward declarations
+  module ::CType; end
+
+  # nested enums
+  module CType
+    include ::ProtocolBuffers::Enum
+    CORD = 1
+    STRING_PIECE = 2
+  end
+
+  optional ::FieldOptions::CType, :ctype, 1
+  optional :string, :experimental_map_key, 9
+  repeated ::UninterpretedOption, :uninterpreted_option, 999
+
+  gen_methods! # new fields ignored after this point
+end
+
+class EnumOptions < ::ProtocolBuffers::Message
+  repeated ::UninterpretedOption, :uninterpreted_option, 999
+
+  gen_methods! # new fields ignored after this point
+end
+
+class EnumValueOptions < ::ProtocolBuffers::Message
+  repeated ::UninterpretedOption, :uninterpreted_option, 999
+
+  gen_methods! # new fields ignored after this point
+end
+
+class ServiceOptions < ::ProtocolBuffers::Message
+  repeated ::UninterpretedOption, :uninterpreted_option, 999
+
+  gen_methods! # new fields ignored after this point
+end
+
+class MethodOptions < ::ProtocolBuffers::Message
+  repeated ::UninterpretedOption, :uninterpreted_option, 999
+
+  gen_methods! # new fields ignored after this point
+end
+
+class UninterpretedOption < ::ProtocolBuffers::Message
+  # forward declarations
+  class ::NamePart < ::ProtocolBuffers::Message; end
+
+  # nested messages
+  class NamePart < ::ProtocolBuffers::Message
+    required :string, :name_part, 1
+    required :bool, :is_extension, 2
+
+    gen_methods! # new fields ignored after this point
+  end
+
+  repeated ::UninterpretedOption::NamePart, :name, 2
+  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
+
+  gen_methods! # new fields ignored after this point
+end
+

data/lib/protocol_buffers/compiler/descriptor.proto

@@ -0,0 +1,393 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// The messages in this file describe the definitions found in .proto files.
+// A valid .proto file can be translated directly to a FileDescriptorProto
+// without any other information (e.g. without reading its imports).
+
+
+
+// package google.protobuf;
+// option java_package = "com.google.protobuf";
+// option java_outer_classname = "DescriptorProtos";
+
+// descriptor.proto must be optimized for speed because reflection-based
+// algorithms don't work during bootstrapping.
+// option optimize_for = SPEED;
+
+// The protocol compiler can output a FileDescriptorSet containing the .proto
+// files it parses.
+message FileDescriptorSet {
+  repeated FileDescriptorProto file = 1;
+}
+
+// Describes a complete .proto file.
+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;
+}
+
+// Describes a message type.
+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;
+}
+
+// Describes a field within a message.
+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;
+}
+
+// Describes an enum type.
+message EnumDescriptorProto {
+  optional string name = 1;
+
+  repeated EnumValueDescriptorProto value = 2;
+
+  optional EnumOptions options = 3;
+}
+
+// Describes a value within an enum.
+message EnumValueDescriptorProto {
+  optional string name = 1;
+  optional int32 number = 2;
+
+  optional EnumValueOptions options = 3;
+}
+
+// Describes a service.
+message ServiceDescriptorProto {
+  optional string name = 1;
+  repeated MethodDescriptorProto method = 2;
+
+  optional ServiceOptions options = 3;
+}
+
+// Describes a method of a service.
+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;
+}
+
+// ===================================================================
+// 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 kenton@google.com to reserve extension
+//   numbers.  Simply tell me how many you need and I'll send you back a
+//   set of numbers to use -- there's no need to explain how you intend to
+//   use them.  If this turns out to be popular, a web service will be set up
+//   to automatically assign option numbers.
+
+
+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.
+  }
+  optional OptimizeMode optimize_for = 9 [default=CODE_SIZE];
+
+
+  // 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];
+
+  // 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;
+  }
+
+  // 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;
+}
+
+// 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.
+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;
+}