v2.6.0

2014-08-15 version 2.6.0

General

• Added oneofs(unions) feature. Fields in the same oneof will share
  memory and at most one field can be set at the same time. Use the
  oneof keyword to define a oneof like:

  message SampleMessage {
    oneof test_oneof {
      string name = 4;
      YourMessage sub_message = 9;
    }
  }
  

• Files, services, enums, messages, methods and enum values can be marked
  as deprecated now.

• Added Support for list values, including lists of mesaages, when
  parsing text-formatted protos in C++ and Java.

  For example:  foo: [1, 2, 3]
  

C++

• Enhanced customization on TestFormat printing.
• Added SwapFields() in reflection API to swap a subset of fields.
  Added SetAllocatedMessage() in reflection API.
• Repeated primitive extensions are now packable. The
  [packed=true] option only affects serializers. Therefore, it is
  possible to switch a repeated extension field to packed format
  without breaking backwards-compatibility.
• Various speed optimizations.

Java

• writeTo() method in ByteString can now write a substring to an
  output stream. Added endWith() method for ByteString.
• ByteString and ByteBuffer are now supported in CodedInputStream
  and CodedOutputStream.
• java_generate_equals_and_hash can now be used with the LITE_RUNTIME.

Python

• A new C++-backed extension module (aka "cpp api v2") that replaces the
  old ("cpp api v1") one. Much faster than the pure Python code. This one
  resolves many bugs and is recommended for general use over the
  pure Python when possible.
• Descriptors now have enum_types_by_name and extension_types_by_name dict
  attributes.
• Support for Python 3.

Protocol Buffers v2.5.0

Version 2.5.0

General

• New notion "import public" that allows a proto file to forward the content
  it imports to its importers. For example,

  // foo.proto
  import public "bar.proto";
  import "baz.proto";
  
  // qux.proto
  import "foo.proto";
  // Stuff defined in bar.proto may be used in this file, but stuff from
  // baz.proto may NOT be used without importing it explicitly.
  

  This is useful for moving proto files. To move a proto file, just leave
  a single "import public" in the old proto file.

• New enum option "allow_alias" that specifies whether different symbols can
  be assigned the same numeric value. Default value is "true". Setting it to
  false causes the compiler to reject enum definitions where multiple symbols
  have the same numeric value.
  Note: We plan to flip the default value to "false" in a future release.
  Projects using enum aliases should set the option to "true" in their .proto
  files.

C++

• New generated method set_allocated_foo(Type* foo) for message and string
  fields. This method allows you to set the field to a pre-allocated object
  and the containing message takes the ownership of that object.
• Added SetAllocatedExtension() and ReleaseExtension() to extensions API.
• Custom options are now formatted correctly when descriptors are printed in
  text format.
• Various speed optimizations.

Java

• Comments in proto files are now collected and put into generated code as
  comments for corresponding classes and data members.

• Added Parser to parse directly into messages without a Builder. For
  example,

  Foo foo = Foo.PARSER.ParseFrom(input);
  

  Using Parser is ~25% faster than using Builder to parse messages.

• Added getters/setters to access the underlying ByteString of a string field
  directly.

• ByteString now supports more operations: substring(), prepend(), and
  append(). The implementation of ByteString uses a binary tree structure
  to support these operations efficiently.

• New method findInitializationErrors() that lists all missing required
  fields.

• Various code size and speed optimizations.

Python

• Added support for dynamic message creation. DescriptorDatabase,
  DescriptorPool, and MessageFactory work like their C++ couterparts to
  simplify Descriptor construction from *DescriptorProtos, and MessageFactory
  provides a message instance from a Descriptor.
• Added pickle support for protobuf messages.
• Unknown fields are now preserved after parsing.
• Fixed bug where custom options were not correctly populated. Custom
  options can be accessed now.
• Added EnumTypeWrapper that provides better accessibility to enum types.
• Added ParseMessage(descriptor, bytes) to generate a new Message instance
  from a descriptor and a byte string.

Protocol Buffers v2.4.1

Version 2.4.1

C++

• Fixed the frendship problem for old compilers to make the library now gcc 3
  compatible again.
• Fixed vcprojects/extract_includes.bat to extract compiler/plugin.h.

Java

• Removed usages of JDK 1.6 only features to make the library now JDK 1.5
  compatible again.
• Fixed a bug about negative enum values.
• serialVersionUID is now defined in generated messages for java serializing.
• Fixed protoc to use java.lang.Object, which makes "Object" now a valid
  message name again.

Python

• Experimental C++ implementation now requires C++ protobuf library installed.
  See the README.txt in the python directory for details.