Protobuf

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

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&35;
- 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.

Release candidate for v3.2.0.

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&35;
- Removed check on dependency in the C reflection API.

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&35;
- Removed legacy_enum_values flag.

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.