|
|
2017-08-01 version 3.4.0 (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript) |
|
|
Planned Future Changes |
|
|
* There are some changes that are not included in this release but are planned |
|
|
for the near future |
|
|
- Preserve unknown fields in proto3: We are going to bring unknown fields |
|
|
back into proto3. In this release, some languages start to support |
|
|
preserving unknown fields in proto3, controlled by flags/options. Some |
|
|
languages also introduce explict APIs to drop unknown fields for |
|
|
migration. Please read the change log sections by languages for details. |
|
|
For general timeline and plan: |
|
|
|
|
|
https://docs.google.com/document/d/1KMRX-G91Aa-Y2FkEaHeeviLRRNblgIahbsk4wA14gRk/view |
|
|
|
|
|
For issues and discussions: |
|
|
|
|
|
https://github.com/google/protobuf/issues/272 |
|
|
|
|
|
- Make C++ implementation C++11 only: we plan to require C++11 to build |
|
|
protobuf code starting from 3.5.0 or 3.6.0 release, after unknown fields |
|
|
semantic changes are finished. Please join this |
|
|
github issue: |
|
|
|
|
|
https://github.com/google/protobuf/issues/2780 |
|
|
|
|
|
to provide your feedback. |
|
|
|
|
|
General |
|
|
* Extension ranges now accept options and are customizable. |
|
|
* "reserve" keyword now supports “max” in field number ranges, |
|
|
e.g. reserve 1000 to max; |
|
|
|
|
|
C++ |
|
|
* Proto3 messages are now able to preserve unknown fields. The default |
|
|
behavior is still to drop unknowns, which will be flipped in a future |
|
|
release. If you rely on unknowns fields being dropped. Please use |
|
|
Messgae::DiscardUnknownFields() explicitly. |
|
|
* Packable proto3 fields are now packed by default in serialization. |
|
|
* Following C++11 features are introduced when C++11 is available: |
|
|
- move-constructor and move-assignment are introduced to messages |
|
|
- Repeated fields constructor now takes std::initializer_list |
|
|
- rvalue setters are introduced for string fields |
|
|
* Experimental Table-Driven parsing and serialization available to test. To |
|
|
enable it, pass in table_driven_parsing table_driven_serialization protoc |
|
|
generator flags for C++ |
|
|
|
|
|
$ protoc --cpp_out=table_driven_parsing,table_driven_serialization:./ \ |
|
|
test.proto |
|
|
* lite generator parameter supported by the generator. Once set, all generated |
|
|
files, use lite runtime regardless of the optimizer_for setting in the |
|
|
.proto file. |
|
|
* Various optimizations to make C++ code more performant on PowerPC platform |
|
|
* Fixed maps data corruption when the maps are modified by both reflection API |
|
|
and generated API. |
|
|
* Deterministic serialization on maps reflection now uses stable sort. |
|
|
* file() accessors are introduced to various *Descriptor classes to make |
|
|
writing template function easier. |
|
|
* ByteSize() and SpaceUsed() are deprecated.Use ByteSizeLong() and |
|
|
SpaceUsedLong() instead |
|
|
* Consistent hash function is used for maps in DEBUG and NDEBUG build. |
|
|
* "using namespace std" is removed from stubs/common.h |
|
|
* Various performance optimizations and bug fixes |
|
|
|
|
|
Java |
|
|
* Introduced new parser API DiscardUnknownFieldsParser in preparation of |
|
|
proto3 unknown fields preservation change. Users who want to drop unknown |
|
|
fields should migrate to use this new parser API. For example: |
|
|
|
|
|
Parser<Foo> parser = DiscardUnknownFieldsParser.wrap(Foo.parser()); |
|
|
Foo foo = parser.parseFrom(input); |
|
|
|
|
|
* Introduced new TextFormat API printUnicodeFieldValue() that prints field |
|
|
value without escaping unicode characters. |
|
|
* Added Durations.compare(Duration, Duration) and |
|
|
Timestamps.compare(Timestamp, Timestamp). |
|
|
* JsonFormat now accepts base64url encoded bytes fields. |
|
|
* Optimized CodedInputStream to do less copies when parsing large bytes |
|
|
fields. |
|
|
* Optimized TextFormat to allocate less memory when printing. |
|
|
|
|
|
Python |
|
|
* SerializeToString API is changed to SerializeToString(self, **kwargs), |
|
|
deterministic parameter is accepted for deterministic serialization. |
|
|
* Added sort_keys parameter in json format to make the output deterministic. |
|
|
* Added indent parameter in json format. |
|
|
* Added extension support in json format. |
|
|
* Added __repr__ support for repeated field in cpp implementation. |
|
|
* Added file in FieldDescriptor. |
|
|
* Added pretty-print filter to text format. |
|
|
* Services and method descriptors are always printed even if generic_service |
|
|
option is turned off. |
|
|
|
|
|
PHP |
|
|
* Support PHP generic services. Specify file option php_generic_service=true |
|
|
to enable generating service interface. |
|
|
* Message, repeated and map fields setters take value instead of reference. |
|
|
* Added map iterator in c extension. |
|
|
* Support json encode/decode. |
|
|
* Added more type info in getter/setter phpdoc |
|
|
* Fixed the problem that c extension and php implementation cannot be used |
|
|
together. |
|
|
* Added file option php_namespace to use custom php namespace instead of |
|
|
package. |
|
|
* Added fluent setter. |
|
|
* Added descriptor API in runtime for custom encode/decode. |
|
|
* Various bug fixes. |
|
|
|
|
|
Objective-C |
|
|
* Fix for GPBExtensionRegistry copying and add tests. |
|
|
* Optimize GPBDictionary.m codegen to reduce size of overall library by 46K |
|
|
per architecture. |
|
|
* Fix some cases of reading of 64bit map values. |
|
|
* Properly error on a tag with field number zero. |
|
|
* Preserve unknown fields in proto3 syntax files. |
|
|
* Document the exceptions on some of the writing apis. |
|
|
|
|
|
C# |
|
|
* Implemented IReadOnlyDictionary<K,V> in MapField<K,V> |
|
|
* Added TryUnpack method for Any message in addition to Unpack. |
|
|
* Converted C# projects to MSBuild (csproj) format. |
|
|
|
|
|
Ruby |
|
|
* Several bug fixes. |
|
|
|
|
|
Javascript |
|
|
* Added support of field option js_type. Now one can specify the JS type of a |
|
|
64-bit integer field to be string in the generated code by adding option |
|
|
[jstype = JS_STRING] on the field. |
|
|
|
|
|
2017-04-05 version 3.3.0 (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript) |
|
|
Planned Future Changes |
|
|
* There are some changes that are not included in this release but are |
|
|
planned for the near future: |
|
|
- Preserve unknown fields in proto3: please read this doc: |
|
|
|
|
|
https://docs.google.com/document/d/1KMRX-G91Aa-Y2FkEaHeeviLRRNblgIahbsk4wA14gRk/view |
|
|
|
|
|
for the timeline and follow up this github issue: |
|
|
|
|
|
https://github.com/google/protobuf/issues/272 |
|
|
|
|
|
for discussion. |
|
|
- Make C++ implementation C++11 only: we plan to require C++11 to build |
|
|
protobuf code starting from 3.4.0 or 3.5.0 release. Please join this |
|
|
github issue: |
|
|
|
|
|
https://github.com/google/protobuf/issues/2780 |
|
|
|
|
|
to provide your feedback. |
|
|
|
|
|
C++ |
|
|
* Fixed map fields serialization of DynamicMessage to correctly serialize |
|
|
both key and value regardless of their presence. |
|
|
* Parser now rejects field number 0 correctly. |
|
|
* New API Message::SpaceUsedLong() that’s equivalent to |
|
|
Message::SpaceUsed() but returns the value in size_t. |
|
|
* JSON support |
|
|
- New flag always_print_enums_as_ints in JsonPrintOptions. |
|
|
- New flag preserve_proto_field_names in JsonPrintOptions. It will instruct |
|
|
the JSON printer to use the original field name declared in the .proto |
|
|
file instead of converting them to lowerCamelCase when printing JSON. |
|
|
- JsonPrintOptions.always_print_primtive_fields now works for oneof message |
|
|
fields. |
|
|
- Fixed a bug that doesn’t allow different fields to set the same json_name |
|
|
value. |
|
|
- Fixed a performance bug that causes excessive memory copy when printing |
|
|
large messages. |
|
|
* Various performance optimizations. |
|
|
|
|
|
Java |
|
|
* Map field setters eagerly validate inputs and throw NullPointerExceptions |
|
|
as appropriate. |
|
|
* Added ByteBuffer overloads to the generated parsing methods and the Parser |
|
|
interface. |
|
|
* proto3 enum's getNumber() method now throws on UNRECOGNIZED values. |
|
|
* Output of JsonFormat is now locale independent. |
|
|
|
|
|
Python |
|
|
* Added FindServiceByName() in the pure-Python DescriptorPool. This works only |
|
|
for descriptors added with DescriptorPool.Add(). Generated descriptor_pool |
|
|
does not support this yet. |
|
|
* Added a descriptor_pool parameter for parsing Any in text_format.Parse(). |
|
|
* descriptor_pool.FindFileContainingSymbol() now is able to find nested |
|
|
extensions. |
|
|
* Extending empty [] to repeated field now sets parent message presence. |
|
|
|
|
|
PHP |
|
|
* Added file option php_class_prefix. The prefix will be prepended to all |
|
|
generated classes defined in the file. |
|
|
* When encoding, negative int32 values are sign-extended to int64. |
|
|
* Repeated/Map field setter accepts a regular PHP array. Type checking is |
|
|
done on the array elements. |
|
|
* encode/decode are renamed to serializeToString/mergeFromString. |
|
|
* Added mergeFrom, clear method on Message. |
|
|
* Fixed a bug that oneof accessor didn’t return the field name that is |
|
|
actually set. |
|
|
* C extension now works with php7. |
|
|
* This is the first GA release of PHP. We guarantee that old generated code |
|
|
can always work with new runtime and new generated code. |
|
|
|
|
|
Objective-C |
|
|
* Fixed help for GPBTimestamp for dates before the epoch that contain |
|
|
fractional seconds. |
|
|
* Added GPBMessageDropUnknownFieldsRecursively() to remove unknowns from a |
|
|
message and any sub messages. |
|
|
* Addressed a threading race in extension registration/lookup. |
|
|
* Increased the max message parsing depth to 100 to match the other languages. |
|
|
* Removed some use of dispatch_once in favor of atomic compare/set since it |
|
|
needs to be heap based. |
|
|
* Fixes for new Xcode 8.3 warnings. |
|
|
|
|
|
C# |
|
|
* Fixed MapField.Values.CopyTo, which would throw an exception unnecessarily |
|
|
if provided exactly the right size of array to copy to. |
|
|
* Fixed enum JSON formatting when multiple names mapped to the same numeric |
|
|
value. |
|
|
* Added JSON formatting option to format enums as integers. |
|
|
* Modified RepeatedField<T> to implement IReadOnlyList<T>. |
|
|
* Introduced the start of custom option handling; it's not as pleasant as it |
|
|
might be, but the information is at least present. We expect to extend code |
|
|
generation to improve this in the future. |
|
|
* Introduced ByteString.FromStream and ByteString.FromStreamAsync to |
|
|
efficiently create a ByteString from a stream. |
|
|
* Added whole-message deprecation, which decorates the class with [Obsolete]. |
|
|
|
|
|
Ruby |
|
|
* Fixed Message#to_h for messages with map fields. |
|
|
* Fixed memcpy() in binary gems to work for old glibc, without breaking the |
|
|
build for non-glibc libc’s like musl. |
|
|
|
|
|
Javascript |
|
|
* Added compatibility tests for version 3.0.0. |
|
|
* Added conformance tests. |
|
|
* Fixed serialization of extensions: we need to emit a value even if it is |
|
|
falsy (like the number 0). |
|
|
* Use closurebuilder.py in favor of calcdeps.py for compiling JavaScript. |
|
|
|
|
|
2017-01-23 version 3.2.0 (C++/Java/Python/PHP/Ruby/Objective-C/C#/JavaScript/Lite) |
|
|
General |
|
|
* Added protoc version number to protoc plugin protocol. It can be used by |
|
|
protoc plugin to detect which version of protoc is used with the plugin and |
|
|
mitigate known problems in certain version of protoc. |
|
|
|
|
|
C++ |
|
|
* The default parsing byte size limit has been raised from 64MB to 2GB. |
|
|
* Added rvalue setters for non-arena string fields. |
|
|
* Enabled debug logging for Android. |
|
|
* Fixed a double-free problem when using Reflection::SetAllocatedMessage() |
|
|
with extension fields. |
|
|
* Fixed several deterministic serialization bugs: |
|
|
* MessageLite::SerializeAsString() now respects the global deterministic |
|
|
serialization flag. |
|
|
* Extension fields are serialized deterministically as well. Fixed protocol |
|
|
compiler to correctly report importing-self as an error. |
|
|
* Fixed FileDescriptor::DebugString() to print custom options correctly. |
|
|
* Various performance/codesize optimizations and cleanups. |
|
|
|
|
|
Java |
|
|
* The default parsing byte size limit has been raised from 64MB to 2GB. |
|
|
* Added recursion limit when parsing JSON. |
|
|
* Fixed a bug that enumType.getDescriptor().getOptions() doesn't have custom |
|
|
options. |
|
|
* Fixed generated code to support field numbers up to 2^29-1. |
|
|
|
|
|
Python |
|
|
* You can now assign NumPy scalars/arrays (np.int32, np.int64) to protobuf |
|
|
fields, and assigning other numeric types has been optimized for |
|
|
performance. |
|
|
* Pure-Python: message types are now garbage-collectable. |
|
|
* Python/C++: a lot of internal cleanup/refactoring. |
|
|
|
|
|
PHP (Alpha) |
|
|
* For 64-bit integers type (int64/uint64/sfixed64/fixed64/sint64), use PHP |
|
|
integer on 64-bit environment and PHP string on 32-bit environment. |
|
|
* PHP generated code also conforms to PSR-4 now. |
|
|
* Fixed ZTS build for c extension. |
|
|
* Fixed c extension build on Mac. |
|
|
* Fixed c extension build on 32-bit linux. |
|
|
* Fixed the bug that message without namespace is not found in the descriptor |
|
|
pool. (#2240) |
|
|
* Fixed the bug that repeated field is not iterable in c extension. |
|
|
* Message names Empty will be converted to GPBEmpty in generated code. |
|
|
* Added phpdoc in generated files. |
|
|
* The released API is almost stable. Unless there is large problem, we won't |
|
|
change it. See |
|
|
https://developers.google.com/protocol-buffers/docs/reference/php-generated |
|
|
for more details. |
|
|
|
|
|
Objective-C |
|
|
* Added support for push/pop of the stream limit on CodedInputStream for |
|
|
anyone doing manual parsing. |
|
|
|
|
|
C# |
|
|
* No changes. |
|
|
|
|
|
Ruby |
|
|
* Message objects now support #respond_to? for field getters/setters. |
|
|
* You can now compare “message == non_message_object” and it will return false |
|
|
instead of throwing an exception. |
|
|
* JRuby: fixed #hashCode to properly reflect the values in the message. |
|
|
|
|
|
Javascript |
|
|
* Deserialization of repeated fields no longer has quadratic performance |
|
|
behavior. |
|
|
* UTF-8 encoding/decoding now properly supports high codepoints. |
|
|
* Added convenience methods for some well-known types: Any, Struct, and |
|
|
Timestamp. These make it easier to convert data between native JavaScript |
|
|
types and the well-known protobuf types. |
|
|
|
|
|
2016-09-23 version 3.1.0 (C++/Java/Python/PHP/Ruby/Objective-C/C#/JavaScript/Lite) |
|
|
General |
|
|
* Proto3 support in PHP (alpha). |
|
|
* Various bug fixes. |
|
|
|
|
|
C++ |
|
|
* Added MessageLite::ByteSizeLong() that’s equivalent to |
|
|
MessageLite::ByteSize() but returns the value in size_t. Useful to check |
|
|
whether a message is over the 2G size limit that protobuf can support. |
|
|
* Moved default_instances to global variables. This allows default_instance |
|
|
addresses to be known at compile time. |
|
|
* Adding missing generic gcc 64-bit atomicops. |
|
|
* Restore New*Callback into google::protobuf namespace since these are used |
|
|
by the service stubs code |
|
|
* JSON support. |
|
|
* Fixed some conformance issues. |
|
|
* Fixed a JSON serialization bug for bytes fields. |
|
|
|
|
|
Java |
|
|
* Fixed a bug in TextFormat that doesn’t accept empty repeated fields (i.e., |
|
|
“field: [ ]”). |
|
|
* JSON support |
|
|
* Fixed JsonFormat to do correct snake_case-to-camelCase conversion for |
|
|
non-style-conforming field names. |
|
|
* Fixed JsonFormat to parse empty Any message correctly. |
|
|
* Added an option to JsonFormat.Parser to ignore unknown fields. |
|
|
* Experimental API |
|
|
* Added UnsafeByteOperations.unsafeWrap(byte[]) to wrap a byte array into |
|
|
ByteString without copy. |
|
|
|
|
|
Python |
|
|
* JSON support |
|
|
* Fixed some conformance issues. |
|
|
|
|
|
PHP (Alpha) |
|
|
* We have added the proto3 support for PHP via both a pure PHP package and a |
|
|
native c extension. The pure PHP package is intended to provide usability |
|
|
to wider range of PHP platforms, while the c extension is intended to |
|
|
provide higher performance. Both implementations provide the same runtime |
|
|
APIs and share the same generated code. Users don’t need to re-generate |
|
|
code for the same proto definition when they want to switch the |
|
|
implementation later. The pure PHP package is included in the php/src |
|
|
directory, and the c extension is included in the php/ext directory. |
|
|
|
|
|
Both implementations provide idiomatic PHP APIs: |
|
|
* All messages and enums are defined as PHP classes. |
|
|
* All message fields can only be accessed via getter/setter. |
|
|
* Both repeated field elements and map elements are stored in containers |
|
|
that act like a normal PHP array. |
|
|
|
|
|
Unlike several existing third-party PHP implementations for protobuf, our |
|
|
implementations are built on a "strongly-typed" philosophy: message fields |
|
|
and array/map containers will throw exceptions eagerly when values of the |
|
|
incorrect type (not including those that can be type converted, e.g., |
|
|
double <-> integer <-> numeric string) are inserted. |
|
|
|
|
|
Currently, pure PHP runtime supports php5.5, 5.6 and 7 on linux. C |
|
|
extension runtime supports php5.5 and 5.6 on linux. |
|
|
|
|
|
See php/README.md for more details about installment. See |
|
|
https://developers.google.com/protocol-buffers/docs/phptutorial for more |
|
|
details about APIs. |
|
|
|
|
|
Objective-C |
|
|
* Helpers are now provided for working the the Any well known type (see |
|
|
GPBWellKnownTypes.h for the api additions). |
|
|
* Some improvements in startup code (especially when extensions aren’t used). |
|
|
|
|
|
Javascript |
|
|
* Fixed missing import of jspb.Map |
|
|
* Fixed valueWriterFn variable name |
|
|
|
|
|
Ruby |
|
|
* Fixed hash computation for JRuby's RubyMessage |
|
|
* Make sure map parsing frames are GC-rooted. |
|
|
* Added API support for well-known types. |
|
|
|
|
|
C# |
|
|
* Removed check on dependency in the C# reflection API. |
|
|
|
|
|
2016-09-06 version 3.0.2 (C++/Java/Python/Ruby/Objective-C/C#/JavaScript/Lite) |
|
|
General |
|
|
* Various bug fixes. |
|
|
|
|
|
Objective C |
|
|
* Fix for oneofs in proto3 syntax files where fields were set to the zero |
|
|
value. |
|
|
* Fix for embedded null character in strings. |
|
|
* CocoaDocs support |
|
|
|
|
|
Ruby |
|
|
* Fixed memory corruption bug in parsing that could occur under GC pressure. |
|
|
|
|
|
Javascript |
|
|
* jspb.Map is now properly exported to CommonJS modules. |
|
|
|
|
|
C# |
|
|
* Removed legacy_enum_values flag. |
|
|
|
|
|
|
|
|
2016-07-27 version 3.0.0 (C++/Java/Python/Ruby/Objective-C/C#/JavaScript/Lite) |
|
|
General |
|
|
* This log only contains changes since the beta-4 release. Summarized change |
|
|
log since the last stable release (v2.6.1) can be found in the github |
|
|
release page. |
|
|
|
|
|
Compatibility Notice |
|
|
* v3.0.0 is the first API stable release of the v3.x series. We do not expect |
|
|
any future API breaking changes. |
|
|
* For C++, Java Lite and Objective-C, source level compatibility is |
|
|
guaranteed. Upgrading from v3.0.0 to newer minor version releases will be |
|
|
source compatible. For example, if your code compiles against protobuf |
|
|
v3.0.0, it will continue to compile after you upgrade protobuf library to |
|
|
v3.1.0. |
|
|
* For other languages, both source level compatibility and binary level |
|
|
compatibility are guaranteed. For example, if you have a Java binary built |
|
|
against protobuf v3.0.0. After switching the protobuf runtime binary to |
|
|
v3.1.0, your built binary should continue to work. |
|
|
* Compatibility is only guaranteed for documented API and documented |
|
|
behaviors. If you are using undocumented API (e.g., use anything in the C++ |
|
|
internal namespace), it can be broken by minor version releases in an |
|
|
undetermined manner. |
|
|
|
|
|
Ruby |
|
|
* When you assign a string field `a.string_field = "X"`, we now call |
|
|
#encode(UTF-8) on the string and freeze the copy. This saves you from |
|
|
needing to ensure the string is already encoded as UTF-8. It also prevents |
|
|
you from mutating the string after it has been assigned (this is how we |
|
|
ensure it stays valid UTF-8). |
|
|
* The generated file for `foo.proto` is now `foo_pb.rb` instead of just |
|
|
`foo.rb`. This makes it easier to see which imports/requires are from |
|
|
protobuf generated code, and also prevents conflicts with any `foo.rb` file |
|
|
you might have written directly in Ruby. It is a backward-incompatible |
|
|
change: you will need to update all of your `require` statements. |
|
|
* For package names like `foo_bar`, we now translate this to the Ruby module |
|
|
`FooBar`. This is more idiomatic Ruby than what we used to do (`Foo_bar`). |
|
|
|
|
|
JavaScript |
|
|
* Scalar fields like numbers and boolean now return defaults instead of |
|
|
`undefined` or `null` when they are unset. You can test for presence |
|
|
explicitly by calling `hasFoo()`, which we now generate for scalar fields. |
|
|
|
|
|
Java Lite |
|
|
* Java Lite is now implemented as a separate plugin, maintained in the |
|
|
`javalite` branch. Both lite runtime and protoc artifacts will be available |
|
|
in Maven. |
|
|
|
|
|
C# |
|
|
* Target platforms now .NET 4.5, selected portable subsets and .NET Core. |
|
|
* legacy_enum_values option is no longer supported. |
|
|
|
|
|
2016-07-15 version 3.0.0-beta-4 (C++/Java/Python/Ruby/Objective-C/C#/JavaScript) |
|
|
General |
|
|
* Added a deterministic serialization API for C++. The deterministic |
|
|
serialization guarantees that given a binary, equal messages will be |
|
|
serialized to the same bytes. This allows applications like MapReduce to |
|
|
group equal messages based on the serialized bytes. The deterministic |
|
|
serialization is, however, NOT canonical across languages; it is also |
|
|
unstable across different builds with schema changes due to unknown fields. |
|
|
Users who need canonical serialization, e.g. persistent storage in a |
|
|
canonical form, fingerprinting, etc, should define their own |
|
|
canonicalization specification and implement the serializer using reflection |
|
|
APIs rather than relying on this API. |
|
|
* Added OneofOptions. You can now define custom options for oneof groups. |
|
|
import "google/protobuf/descriptor.proto"; |
|
|
extend google.protobuf.OneofOptions { |
|
|
optional int32 my_oneof_extension = 12345; |
|
|
} |
|
|
message Foo { |
|
|
oneof oneof_group { |
|
|
(my_oneof_extension) = 54321; |
|
|
... |
|
|
} |
|
|
} |
|
|
|
|
|
C++ (beta) |
|
|
* Introduced a deterministic serialization API in |
|
|
CodedOutputStream::SetSerializationDeterministic(bool). See the notes about |
|
|
deterministic serialization in the General section. |
|
|
* Added google::protobuf::Map::swap() to swap two map fields. |
|
|
* Fixed a memory leak when calling Reflection::ReleaseMessage() on a message |
|
|
allocated on arena. |
|
|
* Improved error reporting when parsing text format protos. |
|
|
* JSON |
|
|
- Added a new parser option to ignore unknown fields when parsing JSON. |
|
|
- Added convenient methods for message to/from JSON conversion. |
|
|
* Various performance optimizations. |
|
|
|
|
|
Java (beta) |
|
|
* File option "java_generate_equals_and_hash" is now deprecated. equals() and |
|
|
hashCode() methods are generated by default. |
|
|
* Added a new JSON printer option "omittingInsignificantWhitespace" to produce |
|
|
a more compact JSON output. The printer will pretty-print by default. |
|
|
* Updated Java runtime to be compatible with 2.5.0/2.6.1 generated protos. |
|
|
|
|
|
Python (beta) |
|
|
* Added support to pretty print Any messages in text format. |
|
|
* Added a flag to ignore unknown fields when parsing JSON. |
|
|
* Bugfix: "@type" field of a JSON Any message is now correctly put before |
|
|
other fields. |
|
|
|
|
|
Objective-C (beta) |
|
|
* Updated the code to support compiling with more compiler warnings |
|
|
enabled. (Issue 1616) |
|
|
* Exposing more detailed errors for parsing failures. (PR 1623) |
|
|
* Small (breaking) change to the naming of some methods on the support classes |
|
|
for map<>. There were collisions with the system provided KVO support, so |
|
|
the names were changed to avoid those issues. (PR 1699) |
|
|
* Fixed for proper Swift bridging of error handling during parsing. (PR 1712) |
|
|
* Complete support for generating sources that will go into a Framework and |
|
|
depend on generated sources from other Frameworks. (Issue 1457) |
|
|
|
|
|
C# (beta) |
|
|
* RepeatedField optimizations. |
|
|
* Support for .NET Core. |
|
|
* Minor bug fixes. |
|
|
* Ability to format a single value in JsonFormatter (advanced usage only). |
|
|
* Modifications to attributes applied to generated code. |
|
|
|
|
|
Javascript (alpha) |
|
|
* Maps now have a real map API instead of being treated as repeated fields. |
|
|
* Well-known types are now provided in the google-protobuf package, and the |
|
|
code generator knows to require() them from that package. |
|
|
* Bugfix: non-canonical varints are correctly decoded. |
|
|
|
|
|
Ruby (alpha) |
|
|
* Accessors for oneof fields now return default values instead of nil. |
|
|
|
|
|
Java Lite |
|
|
* Java lite support is removed from protocol compiler. It will be supported |
|
|
as a protocol compiler plugin in a separate code branch. |
|
|
|
|
|
2016-05-16 version 3.0.0-beta-3 (C++/Java/Python/Ruby/Nano/Objective-C/C#/JavaScript) |
|
|
General |
|
|
* Supported Proto3 lite-runtime in C++/Java for mobile platforms. |
|
|
* Any type now supports APIs to specify prefixes other than |
|
|
type.googleapis.com |
|
|
* Removed javanano_use_deprecated_package option; Nano will always has its own |
|
|
".nano" package. |
|
|
|
|
|
C++ (Beta) |
|
|
* Improved hash maps. |
|
|
- Improved hash maps comments. In particular, please note that equal hash |
|
|
maps will not necessarily have the same iteration order and |
|
|
serialization. |
|
|
- Added a new hash maps implementation that will become the default in a |
|
|
later release. |
|
|
* Arenas |
|
|
- Several inlined methods in Arena were moved to out-of-line to improve |
|
|
build performance and code size. |
|
|
- Added SpaceAllocatedAndUsed() to report both space used and allocated |
|
|
- Added convenient class UnsafeArenaAllocatedRepeatedPtrFieldBackInserter |
|
|
* Any |
|
|
- Allow custom type URL prefixes in Any packing. |
|
|
- TextFormat now expand the Any type rather than printing bytes. |
|
|
* Performance optimizations and various bug fixes. |
|
|
|
|
|
Java (Beta) |
|
|
* Introduced an ExperimentalApi annotation. Annotated APIs are experimental |
|
|
and are subject to change in a backward incompatible way in future releases. |
|
|
* Introduced zero-copy serialization as an ExperimentalApi |
|
|
- Introduction of the `ByteOutput` interface. This is similar to |
|
|
`OutputStream` but provides semantics for lazy writing (i.e. no |
|
|
immediate copy required) of fields that are considered to be immutable. |
|
|
- `ByteString` now supports writing to a `ByteOutput`, which will directly |
|
|
expose the internals of the `ByteString` (i.e. `byte[]` or `ByteBuffer`) |
|
|
to the `ByteOutput` without copying. |
|
|
- `CodedOutputStream` now supports writing to a `ByteOutput`. `ByteString` |
|
|
instances that are too large to fit in the internal buffer will be |
|
|
(lazily) written to the `ByteOutput` directly. |
|
|
- This allows applications using large `ByteString` fields to avoid |
|
|
duplication of these fields entirely. Such an application can supply a |
|
|
`ByteOutput` that chains together the chunks received from |
|
|
`CodedOutputStream` before forwarding them onto the IO system. |
|
|
* Other related changes to `CodedOutputStream` |
|
|
- Additional use of `sun.misc.Unsafe` where possible to perform fast |
|
|
access to `byte[]` and `ByteBuffer` values and avoiding unnecessary |
|
|
range checking. |
|
|
- `ByteBuffer`-backed `CodedOutputStream` now writes directly to the |
|
|
`ByteBuffer` rather than to an intermediate array. |
|
|
* Improved lite-runtime. |
|
|
- Lite protos now implement deep equals/hashCode/toString |
|
|
- Significantly improved the performance of Builder#mergeFrom() and |
|
|
Builder#mergeDelimitedFrom() |
|
|
* Various bug fixes and small feature enhancement. |
|
|
- Fixed stack overflow when in hashCode() for infinite recursive oneofs. |
|
|
- Fixed the lazy field parsing in lite to merge rather than overwrite. |
|
|
- TextFormat now supports reporting line/column numbers on errors. |
|
|
- Updated to add appropriate @Override for better compiler errors. |
|
|
|
|
|
Python (Beta) |
|
|
* Added JSON format for Any, Struct, Value and ListValue |
|
|
* [ ] is now accepted for both repeated scalar fields and repeated message |
|
|
fields in text format parser. |
|
|
* Numerical field name is now supported in text format. |
|
|
* Added DiscardUnknownFields API for python protobuf message. |
|
|
|
|
|
Objective-C (Beta) |
|
|
* Proto comments now come over as HeaderDoc comments in the generated sources |
|
|
so Xcode can pick them up and display them. |
|
|
* The library headers have been updated to use HeaderDoc comments so Xcode can |
|
|
pick them up and display them. |
|
|
* The per message and per field overhead in both generated code and runtime |
|
|
object sizes was reduced. |
|
|
* Generated code now include deprecated annotations when the proto file |
|
|
included them. |
|
|
|
|
|
C# (Beta) |
|
|
In general: some changes are breaking, which require regenerating messages. |
|
|
Most user-written code will not be impacted *except* for the renaming of enum |
|
|
values. |
|
|
|
|
|
* Allow custom type URL prefixes in `Any` packing, and ignore them when |
|
|
unpacking |
|
|
* `protoc` is now in a separate NuGet package (Google.Protobuf.Tools) |
|
|
* New option: `internal_access` to generate internal classes |
|
|
* Enum values are now PascalCased, and if there's a prefix which matches the |
|
|
name of the enum, that is removed (so an enum `COLOR` with a value |
|
|
`COLOR_BLUE` would generate a value of just `Blue`). An option |
|
|
(`legacy_enum_values`) is temporarily available to disable this, but the |
|
|
option will be removed for GA. |
|
|
* `json_name` option is now honored |
|
|
* If group tags are encountered when parsing, they are validated more |
|
|
thoroughly (although we don't support actual groups) |
|
|
* NuGet dependencies are better specified |
|
|
* Breaking: `Preconditions` is renamed to `ProtoPreconditions` |
|
|
* Breaking: `GeneratedCodeInfo` is renamed to `GeneratedClrTypeInfo` |
|
|
* `JsonFormatter` now allows writing to a `TextWriter` |
|
|
* New interface, `ICustomDiagnosticMessage` to allow more compact |
|
|
representations from `ToString` |
|
|
* `CodedInputStream` and `CodedOutputStream` now implement `IDisposable`, |
|
|
which simply disposes of the streams they were constructed with |
|
|
* Map fields no longer support null values (in line with other languages) |
|
|
* Improvements in JSON formatting and parsing |
|
|
|
|
|
Javascript (Alpha) |
|
|
* Better support for "bytes" fields: bytes fields can be read as either a |
|
|
base64 string or UInt8Array (in environments where TypedArray is supported). |
|
|
* New support for CommonJS imports. This should make it easier to use the |
|
|
JavaScript support in Node.js and tools like WebPack. See js/README.md for |
|
|
more information. |
|
|
* Some significant internal refactoring to simplify and modularize the code. |
|
|
|
|
|
Ruby (Alpha) |
|
|
* JSON serialization now properly uses camelCased names, with a runtime option |
|
|
that will preserve original names from .proto files instead. |
|
|
* Well-known types are now included in the distribution. |
|
|
* Release now includes binary gems for Windows, Mac, and Linux instead of just |
|
|
source gems. |
|
|
* Bugfix for serializing oneofs. |
|
|
|
|
|
C++/Java Lite (Alpha) |
|
|
A new "lite" generator parameter was introduced in the protoc for C++ and |
|
|
Java for Proto3 syntax messages. Example usage: |
|
|
|
|
|
./protoc --cpp_out=lite:$OUTPUT_PATH foo.proto |
|
|
|
|
|
The protoc will treat the current input and all the transitive dependencies |
|
|
as LITE. The same generator parameter must be used to generate the |
|
|
dependencies. |
|
|
|
|
|
In Proto3 syntax files, "optimized_for=LITE_RUNTIME" is no longer supported. |
|
|
|
|
|
|
|
|
2015-12-30 version 3.0.0-beta-2 (C++/Java/Python/Ruby/Nano/Objective-C/C#/JavaScript) |
|
|
General |
|
|
* Introduced a new language implementation: JavaScript. |
|
|
* Added a new field option "json_name". By default proto field names are |
|
|
converted to "lowerCamelCase" in proto3 JSON format. This option can be |
|
|
used to override this behavior and specify a different JSON name for the |
|
|
field. |
|
|
* Added conformance tests to ensure implementations are following proto3 JSON |
|
|
specification. |
|
|
|
|
|
C++ (Beta) |
|
|
* Various bug fixes and improvements to the JSON support utility: |
|
|
- Duplicate map keys in JSON are now rejected (i.e., translation will |
|
|
fail). |
|
|
- Fixed wire-format for google.protobuf.Value/ListValue. |
|
|
- Fixed precision loss when converting google.protobuf.Timestamp. |
|
|
- Fixed a bug when parsing invalid UTF-8 code points. |
|
|
- Fixed a memory leak. |
|
|
- Reduced call stack usage. |
|
|
|
|
|
Java (Beta) |
|
|
* Cleaned up some unused methods on CodedOutputStream. |
|
|
* Presized lists for packed fields during parsing in the lite runtime to |
|
|
reduce allocations and improve performance. |
|
|
* Improved the performance of unknown fields in the lite runtime. |
|
|
* Introduced UnsafeByteStrings to support zero-copy ByteString creation. |
|
|
* Various bug fixes and improvements to the JSON support utility: |
|
|
- Fixed a thread-safety bug. |
|
|
- Added a new option “preservingProtoFieldNames” to JsonFormat. |
|
|
- Added a new option “includingDefaultValueFields” to JsonFormat. |
|
|
- Updated the JSON utility to comply with proto3 JSON specification. |
|
|
|
|
|
Python (Beta) |
|
|
* Added proto3 JSON format utility. It includes support for all field types |
|
|
and a few well-known types except for Any and Struct. |
|
|
* Added runtime support for Any, Timestamp, Duration and FieldMask. |
|
|
* [ ] is now accepted for repeated scalar fields in text format parser. |
|
|
* Map fields now have proper O(1) performance for lookup/insert/delete |
|
|
when using the Python/C++ implementation. They were previously using O(n) |
|
|
search-based algorithms because the C++ reflection interface didn't |
|
|
support true map operations. |
|
|
|
|
|
Objective-C (Beta) |
|
|
* Various bug-fixes and code tweaks to pass more strict compiler warnings. |
|
|
* Now has conformance test coverage and is passing all tests. |
|
|
|
|
|
C# (Beta) |
|
|
* Various bug-fixes. |
|
|
* Code generation: Files generated in directories based on namespace. |
|
|
* Code generation: Include comments from .proto files in XML doc |
|
|
comments (naively) |
|
|
* Code generation: Change organization/naming of "reflection class" (access |
|
|
to file descriptor) |
|
|
* Code generation and library: Add Parser property to MessageDescriptor, |
|
|
and introduce a non-generic parser type. |
|
|
* Library: Added TypeRegistry to support JSON parsing/formatting of Any. |
|
|
* Library: Added Any.Pack/Unpack support. |
|
|
* Library: Implemented JSON parsing. |
|
|
|
|
|
Javascript (Alpha) |
|
|
* Added proto3 support for JavaScript. The runtime is written in pure |
|
|
JavaScript and works in browsers and in Node.js. To generate JavaScript |
|
|
code for your proto, invoke protoc with "--js_out". See js/README.md |
|
|
for more build instructions. |
|
|
|
|
|
2015-08-26 version 3.0.0-beta-1 (C++/Java/Python/Ruby/Nano/Objective-C/C#) |
|
|
About Beta |
|
|
* This is the first beta release of protobuf v3.0.0. Not all languages |
|
|
have reached beta stage. Languages not marked as beta are still in |
|
|
alpha (i.e., be prepared for API breaking changes). |
|
|
|
|
|
General |
|
|
* Proto3 JSON is supported in several languages (fully supported in C++ |
|
|
and Java, partially supported in Ruby/C#). The JSON spec is defined in |
|
|
the proto3 language guide: |
|
|
|
|
|
https://developers.google.com/protocol-buffers/docs/proto3#json |
|
|
|
|
|
We will publish a more detailed spec to define the exact behavior of |
|
|
proto3-conformant JSON serializers and parsers. Until then, do not rely |
|
|
on specific behaviors of the implementation if it’s not documented in |
|
|
the above spec. More specifically, the behavior is not yet finalized for |
|
|
the following: |
|
|
- Parsing invalid JSON input (e.g., input with trailing commas). |
|
|
- Non-camelCase names in JSON input. |
|
|
- The same field appears multiple times in JSON input. |
|
|
- JSON arrays contain “null” values. |
|
|
- The message has unknown fields. |
|
|
|
|
|
* Proto3 now enforces strict UTF-8 checking. Parsing will fail if a string |
|
|
field contains non UTF-8 data. |
|
|
|
|
|
C++ (Beta) |
|
|
* Introduced new utility functions/classes in the google/protobuf/util |
|
|
directory: |
|
|
- MessageDifferencer: compare two proto messages and report their |
|
|
differences. |
|
|
- JsonUtil: support converting protobuf binary format to/from JSON. |
|
|
- TimeUtil: utility functions to work with well-known types Timestamp |
|
|
and Duration. |
|
|
- FieldMaskUtil: utility functions to work with FieldMask. |
|
|
|
|
|
* Performance optimization of arena construction and destruction. |
|
|
* Bug fixes for arena and maps support. |
|
|
* Changed to use cmake for Windows Visual Studio builds. |
|
|
* Added Bazel support. |
|
|
|
|
|
Java (Beta) |
|
|
* Introduced a new util package that will be distributed as a separate |
|
|
artifact in maven. It contains: |
|
|
- JsonFormat: convert proto messages to/from JSON. |
|
|
- TimeUtil: utility functions to work with Timestamp and Duration. |
|
|
- FieldMaskUtil: utility functions to work with FieldMask. |
|
|
|
|
|
* The static PARSER in each generated message is deprecated, and it will |
|
|
be removed in a future release. A static parser() getter is generated |
|
|
for each message type instead. |
|
|
* Performance optimizations for String fields serialization. |
|
|
* Performance optimizations for Lite runtime on Android: |
|
|
- Reduced allocations |
|
|
- Reduced method overhead after ProGuarding |
|
|
- Reduced code size after ProGuarding |
|
|
|
|
|
Python (Alpha) |
|
|
* Removed legacy Python 2.5 support. |
|
|
* Moved to a single Python 2.x/3.x-compatible codebase, instead of using 2to3. |
|
|
* Fixed build/tests on Python 2.6, 2.7, 3.3, and 3.4. |
|
|
- Pure-Python works on all four. |
|
|
- Python/C++ implementation works on all but 3.4, due to changes in the |
|
|
Python/C++ API in 3.4. |
|
|
* Some preliminary work has been done to allow for multiple DescriptorPools |
|
|
with Python/C++. |
|
|
|
|
|
Ruby (Alpha) |
|
|
* Many bugfixes: |
|
|
- fixed parsing/serialization of bytes, sint, sfixed types |
|
|
- other parser bugfixes |
|
|
- fixed memory leak affecting Ruby 2.2 |
|
|
|
|
|
JavaNano (Alpha) |
|
|
* JavaNano generated code now will be put in a nano package by default to |
|
|
avoid conflicts with Java generated code. |
|
|
|
|
|
Objective-C (Alpha) |
|
|
* Added non-null markup to ObjC library. Requires SDK 8.4+ to build. |
|
|
* Many bugfixes: |
|
|
- Removed the class/enum filter. |
|
|
- Renamed some internal types to avoid conflicts with the well-known types |
|
|
protos. |
|
|
- Added missing support for parsing repeated primitive fields in packed or |
|
|
unpacked forms. |
|
|
- Added *Count for repeated and map<> fields to avoid auto-create when |
|
|
checking for them being set. |
|
|
|
|
|
C# (Alpha) |
|
|
* Namespace changed to Google.Protobuf (and NuGet package will be named |
|
|
correspondingly). |
|
|
* Target platforms now .NET 4.5 and selected portable subsets only. |
|
|
* Removed lite runtime. |
|
|
* Reimplementation to use mutable message types. |
|
|
* Null references used to represent "no value" for message type fields. |
|
|
* Proto3 semantics supported; proto2 files are prohibited for C# codegen. |
|
|
Most proto3 features supported: |
|
|
- JSON formatting (a.k.a. serialization to JSON), including well-known |
|
|
types (except for Any). |
|
|
- Wrapper types mapped to nullable value types (or string/ByteString |
|
|
allowing nullability). JSON parsing is not supported yet. |
|
|
- maps |
|
|
- oneof |
|
|
- enum unknown value preservation |
|
|
|
|
|
2015-05-25 version 3.0.0-alpha-3 (Objective-C/C#): |
|
|
General |
|
|
* Introduced two new language implementations (Objective-C, C#) to proto3. |
|
|
* Explicit "optional" keyword are disallowed in proto3 syntax, as fields are |
|
|
optional by default. |
|
|
* Group fields are no longer supported in proto3 syntax. |
|
|
* Changed repeated primitive fields to use packed serialization by default in |
|
|
proto3 (implemented for C++, Java, Python in this release). The user can |
|
|
still disable packed serialization by setting packed to false for now. |
|
|
* Added well-known type protos (any.proto, empty.proto, timestamp.proto, |
|
|
duration.proto, etc.). Users can import and use these protos just like |
|
|
regular proto files. Additional runtime support will be added for them in |
|
|
future releases (in the form of utility helper functions, or having them |
|
|
replaced by language specific types in generated code). |
|
|
* Added a "reserved" keyword in both proto2 and proto3 syntax. User can use |
|
|
this keyword to declare reserved field numbers and names to prevent them |
|
|
from being reused by other fields in the same message. |
|
|
|
|
|
To reserve field numbers, add a reserved declaration in your message: |
|
|
|
|
|
message TestMessage { |
|
|
reserved 2, 15, 9 to 11, 3; |
|
|
} |
|
|
|
|
|
This reserves field numbers 2, 3, 9, 10, 11 and 15. If a user uses any of |
|
|
these as field numbers, the protocol buffer compiler will report an error. |
|
|
|
|
|
Field names can also be reserved: |
|
|
|
|
|
message TestMessage { |
|
|
reserved "foo", "bar"; |
|
|
} |
|
|
|
|
|
* Various bug fixes since 3.0.0-alpha-2 |
|
|
|
|
|
Objective-C |
|
|
Objective-C includes a code generator and a native objective-c runtime |
|
|
library. By adding “--objc_out” to protoc, the code generator will generate |
|
|
a header(*.pbobjc.h) and an implementation file(*.pbobjc.m) for each proto |
|
|
file. |
|
|
|
|
|
In this first release, the generated interface provides: enums, messages, |
|
|
field support(single, repeated, map, oneof), proto2 and proto3 syntax |
|
|
support, parsing and serialization. It’s compatible with ARC and non-ARC |
|
|
usage. Besides, user can also access it via the swift bridging header. |
|
|
|
|
|
See objectivec/README.md for details. |
|
|
|
|
|
C# |
|
|
* C# protobufs are based on project |
|
|
https://github.com/jskeet/protobuf-csharp-port. The original project was |
|
|
frozen and all the new development will happen here. |
|
|
* Codegen plugin for C# was completely rewritten to C++ and is now an |
|
|
integral part of protoc. |
|
|
* Some refactorings and cleanup has been applied to the C# runtime library. |
|
|
* Only proto2 is supported in C# at the moment, proto3 support is in |
|
|
progress and will likely bring significant breaking changes to the API. |
|
|
|
|
|
See csharp/README.md for details. |
|
|
|
|
|
C++ |
|
|
* Added runtime support for Any type. To use Any in your proto file, first |
|
|
import the definition of Any: |
|
|
|
|
|
// foo.proto |
|
|
import "google/protobuf/any.proto"; |
|
|
message Foo { |
|
|
google.protobuf.Any any_field = 1; |
|
|
} |
|
|
message Bar { |
|
|
int32 value = 1; |
|
|
} |
|
|
|
|
|
Then in C++ you can access the Any field using PackFrom()/UnpackTo() |
|
|
methods: |
|
|
|
|
|
Foo foo; |
|
|
Bar bar = ...; |
|
|
foo.mutable_any_field()->PackFrom(bar); |
|
|
... |
|
|
if (foo.any_field().IsType<Bar>()) { |
|
|
foo.any_field().UnpackTo(&bar); |
|
|
... |
|
|
} |
|
|
* In text format, entries of a map field will be sorted by key. |
|
|
|
|
|
Java |
|
|
* Continued optimizations on the lite runtime to improve performance for |
|
|
Android. |
|
|
|
|
|
Python |
|
|
* Added map support. |
|
|
- maps now have a dict-like interface (msg.map_field[key] = value) |
|
|
- existing code that modifies maps via the repeated field interface |
|
|
will need to be updated. |
|
|
|
|
|
Ruby |
|
|
* Improvements to RepeatedField's emulation of the Ruby Array API. |
|
|
* Various speedups and internal cleanups. |
|
|
|
|
|
2015-02-26 version 3.0.0-alpha-2 (Python/Ruby/JavaNano): |
|
|
General |
|
|
* Introduced three new language implementations (Ruby, JavaNano, and |
|
|
Python) to proto3. |
|
|
* Various bug fixes since 3.0.0-alpha-1 |
|
|
|
|
|
Python: |
|
|
Python has received several updates, most notably support for proto3 |
|
|
semantics in any .proto file that declares syntax="proto3". |
|
|
Messages declared in proto3 files no longer represent field presence |
|
|
for scalar fields (number, enums, booleans, or strings). You can |
|
|
no longer call HasField() for such fields, and they are serialized |
|
|
based on whether they have a non-zero/empty/false value. |
|
|
|
|
|
One other notable change is in the C++-accelerated implementation. |
|
|
Descriptor objects (which describe the protobuf schema and allow |
|
|
reflection over it) are no longer duplicated between the Python |
|
|
and C++ layers. The Python descriptors are now simple wrappers |
|
|
around the C++ descriptors. This change should significantly |
|
|
reduce the memory usage of programs that use a lot of message |
|
|
types. |
|
|
|
|
|
Ruby: |
|
|
We have added proto3 support for Ruby via a native C extension. |
|
|
|
|
|
The Ruby extension itself is included in the ruby/ directory, and details on |
|
|
building and installing the extension are in ruby/README.md. The extension |
|
|
will also be published as a Ruby gem. Code generator support is included as |
|
|
part of `protoc` with the `--ruby_out` flag. |
|
|
|
|
|
The Ruby extension implements a user-friendly DSL to define message types |
|
|
(also generated by the code generator from `.proto` files). Once a message |
|
|
type is defined, the user may create instances of the message that behave in |
|
|
ways idiomatic to Ruby. For example: |
|
|
|
|
|
- Message fields are present as ordinary Ruby properties (getter method |
|
|
`foo` and setter method `foo=`). |
|
|
- Repeated field elements are stored in a container that acts like a native |
|
|
Ruby array, and map elements are stored in a container that acts like a |
|
|
native Ruby hashmap. |
|
|
- The usual well-known methods, such as `#to_s`, `#dup`, and the like, are |
|
|
present. |
|
|
|
|
|
Unlike several existing third-party Ruby extensions for protobuf, this |
|
|
extension is built on a "strongly-typed" philosophy: message fields and |
|
|
array/map containers will throw exceptions eagerly when values of the |
|
|
incorrect type are inserted. |
|
|
|
|
|
See ruby/README.md for details. |
|
|
|
|
|
JavaNano: |
|
|
JavaNano is a special code generator and runtime library designed especially |
|
|
for resource-restricted systems, like Android. It is very resource-friendly |
|
|
in both the amount of code and the runtime overhead. Here is an an overview |
|
|
of JavaNano features compared with the official Java protobuf: |
|
|
|
|
|
- No descriptors or message builders. |
|
|
- All messages are mutable; fields are public Java fields. |
|
|
- For optional fields only, encapsulation behind setter/getter/hazzer/ |
|
|
clearer functions is opt-in, which provide proper 'has' state support. |
|
|
- For proto2, if not opted in, has state (field presence) is not available. |
|
|
Serialization outputs all fields not equal to their defaults. |
|
|
The behavior is consistent with proto3 semantics. |
|
|
- Required fields (proto2 only) are always serialized. |
|
|
- Enum constants are integers; protection against invalid values only |
|
|
when parsing from the wire. |
|
|
- Enum constants can be generated into container interfaces bearing |
|
|
the enum's name (so the referencing code is in Java style). |
|
|
- CodedInputByteBufferNano can only take byte[] (not InputStream). |
|
|
- Similarly CodedOutputByteBufferNano can only write to byte[]. |
|
|
- Repeated fields are in arrays, not ArrayList or Vector. Null array |
|
|
elements are allowed and silently ignored. |
|
|
- Full support for serializing/deserializing repeated packed fields. |
|
|
- Support extensions (in proto2). |
|
|
- Unset messages/groups are null, not an immutable empty default |
|
|
instance. |
|
|
- toByteArray(...) and mergeFrom(...) are now static functions of |
|
|
MessageNano. |
|
|
- The 'bytes' type translates to the Java type byte[]. |
|
|
|
|
|
See javanano/README.txt for details. |
|
|
|
|
|
2014-12-01 version 3.0.0-alpha-1 (C++/Java): |
|
|
|
|
|
General |
|
|
* Introduced Protocol Buffers language version 3 (aka proto3). |
|
|
|
|
|
When protobuf was initially opensourced it implemented Protocol Buffers |
|
|
language version 2 (aka proto2), which is why the version number |
|
|
started from v2.0.0. From v3.0.0, a new language version (proto3) is |
|
|
introduced while the old version (proto2) will continue to be supported. |
|
|
|
|
|
The main intent of introducing proto3 is to clean up protobuf before |
|
|
pushing the language as the foundation of Google's new API platform. |
|
|
In proto3, the language is simplified, both for ease of use and to |
|
|
make it available in a wider range of programming languages. At the |
|
|
same time a few features are added to better support common idioms |
|
|
found in APIs. |
|
|
|
|
|
The following are the main new features in language version 3: |
|
|
|
|
|
1. Removal of field presence logic for primitive value fields, removal |
|
|
of required fields, and removal of default values. This makes proto3 |
|
|
significantly easier to implement with open struct representations, |
|
|
as in languages like Android Java, Objective C, or Go. |
|
|
2. Removal of unknown fields. |
|
|
3. Removal of extensions, which are instead replaced by a new standard |
|
|
type called Any. |
|
|
4. Fix semantics for unknown enum values. |
|
|
5. Addition of maps. |
|
|
6. Addition of a small set of standard types for representation of time, |
|
|
dynamic data, etc. |
|
|
7. A well-defined encoding in JSON as an alternative to binary proto |
|
|
encoding. |
|
|
|
|
|
This release (v3.0.0-alpha-1) includes partial proto3 support for C++ and |
|
|
Java. Items 6 (well-known types) and 7 (JSON format) in the above feature |
|
|
list are not implemented. |
|
|
|
|
|
A new notion "syntax" is introduced to specify whether a .proto file |
|
|
uses proto2 or proto3: |
|
|
|
|
|
// foo.proto |
|
|
syntax = "proto3"; |
|
|
message Bar {...} |
|
|
|
|
|
If omitted, the protocol compiler will generate a warning and "proto2" will |
|
|
be used as the default. This warning will be turned into an error in a |
|
|
future release. |
|
|
|
|
|
We recommend that new Protocol Buffers users use proto3. However, we do not |
|
|
generally recommend that existing users migrate from proto2 from proto3 due |
|
|
to API incompatibility, and we will continue to support proto2 for a long |
|
|
time. |
|
|
|
|
|
* Added support for map fields (implemented in C++/Java for both proto2 and |
|
|
proto3). |
|
|
|
|
|
Map fields can be declared using the following syntax: |
|
|
|
|
|
message Foo { |
|
|
map<string, string> values = 1; |
|
|
} |
|
|
|
|
|
Data of a map field will be stored in memory as an unordered map and it |
|
|
can be accessed through generated accessors. |
|
|
|
|
|
C++ |
|
|
* Added arena allocation support (for both proto2 and proto3). |
|
|
|
|
|
Profiling shows memory allocation and deallocation constitutes a significant |
|
|
fraction of CPU-time spent in protobuf code and arena allocation is a |
|
|
technique introduced to reduce this cost. With arena allocation, new |
|
|
objects will be allocated from a large piece of preallocated memory and |
|
|
deallocation of these objects is almost free. Early adoption shows 20% to |
|
|
50% improvement in some Google binaries. |
|
|
|
|
|
To enable arena support, add the following option to your .proto file: |
|
|
|
|
|
option cc_enable_arenas = true; |
|
|
|
|
|
Protocol compiler will generate additional code to make the generated |
|
|
message classes work with arenas. This does not change the existing API |
|
|
of protobuf messages and does not affect wire format. Your existing code |
|
|
should continue to work after adding this option. In the future we will |
|
|
make this option enabled by default. |
|
|
|
|
|
To actually take advantage of arena allocation, you need to use the arena |
|
|
APIs when creating messages. A quick example of using the arena API: |
|
|
|
|
|
{ |
|
|
google::protobuf::Arena arena; |
|
|
// Allocate a protobuf message in the arena. |
|
|
MyMessage* message = Arena::CreateMessage<MyMessage>(&arena); |
|
|
// All submessages will be allocated in the same arena. |
|
|
if (!message->ParseFromString(data)) { |
|
|
// Deal with malformed input data. |
|
|
} |
|
|
// Must not delete the message here. It will be deleted automatically |
|
|
// when the arena is destroyed. |
|
|
} |
|
|
|
|
|
Currently arena does not work with map fields. Enabling arena in a .proto |
|
|
file containing map fields will result in compile errors in the generated |
|
|
code. This will be addressed in a future release. |
|
|
|
|
|
2014-10-20 version 2.6.1: |
|
|
|
|
|
C++ |
|
|
* Added atomicops support for Solaris. |
|
|
* Released memory allocated by InitializeDefaultRepeatedFields() and |
|
|
GetEmptyString(). Some memory sanitizers reported them as memory leaks. |
|
|
|
|
|
Java |
|
|
* Updated DynamicMessage.setField() to handle repeated enum values |
|
|
correctly. |
|
|
* Fixed a bug that caused NullPointerException to be thrown when |
|
|
converting manually constructed FileDescriptorProto to |
|
|
FileDescriptor. |
|
|
|
|
|
Python |
|
|
* Fixed WhichOneof() to work with de-serialized protobuf messages. |
|
|
* Fixed a missing file problem of Python C++ implementation. |
|
|
|
|
|
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 messages, 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. |
|
|
|
|
|
2013-02-27 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++ counterparts 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. |
|
|
|
|
|
2011-05-01 version 2.4.1: |
|
|
|
|
|
C++ |
|
|
* Fixed the friendship 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. |
|
|
|
|
|
2011-02-02 version 2.4.0: |
|
|
|
|
|
General |
|
|
* The RPC (cc|java|py)_generic_services default value is now false instead of |
|
|
true. |
|
|
* Custom options can have aggregate types. For example, |
|
|
message MyOption { |
|
|
optional string comment = 1; |
|
|
optional string author = 2; |
|
|
} |
|
|
extend google.protobuf.FieldOptions { |
|
|
optional MyOption myoption = 12345; |
|
|
} |
|
|
This option can now be set as follows: |
|
|
message SomeType { |
|
|
optional int32 field = 1 [(myoption) = { comment:'x' author:'y' }]; |
|
|
} |
|
|
|
|
|
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 |
|
|
(You may continue to modify it and then build another message). |
|
|
* Code generator will generate efficient equals() and hashCode() |
|
|
implementations if new option java_generate_equals_and_hash is enabled. |
|
|
(Otherwise, reflection-based implementations are used.) |
|
|
* 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 |
|
|
_VALUE. |
|
|
|
|
|
Python |
|
|
* Added an experimental C++ implementation for Python messages via a Python |
|
|
extension. Implementation type is controlled by an environment variable |
|
|
PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION (valid values: "cpp" and "python") |
|
|
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. |
|
|
E.g. instead of |
|
|
item = repeated_field.add() |
|
|
item.foo = bar |
|
|
item.baz = quux |
|
|
You can do: |
|
|
repeated_field.add(foo=bar, baz=quux) |
|
|
* Added a sort() interface to the BaseContainer. |
|
|
* Added an extend() method to repeated composite fields. |
|
|
* Added UTF8 debug string support. |
|
|
|
|
|
2010-01-08 version 2.3.0: |
|
|
|
|
|
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: |
|
|
option cc_generic_services = false; |
|
|
option java_generic_services = false; |
|
|
option py_generic_services = false; |
|
|
This allows plugins to generate alternative code, possibly specific to some |
|
|
particular RPC implementation. |
|
|
|
|
|
protoc |
|
|
* 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. See src/google/protobuf/compiler/plugin.proto. |
|
|
**WARNING**: Plugins are experimental. The interface may change in a |
|
|
future version. |
|
|
* If the output location ends in .zip or .jar, protoc will write its output |
|
|
to a zip/jar archive instead of a directory. For example: |
|
|
protoc --java_out=myproto_srcs.jar --python_out=myproto.zip myproto.proto |
|
|
Currently the archive contents are not compressed, though this could change |
|
|
in the future. |
|
|
* inf, -inf, and nan can now be used as default values for float and double |
|
|
fields. |
|
|
|
|
|
C++ |
|
|
* Various speed and code size optimizations. |
|
|
* DynamicMessageFactory is now fully thread-safe. |
|
|
* Message::Utf8DebugString() method is like DebugString() but avoids escaping |
|
|
UTF-8 bytes. |
|
|
* Compiled-in message types can now contain dynamic extensions, through use |
|
|
of CodedInputStream::SetExtensionRegistry(). |
|
|
* Now compiles shared libraries (DLLs) by default on Cygwin and MinGW, to |
|
|
match other platforms. Use --disable-shared to avoid this. |
|
|
|
|
|
Java |
|
|
* parseDelimitedFrom() and mergeDelimitedFrom() now detect EOF and return |
|
|
false/null instead of throwing an exception. |
|
|
* Fixed some initialization ordering bugs. |
|
|
* Fixes for OpenJDK 7. |
|
|
|
|
|
Python |
|
|
* 10-25 times faster than 2.2.0, still pure-Python. |
|
|
* Calling a mutating method on a sub-message always instantiates the message |
|
|
in its parent even if the mutating method doesn't actually mutate anything |
|
|
(e.g. parsing from an empty string). |
|
|
* Expanded descriptors a bit. |
|
|
|
|
|
2009-08-11 version 2.2.0: |
|
|
|
|
|
C++ |
|
|
* Lite mode: The "optimize_for = LITE_RUNTIME" option causes the compiler |
|
|
to generate code which only depends libprotobuf-lite, which is much smaller |
|
|
than libprotobuf but lacks descriptors, reflection, and some other features. |
|
|
* Fixed bug where Message.Swap(Message) was only implemented for |
|
|
optimize_for_speed. Swap now properly implemented in both modes |
|
|
(Issue 91). |
|
|
* Added RemoveLast and SwapElements(index1, index2) to Reflection |
|
|
interface for repeated elements. |
|
|
* Added Swap(Message) to Reflection interface. |
|
|
* Floating-point literals in generated code that are intended to be |
|
|
single-precision now explicitly have 'f' suffix to avoid pedantic warnings |
|
|
produced by some compilers. |
|
|
* The [deprecated=true] option now causes the C++ code generator to generate |
|
|
a GCC-style deprecation annotation (no-op on other compilers). |
|
|
* google::protobuf::GetEnumDescriptor<SomeGeneratedEnumType>() returns the |
|
|
EnumDescriptor for that type -- useful for templates which cannot call |
|
|
SomeGeneratedEnumType_descriptor(). |
|
|
* Various optimizations and obscure bug fixes. |
|
|
|
|
|
Java |
|
|
* Lite mode: The "optimize_for = LITE_RUNTIME" option causes the compiler |
|
|
to generate code which only depends libprotobuf-lite, which is much smaller |
|
|
than libprotobuf but lacks descriptors, reflection, and some other features. |
|
|
* Lots of style cleanups. |
|
|
|
|
|
Python |
|
|
* Fixed endianness bug with floats and doubles. |
|
|
* Text format parsing support. |
|
|
* Fix bug with parsing packed repeated fields in embedded messages. |
|
|
* Ability to initialize fields by passing keyword args to constructor. |
|
|
* Support iterators in extend and __setslice__ for containers. |
|
|
|
|
|
2009-05-13 version 2.1.0: |
|
|
|
|
|
General |
|
|
* Repeated fields of primitive types (types other that string, group, and |
|
|
nested messages) may now use the option [packed = true] to get a more |
|
|
efficient encoding. In the new encoding, the entire list is written |
|
|
as a single byte blob using the "length-delimited" wire type. Within |
|
|
this blob, the individual values are encoded the same way they would |
|
|
be normally except without a tag before each value (thus, they are |
|
|
tightly "packed"). |
|
|
* For each field, the generated code contains an integer constant assigned |
|
|
to the field number. For example, the .proto file: |
|
|
message Foo { optional int bar_baz = 123; } |
|
|
would generate the following constants, all with the integer value 123: |
|
|
C++: Foo::kBarBazFieldNumber |
|
|
Java: Foo.BAR_BAZ_FIELD_NUMBER |
|
|
Python: Foo.BAR_BAZ_FIELD_NUMBER |
|
|
Constants are also generated for extensions, with the same naming scheme. |
|
|
These constants may be used as switch cases. |
|
|
* Updated bundled Google Test to version 1.3.0. Google Test is now bundled |
|
|
in its verbatim form as a nested autoconf package, so you can drop in any |
|
|
other version of Google Test if needed. |
|
|
* optimize_for = SPEED is now the default, by popular demand. Use |
|
|
optimize_for = CODE_SIZE if code size is more important in your app. |
|
|
* It is now an error to define a default value for a repeated field. |
|
|
Previously, this was silently ignored (it had no effect on the generated |
|
|
code). |
|
|
* Fields can now be marked deprecated like: |
|
|
optional int32 foo = 1 [deprecated = true]; |
|
|
Currently this does not have any actual effect, but in the future the code |
|
|
generators may generate deprecation annotations in each language. |
|
|
* Cross-compiling should now be possible using the --with-protoc option to |
|
|
configure. See README.txt for more info. |
|
|
|
|
|
protoc |
|
|
* --error_format=msvs option causes errors to be printed in Visual Studio |
|
|
format, which should allow them to be clicked on in the build log to go |
|
|
directly to the error location. |
|
|
* The type name resolver will no longer resolve type names to fields. For |
|
|
example, this now works: |
|
|
message Foo {} |
|
|
message Bar { |
|
|
optional int32 Foo = 1; |
|
|
optional Foo baz = 2; |
|
|
} |
|
|
Previously, the type of "baz" would resolve to "Bar.Foo", and you'd get |
|
|
an error because Bar.Foo is a field, not a type. Now the type of "baz" |
|
|
resolves to the message type Foo. This change is unlikely to make a |
|
|
difference to anyone who follows the Protocol Buffers style guide. |
|
|
|
|
|
C++ |
|
|
* Several optimizations, including but not limited to: |
|
|
- Serialization, especially to flat arrays, is 10%-50% faster, possibly |
|
|
more for small objects. |
|
|
- Several descriptor operations which previously required locking no longer |
|
|
do. |
|
|
- Descriptors are now constructed lazily on first use, rather than at |
|
|
process startup time. This should save memory in programs which do not |
|
|
use descriptors or reflection. |
|
|
- UnknownFieldSet completely redesigned to be more efficient (especially in |
|
|
terms of memory usage). |
|
|
- Various optimizations to reduce code size (though the serialization speed |
|
|
optimizations increased code size). |
|
|
* Message interface has method ParseFromBoundedZeroCopyStream() which parses |
|
|
a limited number of bytes from an input stream rather than parsing until |
|
|
EOF. |
|
|
* GzipInputStream and GzipOutputStream support reading/writing gzip- or |
|
|
zlib-compressed streams if zlib is available. |
|
|
(google/protobuf/io/gzip_stream.h) |
|
|
* DescriptorPool::FindAllExtensions() and corresponding |
|
|
DescriptorDatabase::FindAllExtensions() can be used to enumerate all |
|
|
extensions of a given type. |
|
|
* For each enum type Foo, protoc will generate functions: |
|
|
const string& Foo_Name(Foo value); |
|
|
bool Foo_Parse(const string& name, Foo* result); |
|
|
The former returns the name of the enum constant corresponding to the given |
|
|
value while the latter finds the value corresponding to a name. |
|
|
* RepeatedField and RepeatedPtrField now have back-insertion iterators. |
|
|
* String fields now have setters that take a char* and a size, in addition |
|
|
to the existing ones that took char* or const string&. |
|
|
* DescriptorPool::AllowUnknownDependencies() may be used to tell |
|
|
DescriptorPool to create placeholder descriptors for unknown entities |
|
|
referenced in a FileDescriptorProto. This can allow you to parse a .proto |
|
|
file without having access to other .proto files that it imports, for |
|
|
example. |
|
|
* Updated gtest to latest version. The gtest package is now included as a |
|
|
nested autoconf package, so it should be able to drop new versions into the |
|
|
"gtest" subdirectory without modification. |
|
|
|
|
|
Java |
|
|
* Fixed bug where Message.mergeFrom(Message) failed to merge extensions. |
|
|
* Message interface has new method toBuilder() which is equivalent to |
|
|
newBuilderForType().mergeFrom(this). |
|
|
* All enums now implement the ProtocolMessageEnum interface. |
|
|
* Setting a field to null now throws NullPointerException. |
|
|
* Fixed tendency for TextFormat's parsing to overflow the stack when |
|
|
parsing large string values. The underlying problem is with Java's |
|
|
regex implementation (which unfortunately uses recursive backtracking |
|
|
rather than building an NFA). Worked around by making use of possessive |
|
|
quantifiers. |
|
|
* Generated service classes now also generate pure interfaces. For a service |
|
|
Foo, Foo.Interface is a pure interface containing all of the service's |
|
|
defined methods. Foo.newReflectiveService() can be called to wrap an |
|
|
instance of this interface in a class that implements the generic |
|
|
RpcService interface, which provides reflection support that is usually |
|
|
needed by RPC server implementations. |
|
|
* RPC interfaces now support blocking operation in addition to non-blocking. |
|
|
The protocol compiler generates separate blocking and non-blocking stubs |
|
|
which operate against separate blocking and non-blocking RPC interfaces. |
|
|
RPC implementations will have to implement the new interfaces in order to |
|
|
support blocking mode. |
|
|
* New I/O methods parseDelimitedFrom(), mergeDelimitedFrom(), and |
|
|
writeDelimitedTo() read and write "delimited" messages from/to a stream, |
|
|
meaning that the message size precedes the data. This way, you can write |
|
|
multiple messages to a stream without having to worry about delimiting |
|
|
them yourself. |
|
|
* Throw a more descriptive exception when build() is double-called. |
|
|
* Add a method to query whether CodedInputStream is at the end of the input |
|
|
stream. |
|
|
* Add a method to reset a CodedInputStream's size counter; useful when |
|
|
reading many messages with the same stream. |
|
|
* equals() and hashCode() now account for unknown fields. |
|
|
|
|
|
Python |
|
|
* Added slicing support for repeated scalar fields. Added slice retrieval and |
|
|
removal of repeated composite fields. |
|
|
* Updated RPC interfaces to allow for blocking operation. A client may |
|
|
now pass None for a callback when making an RPC, in which case the |
|
|
call will block until the response is received, and the response |
|
|
object will be returned directly to the caller. This interface change |
|
|
cannot be used in practice until RPC implementations are updated to |
|
|
implement it. |
|
|
* Changes to input_stream.py should make protobuf compatible with appengine. |
|
|
|
|
|
2008-11-25 version 2.0.3: |
|
|
|
|
|
protoc |
|
|
* Enum values may now have custom options, using syntax similar to field |
|
|
options. |
|
|
* Fixed bug where .proto files which use custom options but don't actually |
|
|
define them (i.e. they import another .proto file defining the options) |
|
|
had to explicitly import descriptor.proto. |
|
|
* Adjacent string literals in .proto files will now be concatenated, like in |
|
|
C. |
|
|
* If an input file is a Windows absolute path (e.g. "C:\foo\bar.proto") and |
|
|
the import path only contains "." (or contains "." but does not contain |
|
|
the file), protoc incorrectly thought that the file was under ".", because |
|
|
it thought that the path was relative (since it didn't start with a slash). |
|
|
This has been fixed. |
|
|
|
|
|
C++ |
|
|
* Generated message classes now have a Swap() method which efficiently swaps |
|
|
the contents of two objects. |
|
|
* All message classes now have a SpaceUsed() method which returns an estimate |
|
|
of the number of bytes of allocated memory currently owned by the object. |
|
|
This is particularly useful when you are reusing a single message object |
|
|
to improve performance but want to make sure it doesn't bloat up too large. |
|
|
* New method Message::SerializeAsString() returns a string containing the |
|
|
serialized data. May be more convenient than calling |
|
|
SerializeToString(string*). |
|
|
* In debug mode, log error messages when string-type fields are found to |
|
|
contain bytes that are not valid UTF-8. |
|
|
* Fixed bug where a message with multiple extension ranges couldn't parse |
|
|
extensions. |
|
|
* Fixed bug where MergeFrom(const Message&) didn't do anything if invoked on |
|
|
a message that contained no fields (but possibly contained extensions). |
|
|
* Fixed ShortDebugString() to not be O(n^2). Durr. |
|
|
* Fixed crash in TextFormat parsing if the first token in the input caused a |
|
|
tokenization error. |
|
|
* Fixed obscure bugs in zero_copy_stream_impl.cc. |
|
|
* Added support for HP C++ on Tru64. |
|
|
* Only build tests on "make check", not "make". |
|
|
* Fixed alignment issue that caused crashes when using DynamicMessage on |
|
|
64-bit Sparc machines. |
|
|
* Simplify template usage to work with MSVC 2003. |
|
|
* Work around GCC 4.3.x x86_64 compiler bug that caused crashes on startup. |
|
|
(This affected Fedora 9 in particular.) |
|
|
* Now works on "Solaris 10 using recent Sun Studio". |
|
|
|
|
|
Java |
|
|
* New overload of mergeFrom() which parses a slice of a byte array instead |
|
|
of the whole thing. |
|
|
* New method ByteString.asReadOnlyByteBuffer() does what it sounds like. |
|
|
* Improved performance of isInitialized() when optimizing for code size. |
|
|
|
|
|
Python |
|
|
* Corrected ListFields() signature in Message base class to match what |
|
|
subclasses actually implement. |
|
|
* Some minor refactoring. |
|
|
* Don't pass self as first argument to superclass constructor (no longer |
|
|
allowed in Python 2.6). |
|
|
|
|
|
2008-09-29 version 2.0.2: |
|
|
|
|
|
General |
|
|
* License changed from Apache 2.0 to 3-Clause BSD. |
|
|
* It is now possible to define custom "options", which are basically |
|
|
annotations which may be placed on definitions in a .proto file. |
|
|
For example, you might define a field option called "foo" like so: |
|
|
import "google/protobuf/descriptor.proto" |
|
|
extend google.protobuf.FieldOptions { |
|
|
optional string foo = 12345; |
|
|
} |
|
|
Then you annotate a field using the "foo" option: |
|
|
message MyMessage { |
|
|
optional int32 some_field = 1 [(foo) = "bar"] |
|
|
} |
|
|
The value of this option is then visible via the message's |
|
|
Descriptor: |
|
|
const FieldDescriptor* field = |
|
|
MyMessage::descriptor()->FindFieldByName("some_field"); |
|
|
assert(field->options().GetExtension(foo) == "bar"); |
|
|
This feature has been implemented and tested in C++ and Java. |
|
|
Other languages may or may not need to do extra work to support |
|
|
custom options, depending on how they construct descriptors. |
|
|
|
|
|
C++ |
|
|
* Fixed some GCC warnings that only occur when using -pedantic. |
|
|
* Improved static initialization code, making ordering more |
|
|
predictable among other things. |
|
|
* TextFormat will no longer accept messages which contain multiple |
|
|
instances of a singular field. Previously, the latter instance |
|
|
would overwrite the former. |
|
|
* Now works on systems that don't have hash_map. |
|
|
|
|
|
Java |
|
|
* Print @Override annotation in generated code where appropriate. |
|
|
|
|
|
Python |
|
|
* Strings now use the "unicode" type rather than the "str" type. |
|
|
String fields may still be assigned ASCII "str" values; they will |
|
|
automatically be converted. |
|
|
* Adding a property to an object representing a repeated field now |
|
|
raises an exception. For example: |
|
|
# No longer works (and never should have). |
|
|
message.some_repeated_field.foo = 1 |
|
|
|
|
|
Windows |
|
|
* We now build static libraries rather than DLLs by default on MSVC. |
|
|
See vsprojects/readme.txt for more information. |
|
|
|
|
|
2008-08-15 version 2.0.1: |
|
|
|
|
|
protoc |
|
|
* New flags --encode and --decode can be used to convert between protobuf text |
|
|
format and binary format from the command-line. |
|
|
* New flag --descriptor_set_out can be used to write FileDescriptorProtos for |
|
|
all parsed files directly into a single output file. This is particularly |
|
|
useful if you wish to parse .proto files from programs written in languages |
|
|
other than C++: just run protoc as a background process and have it output |
|
|
a FileDescriptorList, then parse that natively. |
|
|
* Improved error message when an enum value's name conflicts with another |
|
|
symbol defined in the enum type's scope, e.g. if two enum types declared |
|
|
in the same scope have values with the same name. This is disallowed for |
|
|
compatibility with C++, but this wasn't clear from the error. |
|
|
* Fixed absolute output paths on Windows. |
|
|
* Allow trailing slashes in --proto_path mappings. |
|
|
|
|
|
C++ |
|
|
* Reflection objects are now per-class rather than per-instance. To make this |
|
|
possible, the Reflection interface had to be changed such that all methods |
|
|
take the Message instance as a parameter. This change improves performance |
|
|
significantly in memory-bandwidth-limited use cases, since it makes the |
|
|
message objects smaller. Note that source-incompatible interface changes |
|
|
like this will not be made again after the library leaves beta. |
|
|
* Heuristically detect sub-messages when printing unknown fields. |
|
|
* Fix static initialization ordering bug that caused crashes at startup when |
|
|
compiling on Mac with static linking. |
|
|
* Fixed TokenizerTest when compiling with -DNDEBUG on Linux. |
|
|
* Fixed incorrect definition of kint32min. |
|
|
* Fix bytes type setter to work with byte sequences with embedded NULLs. |
|
|
* Other irrelevant tweaks. |
|
|
|
|
|
Java |
|
|
* Fixed UnknownFieldSet's parsing of varints larger than 32 bits. |
|
|
* Fixed TextFormat's parsing of "inf" and "nan". |
|
|
* Fixed TextFormat's parsing of comments. |
|
|
* Added info to Java POM that will be required when we upload the |
|
|
package to a Maven repo. |
|
|
|
|
|
Python |
|
|
* MergeFrom(message) and CopyFrom(message) are now implemented. |
|
|
* SerializeToString() raises an exception if the message is missing required |
|
|
fields. |
|
|
* Code organization improvements. |
|
|
* Fixed doc comments for RpcController and RpcChannel, which had somehow been |
|
|
swapped. |
|
|
* Fixed text_format_test on Windows where floating-point exponents sometimes |
|
|
contain extra zeros. |
|
|
* Fix Python service CallMethod() implementation. |
|
|
|
|
|
Other |
|
|
* Improved readmes. |
|
|
* VIM syntax highlighting improvements. |
|
|
|
|
|
2008-07-07 version 2.0.0: |
|
|
|
|
|
* First public release.
|
|
|
|
