What's new in Protocol Buffers 2.5.0
Feb 28, 2013
- 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.
- 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.getParser().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.
New in Protocol Buffers 2.5.0 RC 1 (Dec 13, 2012)
- 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.
- 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.getParser().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.
New in Protocol Buffers 2.4.1 (May 2, 2011)
- 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.
New in Protocol Buffers 2.4.0 (Jan 24, 2011)
- General
- The RPC (cc|java|py)_generic_services default value is now false instead of true.
- Custom options can have aggregate types. For example,
- C++
- Various speed and code size optimizations.
- Added a release_foo() method on string and message fields.
- Fixed gzip_output_stream sub-stream handling.
- Java
- Builders now maintain sub-builders for sub-messages. Use getFooBuilder() to get the builder for the sub-message "foo". This allows you to repeatedly modify deeply-nested sub-messages without rebuilding them.
- Builder.build() no longer invalidates the Builder for generated messages
- Code generator will generate efficient equals() and hashCode()implementations if new option java_generate_equals_and_hash is enabled.
- Generated messages now implement Serializable.
- Fields with [deprecated=true] will be marked with @Deprecated in Java.
- Added lazy conversion of UTF-8 encoded strings to String objects to improve performance.
- Various optimizations.
- Enum value can be accessed directly, instead of calling getNumber() on the enum member.
- For each enum value, an integer constant is also generated with the suffix
- Added an experimental C++ implementation for Python messages via a Python extension.
- The default value is currently "python" but will be changed to "cpp"in future release.
- Improved performance on message instantiation significantly. Most of the work on message instantiation is done just once per message class, instead of once per message instance.
- Improved performance on text message parsing.
- Allow add() to forward keyword arguments to the concrete class.
- Added a sort() interface to the BaseContainer.
- Added an extend() method to repeated composite fields.
- Added UTF8 debug string support.
New in Protocol Buffers 2.3.0 (Apr 7, 2010)
- General
- Parsers for repeated numeric fields now always accept both packed and unpacked input. The [packed=true] option only affects serializers.
- Therefore, it is possible to switch a field to packed format without breaking backwards-compatibility -- as long as all parties are using protobuf 2.3.0 or above, at least.
- The generic RPC service code generated by the C++, Java, and Python generators can be disabled via file options:
- Now supports a plugin system for code generators. Plugins can generate code for new languages or inject additional code into the output of other code generators. Plugins are just binaries which accept a protocol buffer on stdin and write a protocol buffer to stdout, so they may be written in any language.