"Fossies" - the Fresh Open Source Software Archive

Member "protobuf-3.12.3/CHANGES.txt" (2 Jun 2020, 112892 Bytes) of package /linux/misc/protobuf-all-3.12.3.tar.gz:


As a special service "Fossies" has tried to format the requested text file into HTML format (style: standard) with prefixed line numbers. Alternatively you can here view or download the uninterpreted source code file. For more information about "CHANGES.txt" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report: 3.12.2_vs_3.12.3.

    1 2020-06-01 version 3.12.3 (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript)
    2 
    3   Objective-C
    4   * Tweak the union used for Extensions to support old generated code. #7573
    5 
    6 2020-05-26 version 3.12.2 (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript)
    7 
    8   C++
    9   * Simplified the template export macros to fix the build for mingw32. (#7539)
   10 
   11   Objective-C
   12   * Fix for the :protobuf_objc target in the Bazel BUILD file. (#7538)
   13 
   14 2020-05-20 version 3.12.1 (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript)
   15 
   16   Ruby
   17   * Re-add binary gems for Ruby 2.3 and 2.4. These are EOL upstream, however
   18     many people still use them and dropping support will require more
   19     coordination.
   20 
   21 2020-05-12 version 3.12.0 (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript)
   22 
   23   Protocol Compiler
   24   * [experimental] Singular, non-message typed fields in proto3 now support
   25     presence tracking. This is enabled by adding the "optional" field label and
   26     passing the --experimental_allow_proto3_optional flag to protoc.
   27     * For usage info, see docs/field_presence.md.
   28     * During this experimental phase, code generators should update to support
   29       proto3 presence, see docs/implementing_proto3_presence.md for instructions.
   30   * Allow duplicate symbol names when multiple descriptor sets are passed on
   31     the command-line, to match the behavior when multiple .proto files are passed.
   32   * Deterministic `protoc --descriptor_set_out` (#7175)
   33 
   34   C++
   35   * [experimental] Added proto3 presence support.
   36   * New descriptor APIs to support proto3 presence.
   37   * Enable Arenas by default on all .proto files.
   38   * Documented that users are not allowed to subclass Message or MessageLite.
   39   * Mark generated classes as final; inheriting from protos is strongly discouraged.
   40   * Add stack overflow protection for text format with unknown fields.
   41   * Add accessors for map key and value FieldDescriptors.
   42   * Add FieldMaskUtil::FromFieldNumbers().
   43   * MessageDifferencer: use ParsePartial() on Any fields so the diff does not
   44     fail when there are missing required fields.
   45   * ReflectionOps::Merge(): lookup messages in the right factory, if it can.
   46   * Added Descriptor::WellKnownTypes enum and Descriptor::well_known_type()
   47     accessor as an easier way of determining if a message is a Well-Known Type.
   48   * Optimized RepeatedField::Add() when it is used in a loop.
   49   * Made proto move/swap more efficient.
   50   * De-virtualize the GetArena() method in MessageLite.
   51   * Improves performance of json_stream_parser.cc by factor 1000 (#7230)
   52   * bug: #7076 undefine Windows OUT and OPTIONAL macros (#7087)
   53   * Fixed a bug in FieldDescriptor::DebugString() that would erroneously print
   54     an "optional" label for a field in a oneof.
   55   * Fix bug in parsing bool extensions that assumed they are always 1 byte.
   56   * Fix off-by-one error in FieldOptions::ByteSize() when extensions are present.
   57   * Clarified the comments to show an example of the difference between
   58     Descriptor::extension and DescriptorPool::FindAllExtensions.
   59   * Add a compiler option 'code_size' to force optimize_for=code_size on all
   60     protos where this is possible.
   61 
   62   Java
   63   * [experimental] Added proto3 presence support.
   64   * Mark java enum _VALUE constants as @Deprecated if the enum field is deprecated
   65   * reduce <clinit> size for enums with allow_alias set to true.
   66   * Sort map fields alphabetically by the field's key when printing textproto.
   67   * Fixed a bug in map sorting that appeared in -rc1 and -rc2 (#7508).
   68   * TextFormat.merge() handles Any as top level type.
   69   * Throw a descriptive IllegalArgumentException when calling
   70     getValueDescriptor() on enum special value UNRECOGNIZED instead of
   71     ArrayIndexOutOfBoundsException.
   72   * Fixed an issue with JsonFormat.printer() where setting printingEnumsAsInts()
   73     would override the configuration passed into includingDefaultValueFields().
   74   * Implement overrides of indexOf() and contains() on primitive lists returned
   75     for repeated fields to avoid autoboxing the list contents.
   76   * Add overload to FieldMaskUtil.fromStringList that accepts a descriptor.
   77   * [bazel] Move Java runtime/toolchains into //java (#7190)
   78 
   79   Python
   80   * [experimental] Added proto3 presence support.
   81   * [experimental] fast import protobuf module, only works with cpp generated code linked in.
   82   * Truncate 'float' fields to 4 bytes of precision in setters for pure-Python
   83     implementation (C++ extension was already doing this).
   84   * Fixed a memory leak in C++ bindings.
   85   * Added a deprecation warning when code tries to create Descriptor objects
   86     directly.
   87   * Fix unintended comparison between bytes and string in descriptor.py.
   88   * Avoid printing excess digits for float fields in TextFormat.
   89   * Remove Python 2.5 syntax compatibility from the proto compiler generated _pb2.py module code.
   90   * Drop 3.3, 3.4 and use single version docker images for all python tests (#7396)
   91 
   92   JavaScript
   93   * Fix js message pivot selection (#6813)
   94 
   95   PHP
   96   * Persistent Descriptor Pool (#6899)
   97   * Implement lazy loading of php class for proto messages (#6911)
   98   * Correct @return in Any.unpack docblock (#7089)
   99   * Ignore unknown enum value when ignore_unknown specified (#7455)
  100 
  101   Ruby
  102   * [experimental] Implemented proto3 presence for Ruby. (#7406)
  103   * Stop building binary gems for ruby <2.5 (#7453)
  104   * Fix for wrappers with a zero value (#7195)
  105   * Fix for JSON serialization of 0/empty-valued wrapper types (#7198)
  106   * Call "Class#new" over rb_class_new_instance in decoding (#7352)
  107   * Build extensions for Ruby 2.7 (#7027)
  108   * assigning 'nil' to submessage should clear the field. (#7397)
  109 
  110   C#
  111   * [experimental] Add support for proto3 presence fields in C# (#7382)
  112   * Mark GetOption API as obsolete and expose the "GetOptions()" method on descriptors instead (#7491)
  113   * Remove Has/Clear members for C# message fields in proto2 (#7429)
  114   * Enforce recursion depth checking for unknown fields (#7132)
  115   * Fix conformance test failures for Google.Protobuf (#6910)
  116   * Cleanup various bits of Google.Protobuf (#6674)
  117   * Fix latest ArgumentException for C# extensions (#6938)
  118   * Remove unnecessary branch from ReadTag (#7289)
  119 
  120   Objective-C
  121   * [experimental] ObjC Proto3 optional support (#7421)
  122   * Block subclassing of generated classes (#7124)
  123   * Use references to Obj C classes instead of names in descriptors. (#7026)
  124   * Revisit how the WKTs are bundled with ObjC. (#7173)
  125 
  126   Other
  127   * Add a proto_lang_toolchain for javalite (#6882)
  128   * [bazel] Update gtest and deprecate //external:{gtest,gtest_main} (#7237)
  129   * Add application note for explicit presence tracking. (#7390)
  130   * Howto doc for implementing proto3 presence in a code generator. (#7407)
  131 
  132 
  133 2020-02-14 version 3.11.4 (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript)
  134   
  135   C#
  136   * Fix latest ArgumentException for C# extensions (#7188)
  137   * Enforce recursion depth checking for unknown fields (#7210)
  138   
  139   Ruby
  140   * Fix wrappers with a zero value (#7195)
  141   * Fix JSON serialization of 0/empty-valued wrapper types (#7198)
  142 
  143 2020-01-31 version 3.11.3 (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript)
  144 
  145   C++
  146   * Add OUT and OPTIONAL to windows portability files (#7087)
  147 
  148   PHP
  149   * Refactored ulong to zend_ulong for php7.4 compatibility (#7147)
  150   * Call register_class before getClass from desc to fix segfault (#7077)
  151   
  152 
  153 2019-12-10 version 3.11.2 (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript)
  154 
  155   PHP
  156   * Make c extension portable for php 7.4 (#6968)
  157   
  158 
  159 2019-12-02 version 3.11.1 (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript)
  160 
  161   PHP
  162   * Extern declare protobuf_globals (#6946)
  163 
  164 
  165 2019-11-19 version 3.11.0 (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript)
  166 
  167   C++
  168   * Make serialization method naming consistent
  169   * Make proto runtime + generated code free of deprecation warnings
  170   * Moved ShutdownProtobufLibrary() to message_lite.h.  For backward compatibility a declaration is still available in stubs/common.h, but users should prefer message_lite.h
  171   * Removed non-namespace macro EXPECT_OK()
  172   * Removed mathlimits.h from stubs in favor of using std::numeric_limits from C++11
  173   * Fixed bug in parser when ending on a group tag
  174   * Add a helper function to UnknownFieldSet to deal with the changing return value of message::unknown_fields()
  175   * Fix incorrect use of string_view iterators
  176   * Support direct pickling of nested messages
  177   * Skip extension tag validation for MessageSet if unknown dependencies are allowed
  178   * Updated deprecation macros to annotate deprecated code (#6612)
  179   * Remove conversion warning in MapEntryFuncs::ByteSizeLong (#6766)
  180   * Revert "Make shared libraries be able to link to MSVC static runtime libraries, so that VC runtime is not required." (#6914)
  181 
  182   Java
  183   * Remove the usage of MethodHandle, so that Android users prior to API version 26 can use protobuf-java
  184   * Publish ProGuard config for javalite
  185   * Fix for StrictMode disk read violation in ExtensionRegistryLite
  186   * Include part of the ByteString's content in its toString().
  187   * Include unknown fields when merging proto3 messages in Java lite builders
  188 
  189   Python
  190   * Add float_precision option in json format printer
  191   * Optionally print bytes fields as messages in unknown fields, if possible
  192   * FieldPath: fix testing IsSet on root path ''
  193   * Experimental code gen (fast import protobuf module) which only work with cpp generated code linked in
  194 
  195   JavaScript
  196   * Remove guard for Symbol iterator for jspb.Map
  197 
  198   PHP
  199   * Avoid too much overhead in layout_init (#6716)
  200   * Lazily Create Singular Wrapper Message (#6833)
  201   * Implement lazy loading of php class for proto messages (#6911)
  202 
  203   Ruby
  204   * Ruby lazy wrappers optimization (#6797)
  205 
  206   C#
  207   * (RepeatedField): Capacity property to resize the internal array (#6530)
  208   * Experimental proto2 support is now officially available (#4642, #5183, #5350, #5936)
  209   * Getting started doc: https://github.com/protocolbuffers/protobuf/blob/master/docs/csharp/proto2.md
  210   * Add length checks to ExtensionCollection (#6759)
  211   * Optimize parsing of some primitive and wrapper types (#6843)
  212   * Use 3 parameter Encoding.GetString for default string values (#6828)
  213   * Change _Extensions property to normal body rather than expression (#6856)
  214 
  215   Objective C
  216   * Fixed unaligned reads for 32bit arm with newer Xcode versions (#6678)
  217 
  218 
  219 2019-09-03 version 3.10.0 (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript)
  220 
  221   C++
  222   * Switch the proto parser to the faster MOMI parser.
  223   * Properly escape Struct keys in the proto3 JSON serializer.
  224   * Fix crash on uninitialized map entries.
  225   * Informed the compiler of has-bit invariant to produce better code
  226   * Unused imports of files defining descriptor extensions will now be reported
  227   * Add proto2::util::RemoveSubranges to remove multiple subranges in linear time.
  228   * Added BaseTextGenerator::GetCurrentIndentationSize()
  229   * Made implicit weak fields compatible with the Apple linker
  230   * Support 32 bit values for ProtoStreamObjectWriter to Struct.
  231   * Removed the internal-only header coded_stream_inl.h and the internal-only methods defined there.
  232   * Enforced no SWIG wrapping of descriptor_database.h (other headers already had this restriction).
  233   * Implementation of the equivalent of the MOMI parser for serialization. This removes one of the two serialization routines, by making the fast array serialization routine completely general. SerializeToCodedStream can now be implemented in terms of the much much faster array serialization. The array serialization regresses slightly, but when array serialization is not possible this wins big. 
  234   * Do not convert unknown field name to snake case to accurately report error.
  235   * Fix a UBSAN warnings. (#6333)
  236   * Add podspec for C++ (#6404)
  237   * protoc: fix source code info location for missing label (#6436)
  238   * C++ Add move constructor for Reflection's SetString (#6477)
  239 
  240   Java
  241   * Call loadDescriptor outside of synchronized block to remove one possible source of deadlock.
  242   * Have oneof enums implement a separate interface (other than EnumLite) for clarity.
  243   * Opensource Android Memory Accessors
  244   * Update TextFormat to make use of the new TypeRegistry.
  245   * Support getFieldBuilder and getRepeatedFieldBuilder in ExtendableBuilder
  246   * Update JsonFormat to make use of the new TypeRegistry.
  247   * Add proguard config generator for GmmBenchmarkSuiteLite.
  248   * Change ProtobufArrayList to use Object[] instead of ArrayList for 5-10% faster parsing
  249   * Implement ProtobufArrayList.add(E) for 20% (5%-40%) faster overall protolite2 parsing
  250   * Make a copy of JsonFormat.TypeRegistry at the protobuf top level package. This will eventually replace JsonFormat.TypeRegistry.
  251   * Fix javadoc warnings in generated files (#6231)
  252   * Java: Add Automatic-Module-Name entries to the Manifest (#6568)
  253 
  254   Python
  255   * Add descriptor methods in descriptor_pool are deprecated.
  256   * Uses explicit imports to prevent multithread test failures in py3.
  257   * Added __delitem__ for Python extension dict
  258   * Update six version to 1.12.0 and fix legacy_create_init issue (#6391)
  259 
  260   JavaScript
  261   * Remove deprecated boolean option to getResultBase64String().
  262   * Fix sint64 zig-zag encoding.
  263   * Simplify hash64 string conversion to avoid DIGIT array. Should reduce overhead if these functions aren't used, and be more efficient by avoiding linear array searches.
  264   * Change the parameter types of binaryReaderFn in ExtensionFieldBinaryInfo to (number, ?, ?).
  265   * Create dates.ts and time_of_days.ts to mirror Java versions. This is a near-identical conversion of c.g.type.util.{Dates,TimeOfDays} respectively.
  266   * Migrate moneys to TypeScript.
  267   
  268   PHP
  269   * Fix incorrect leap day for Timestamp (#6696)
  270   * Initialize well known type values (#6713)
  271 
  272   Ruby
  273   * Fix scope resolution for Google namespace (#5878)
  274   * Support hashes for struct initializers (#5716)
  275   * Optimized away the creation of empty string objects. (#6502)
  276   * Roll forward Ruby upb changes now that protobuf Ruby build is fixed (#5866)
  277   * Optimized layout_mark() for Ruby (#6521)
  278   * Optimization for layout_init() (#6547)
  279   * Fix for GC of Ruby map frames. (#6533)
  280   * Fixed leap year handling by reworking upb_mktime() -> upb_timegm(). (#6695)
  281   
  282   Objective C
  283   * Remove OSReadLittle* due to alignment requirements (#6678)
  284   * Don't use unions and instead use memcpy for the type swaps. (#6672)
  285 
  286   Other
  287   * Override CocoaPods module to lowercase (#6464)
  288 
  289 
  290 2019-06-28 version 3.9.0 (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript)
  291 
  292   C++
  293   * Optimize and simplify implementation of RepeatedPtrFieldBase
  294   * Don't create unnecessary unknown field sets.
  295   * Remove branch from accessors to repeated field element array.
  296   * Added delimited parse and serialize util.
  297   * Reduce size by not emitting constants for fieldnumbers
  298   * Fix a bug when comparing finite and infinite field values with explicit tolerances.
  299   * TextFormat::Parser should use a custom Finder to look up extensions by number if one is provided.
  300   * Add MessageLite::Utf8DebugString() to make MessageLite more compatible with Message.
  301   * Fail fast for better performance in DescriptorPool::FindExtensionByNumber() if descriptor has no defined extensions.
  302   * Adding the file name to help debug colliding extensions
  303   * Added FieldDescriptor::PrintableNameForExtension() and DescriptorPool::FindExtensionByPrintableName().
  304     The latter will replace Reflection::FindKnownExtensionByName().
  305   * Replace NULL with nullptr
  306   * Created a new Add method in repeated field that allows adding a range of elements all at once.
  307   * Enabled enum name-to-value mapping functions for C++ lite
  308   * Avoid dynamic initialization in descriptor.proto generated code
  309   * Move stream functions to MessageLite from Message.
  310   * Move all zero_copy_stream functionality to io_lite.
  311   * Do not create array of matched fields for simple repeated fields
  312   * Enabling silent mode by default to reduce make compilation noise. (#6237)
  313 
  314   Java
  315   * Expose TextFormat.Printer and make it configurable. Deprecate the static methods.
  316   * Library for constructing google.protobuf.Struct and google.protobuf.Value
  317   * Make OneofDescriptor extend GenericDescriptor.
  318   * Expose streamingness of service methods from MethodDescriptor.
  319   * Fix a bug where TextFormat fails to parse Any filed with > 1 embedded message sub-fields.
  320   * Establish consistent JsonFormat behavior for nulls in oneofs, regardless of order.
  321   * Update GSON version to 3.8.5. (#6268)
  322   * Add `protobuf_java_lite` Bazel target. (#6177)
  323 
  324   Python
  325   * Change implementation of Name() for enums that allow aliases in proto2 in Python
  326     to be in line with claims in C++ implementation (to return first value).
  327   * Explicitly say what field cannot be set when the new value fails a type check.
  328   * Duplicate register in descriptor pool will raise errors
  329   * Add __slots__ to all well_known_types classes, custom attributes are not allowed anymore.
  330   * text_format only present 8 valid digits for float fields by default
  331 
  332   JavaScript
  333   * Add Oneof enum to the list of goog.provide
  334 
  335   PHP
  336   * Make php message class final to avoid mocking. (#6277)
  337   * Rename get/setXXXValue to get/setXXXWrapper. (#6295)
  338 
  339   Ruby
  340   * Remove to_hash methods. (#6166)
  341 
  342 
  343 2019-04-29 version 3.8.0 (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript)
  344 
  345   C++
  346   * Use std::atomic<int32> in case of myriad2 platform
  347   * Always declare enums to be int-sized
  348   * Added DebugString() and ShortDebugString() methods on MessageLite
  349   * Specialized different parse loop control flows
  350   * Make hasbits potentially in register. The or's start forming an obstacle because it's a read modify store on the same mem address on each iteration.
  351   * Move to an internal MACRO for parser validity checks.
  352   * Improve map parsing performance.
  353   * Make MergePartialFromCodedStream non virtual. This allows direct calls, potential inlining and is also a code health improvement
  354   * Add an overall limit to parse_context to prevent reading past it. This allows to remove a annoying level of indirection.
  355   * Fix a mistake, we shouldn't verify map key/value strings for utf8 in opt mode for proto2.
  356   * Further improvements to cut binary size.
  357   * Prepare to make MergePartialFromCodedStream non-virtual.
  358   * A report on some interesting behavior change in python (caused by b/27494216) made me realize there is a check that needs to be done in case the parse ended on a end group tag.
  359   * Add a note of caution to the comments around skip in CodedOutputStream.
  360   * Simplify end check.
  361   * Add overload for ParseMessage for MessageLite/Message types. If the explicit type is not known inlining won't help de-virtualizing the virtual call.
  362   * Reduce linker input. It turns out that ParseMessage is not inlined, producing  template instantiations that are used only once and save nothing but cost more.
  363   * Improve the parser.
  364   * [c++17] Changed proto2::RepeatedPtrField iterators to no longer derive from the deprecated std::iterator class.
  365   * Change the default value of case_insensitive_enum_parsing to false for JsonStringToMessage.
  366   * Add a warning if a field name doesn't match the style guide.
  367   * Fix TextFormat not round-trip correctly when float value is max float.
  368   * Added locationed info for some errors at compiler
  369   * Python reserved keywords are now working with getattr()/setattr() for most descriptors.
  370   * Added AllowUnknownField() in text_format
  371   * Append '_' to C++ reserved keywords for message, enum, extension
  372   * Fix MSVC warning C4244 in protobuf's parse_context.h.
  373   * Updating Iterators to be compatible with C++17 in MSVC.
  374   * Use capability annotation in mutex.h
  375   * Fix "UndefinedBehaviorSanitizer: cfi-bad-type"
  376   * CriticalSectionLock class as a lightweight replacement for std::mutex on Windows platforms.
  377   * Removed vestigial wire_format_lite_inl.h
  378 
  379   C#
  380   * Added System.Memory dependency.
  381 
  382   Java
  383   * Make Java protoc code generator ignore optimize_for LITE_RUNTIME. Users should instead use the Java lite protoc plugin.
  384   * Change Extension getMessageDefaultInstance() to return Message instead of MessageLite.
  385   * Prevent malicious input streams from leaking buffers for ByteString or ByteBuffer parsing.
  386   * Release new Javalite runtime.
  387   * Show warning in case potential file name conflict.
  388   * Allow Java reserved keywords to be used in extensions.
  389   * Added setAllowUnknownFields() in text format
  390   * Add memoization to ExtensionRegistryLite.getEmptyRegistry()
  391   * Improve performance of CodedOutputStream.writeUInt32NoTag
  392   * Add an optimized mismatch-finding algorithm to UnsafeUtil.
  393   * When serializing uint32 varints, check that we have MAX_VARINT32_SIZE bytes left, not just MAX_VARINT_SIZE.
  394   * Minor optimization to RopeByteString.PieceIterator
  395 
  396   JavaScript
  397   * Simplify generated toObject code when the default value is used.
  398 
  399   Python
  400   * Changes implementation of Name() for enums that allow aliases in proto2 in Python to be in line with claims in C++ implementation (to return first value).
  401   * Added double_format option in text format printer.
  402   * Added iter and __contains__ to extension dict
  403   * Added allow_unknown_field option in python text format parser
  404   * Fixed Timestamp.ToDatetime() loses precision issue
  405   * Support unknown field in text format printer.
  406   * Float field will be convert to inf if bigger than struct.unpack('f', b'\xff\xff\x7f\x7f')[0] which is about 3.4028234664e+38,
  407   convert to -inf if smaller than -3.4028234664e+38
  408   * Allowed casting str->bytes in Message.__setstate__
  409 
  410   Ruby
  411   * Helper methods to get enum name for Ruby.
  412 
  413 
  414 2019-01-24 version 3.7.0 (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript)
  415 
  416   C++
  417   * Introduced new MOMI (maybe-outside-memory-interval) parser.
  418   * Add an option to json_util to parse enum as case-insensitive. In the future, enum parsing in json_util will become case-sensitive.
  419   * Added conformance test for enum aliases
  420   * Added support for --cpp_out=speed:...
  421   * Added use of C++ override keyword where appropriate
  422   * Many other cleanups and fixes.
  423 
  424   Java
  425   * Fix illegal reflective access warning in JDK 9+
  426   * Add BOM
  427 
  428   Python
  429   * Added Python 3.7 compatibility.
  430   * Modified ParseFromString to return bytes parsed .
  431   * Introduce Proto C API.
  432   * FindFileContainingSymbol in descriptor pool is now able to find field and enum values.
  433   * reflection.MakeClass()  and  reflection.ParseMessage() are deprecated.
  434   * Added DescriptorPool.FindMethodByName() method in pure python (c extension already has it)
  435   * Flipped proto3 to preserve unknown fields by default.
  436   * Added support for memoryview in python3 proto message parsing.
  437   * Added MergeFrom for repeated scalar fields in c extension (pure python already has it)
  438   * Surrogates are now rejected at setters in python3.
  439   * Added public unknown field API.
  440   * RecursionLimit is also set to max if allow_oversize_protos is enabled.
  441   * Disallow duplicate scalars in proto3 text_format parse.
  442   * Fix some segment faults for c extension map field.
  443 
  444   PHP
  445   * Most issues for json encoding/decoding in the c extension have been fixed. There are still some edge cases not fixed. For more details, check conformance/failure_list_php_c.txt.
  446   * Supports php 7.3
  447   * Added helper methods to convert between enum values and names.
  448   * Allow setting/getting wrapper message fields using primitive values.
  449   * Various bug fixes.
  450 
  451   Ruby
  452   * Ruby 2.6 support.
  453   * Drops support for ruby < 2.3.
  454   * Most issues for json encoding/decoding in the c extension have been fixed. There are still some edge cases not fixed. For more details, check conformance/failure_list_ruby.txt.
  455   * Json parsing can specify an option to ignore unknown fields: msg.decode_json(data, {ignore_unknown_fields: true}).
  456   * Added support for proto2 syntax (partially).
  457   * Various bug fixes.
  458 
  459   Csharp
  460   * More support for FieldMask include merge, intersect and more.
  461   * Increasing the default recursion limit to 100.
  462   * Support loading FileDescriptors dynamically.
  463   * Provide access to comments from descriptors.
  464   * Added Any.Is method.
  465   * Compatible with C# 6
  466   * Added IComparable and comparison operators on Timestamp.
  467 
  468   Objective C
  469   * Add ability to introspect list of enum values (#4678)
  470   * Copy the value when setting message/data fields (#5215)
  471   * Support suppressing the objc package prefix checks on a list of files (#5309)
  472   * More complete keyword and NSObject method (via categories) checks for field names, can result in more fields being rename, but avoids the collisions at runtime (#5289)
  473   * Small fixes to TextFormat generation for extensions (#5362)
  474   * Provide more details/context in deprecation messages (#5412)
  475   * Array/Dictionary enumeration blocks NS_NOESCAPE annotation for Swift (#5421)
  476   * Properly annotate extensions for ARC when their names imply behaviors (#5427)
  477   * Enum alias name collision improvements (#5480)
  478 
  479 
  480 2018-07-27 version 3.6.1 (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript)
  481 
  482   C++
  483   * Introduced workaround for Windows issue with std::atomic and std::once_flag
  484     initialization (#4777, #4773).
  485 
  486   PHP
  487   * Added compatibility with PHP 7.3 (#4898).
  488 
  489   Ruby
  490   * Fixed Ruby crash involving Any encoding (#4718).
  491 
  492 2018-06-01 version 3.6.0 (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript)
  493 
  494   C++
  495   * Starting from this release, we now require C++11. For those we cannot yet
  496     upgrade to C++11, we will try to keep the 3.5.x branch updated with
  497     critical bug fixes only. If you have any concerns about this, please
  498     comment on issue #2780.
  499   * Moved to C++11 types like std::atomic and std::unique_ptr and away from our
  500     old custom-built equivalents.
  501   * Added support for repeated message fields in lite protos using implicit
  502     weak fields. This is an experimental feature that allows the linker to
  503     strip out more unused messages than previously was possible.
  504   * Fixed SourceCodeInfo for interpreted options and extension range options.
  505   * Fixed always_print_enums_as_ints option for JSON serialization.
  506   * Added support for ignoring unknown enum values when parsing JSON.
  507   * Create std::string in Arena memory.
  508   * Fixed ValidateDateTime to correctly check the day.
  509   * Fixed bug in ZeroCopyStreamByteSink.
  510   * Various other cleanups and fixes.
  511 
  512   Java
  513   * Dropped support for Java 6.
  514   * Added a UTF-8 decoder that uses Unsafe to directly decode a byte buffer.
  515   * Added deprecation annotations to generated code for deprecated oneof
  516     fields.
  517   * Fixed map field serialization in DynamicMessage.
  518   * Cleanup and documentation for Java Lite runtime.
  519   * Various other fixes and cleanups
  520   * Fixed unboxed arraylists to handle an edge case
  521   * Improved performance for copying between unboxed arraylists
  522   * Fixed lite protobuf to avoid Java compiler warnings
  523   * Improved test coverage for lite runtime
  524   * Performance improvements for lite runtime
  525 
  526   Python
  527   * Fixed bytes/string map key incompatibility between C++ and pure-Python
  528     implementations (issue #4029)
  529   * Added __init__.py files to compiler and util subpackages
  530   * Use /MT for all Windows versions
  531   * Fixed an issue affecting the Python-C++ implementation when used with
  532     Cython (issue #2896)
  533   * Various text format fixes
  534   * Various fixes to resolve behavior differences between the pure-Python and
  535     Python-C++ implementations
  536 
  537   PHP
  538   * Added php_metadata_namespace to control the file path of generated metadata
  539     file.
  540   * Changed generated classes of nested message/enum. E.g., Foo.Bar, which
  541     previously generates Foo_Bar, now generates Foo/Bar
  542   * Added array constructor. When creating a message, users can pass a php
  543     array whose content is field name to value pairs into constructor. The
  544     created message will be initialized according to the array. Note that
  545     message field should use a message value instead of a sub-array.
  546   * Various bug fixes.
  547 
  548   Objective-C
  549   * We removed some helper class methods from GPBDictionary to shrink the size
  550     of the library, the functionary is still there, but you may need to do some
  551     specific +alloc / -init… methods instead.
  552   * Minor improvements in the performance of object field getters/setters by
  553     avoiding some memory management overhead.
  554   * Fix a memory leak during the raising of some errors.
  555   * Make header importing completely order independent.
  556   * Small code improvements for things the undefined behaviors compiler option
  557     was flagging.
  558 
  559   Ruby
  560   * Added ruby_package file option to control the module of generated class.
  561   * Various bug fixes.
  562 
  563   Javascript
  564   * Allow setting string to int64 field.
  565 
  566   Csharp
  567   * Unknown fields are now parsed and then sent back on the wire. They can be
  568     discarded at parse time via a CodedInputStream option.
  569   * Movement towards working with .NET 3.5 and Unity
  570   * Expression trees are no longer used
  571   * AOT generics issues in Unity/il2cpp have a workaround (see this commit for
  572     details)
  573   * Floating point values are now compared bitwise (affects NaN value
  574     comparisons)
  575   * The default size limit when parsing is now 2GB rather than 64MB
  576   * MessageParser now supports parsing from a slice of a byte array
  577   * JSON list parsing now accepts null values where the underlying proto
  578     representation does
  579 
  580 2017-12-20 version 3.5.1 (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript)
  581   Planned Future Changes
  582   * Make C++ implementation C++11 only: we plan to require C++11 to build
  583     protobuf code starting from 3.6.0 release. Please join this github issue:
  584     https://github.com/protocolbuffers/protobuf/issues/2780 to provide your feedback.
  585 
  586   protoc
  587   * Fixed a bug introduced in 3.5.0 and protoc in Windows now accepts non-ascii
  588     characters in paths again.
  589 
  590   C++
  591   * Removed several usages of C++11 features in the code base.
  592   * Fixed some compiler warnings.
  593 
  594   PHP
  595   * Fixed memory leak in C-extension implementation.
  596   * Added discardUnknokwnFields API.
  597   * Removed duplicated typedef in C-extension headers.
  598   * Avoided calling private php methods (timelib_update_ts).
  599   * Fixed Any.php to use fully-qualified name for DescriptorPool.
  600 
  601   Ruby
  602   * Added Google_Protobuf_discard_unknown for discarding unknown fields in
  603     messages.
  604 
  605   C#
  606   * Unknown fields are now preserved by default.
  607   * Floating point values are now bitwise compared, affecting message equality
  608     check and Contains() API in map and repeated fields.
  609 
  610 
  611 2017-11-13 version 3.5.0 (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript)
  612   Planned Future Changes
  613   * Make C++ implementation C++11 only: we plan to require C++11 to build
  614     protobuf code starting from 3.6.0 release. Please join this github issue:
  615     https://github.com/protocolbuffers/protobuf/issues/2780 to provide your feedback.
  616 
  617   General
  618   * Unknown fields are now preserved in proto3 for most of the language
  619     implementations for proto3 by default. See the per-language section for
  620     details.
  621   * reserve keyword are now supported in enums
  622 
  623   C++
  624   * Proto3 messages are now preserving unknown fields by default. If you rely on
  625     unknowns fields being dropped. Please use DiscardUnknownFields() explicitly.
  626   * Deprecated the unsafe_arena_release_* and unsafe_arena_add_allocated_*
  627     methods for string fields.
  628   * Added move constructor and move assignment to RepeatedField,
  629     RepeatedPtrField and google::protobuf::Any.
  630   * Added perfect forwarding in Arena::CreateMessage
  631   * In-progress experimental support for implicit weak fields with lite protos.
  632     This feature allows the linker to strip out more unused messages and reduce
  633     binary size.
  634   * Various performance optimizations.
  635 
  636   Java
  637   * Proto3 messages are now preserving unknown fields by default. If you’d like
  638     to drop unknown fields, please use the DiscardUnknownFieldsParser API. For
  639     example:
  640       Parser<Foo> parser = DiscardUnknownFieldsParser.wrap(Foo.parser());
  641       Foo foo = parser.parseFrom(input);
  642   * Added a new CodedInputStream decoder for Iterable<ByteBuffer> with direct
  643     ByteBuffers.
  644   * TextFormat now prints unknown length-delimited fields as messages if
  645     possible.
  646   * FieldMaskUtil.merge() no longer creates unnecessary empty messages when a
  647     message field is unset in both source message and destination message.
  648   * Various performance optimizations.
  649 
  650   Python
  651   * Proto3 messages are now preserving unknown fields by default. Use
  652     message.DiscardUnknownFields() to drop unknown fields.
  653   * Add FieldDescriptor.file in generated code.
  654   * Add descriptor pool FindOneofByName in pure python.
  655   * Change unknown enum values into unknown field set .
  656   * Add more Python dict/list compatibility for Struct/ListValue.
  657   * Add utf-8 support for text_format.Merge()/Parse().
  658   * Support numeric unknown enum values for proto3 JSON format.
  659   * Add warning for Unexpected end-group tag in cpp extension.
  660 
  661   PHP
  662   * Proto3 messages are now preserving unknown fields.
  663   * Provide well known type messages in runtime.
  664   * Add prefix ‘PB’ to generated class of reserved names.
  665   * Fixed all conformance tests for encode/decode json in php runtime. C
  666     extension needs more work.
  667 
  668   Objective-C
  669   * Fixed some issues around copying of messages with unknown fields and then
  670     mutating the unknown fields in the copy.
  671 
  672   C#
  673   * Added unknown field support in JsonParser.
  674   * Fixed oneof message field merge.
  675   * Simplify parsing messages from array slices.
  676 
  677   Ruby
  678   * Unknown fields are now preserved by default.
  679   * Fixed several bugs for segment fault.
  680 
  681   Javascript
  682   * Decoder can handle both paced and unpacked data no matter how the proto is
  683     defined.
  684   * Decoder now accept long varint for 32 bit integers.
  685 
  686 
  687 2017-08-14 version 3.4.0 (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript)
  688   Planned Future Changes
  689   * There are some changes that are not included in this release but are planned
  690     for the near future
  691       - Preserve unknown fields in proto3: We are going to bring unknown fields
  692         back into proto3. In this release, some languages start to support
  693         preserving unknown fields in proto3, controlled by flags/options. Some
  694         languages also introduce explicit APIs to drop unknown fields for
  695         migration. Please read the change log sections by languages for details.
  696         For general timeline and plan:
  697 
  698           https://docs.google.com/document/d/1KMRX-G91Aa-Y2FkEaHeeviLRRNblgIahbsk4wA14gRk/view
  699 
  700         For issues and discussions:
  701 
  702           https://github.com/protocolbuffers/protobuf/issues/272
  703 
  704       - Make C++ implementation C++11 only: we plan to require C++11 to build
  705         protobuf code starting from 3.5.0 or 3.6.0 release, after unknown fields
  706         semantic changes are finished. Please join this
  707         github issue:
  708 
  709           https://github.com/protocolbuffers/protobuf/issues/2780
  710 
  711         to provide your feedback.
  712 
  713   General
  714   * Extension ranges now accept options and are customizable.
  715   * "reserve" keyword now supports “max” in field number ranges,
  716     e.g.  reserve 1000 to max;
  717 
  718   C++
  719   * Proto3 messages are now able to preserve unknown fields. The default
  720     behavior is still to drop unknowns, which will be flipped in a future
  721     release. If you rely on unknowns fields being dropped. Please use
  722     Message::DiscardUnknownFields() explicitly.
  723   * Packable proto3 fields are now packed by default in serialization.
  724   * Following C++11 features are introduced when C++11 is available:
  725       - move-constructor and move-assignment are introduced to messages
  726       - Repeated fields constructor now takes std::initializer_list
  727       - rvalue setters are introduced for string fields
  728   * Experimental Table-Driven parsing and serialization available to test. To
  729     enable it, pass in table_driven_parsing table_driven_serialization protoc
  730     generator flags for C++
  731 
  732       $ protoc --cpp_out=table_driven_parsing,table_driven_serialization:./ \
  733         test.proto
  734 
  735   * lite generator parameter supported by the generator. Once set, all generated
  736     files, use lite runtime regardless of the optimizer_for setting in the
  737     .proto file.
  738   * Various optimizations to make C++ code more performant on PowerPC platform
  739   * Fixed maps data corruption when the maps are modified by both reflection API
  740     and generated API.
  741   * Deterministic serialization on maps reflection now uses stable sort.
  742   * file() accessors are introduced to various *Descriptor classes to make
  743     writing template function easier.
  744   * ByteSize() and SpaceUsed() are deprecated.Use ByteSizeLong() and
  745     SpaceUsedLong() instead
  746   * Consistent hash function is used for maps in DEBUG and NDEBUG build.
  747   * "using namespace std" is removed from stubs/common.h
  748   * Various performance optimizations and bug fixes
  749 
  750   Java
  751   * Introduced new parser API DiscardUnknownFieldsParser in preparation of
  752     proto3 unknown fields preservation change. Users who want to drop unknown
  753     fields should migrate to use this new parser API. For example:
  754 
  755       Parser<Foo> parser = DiscardUnknownFieldsParser.wrap(Foo.parser());
  756       Foo foo = parser.parseFrom(input);
  757 
  758   * Introduced new TextFormat API printUnicodeFieldValue() that prints field
  759     value without escaping unicode characters.
  760   * Added Durations.compare(Duration, Duration) and
  761     Timestamps.compare(Timestamp, Timestamp).
  762   * JsonFormat now accepts base64url encoded bytes fields.
  763   * Optimized CodedInputStream to do less copies when parsing large bytes
  764     fields.
  765   * Optimized TextFormat to allocate less memory when printing.
  766 
  767   Python
  768   * SerializeToString API is changed to SerializeToString(self, **kwargs),
  769     deterministic parameter is accepted for deterministic serialization.
  770   * Added sort_keys parameter in json format to make the output deterministic.
  771   * Added indent parameter in json format.
  772   * Added extension support in json format.
  773   * Added __repr__ support for repeated field in cpp implementation.
  774   * Added file in FieldDescriptor.
  775   * Added pretty-print filter to text format.
  776   * Services and method descriptors are always printed even if generic_service
  777     option is turned off.
  778   * Note: AppEngine 2.5 is deprecated on June 2017 that AppEngine 2.5 will
  779     never update protobuf runtime. Users who depend on AppEngine 2.5 should use
  780     old protoc.
  781 
  782   PHP
  783   * Support PHP generic services. Specify file option php_generic_service=true
  784     to enable generating service interface.
  785   * Message, repeated and map fields setters take value instead of reference.
  786   * Added map iterator in c extension.
  787   * Support json  encode/decode.
  788   * Added more type info in getter/setter phpdoc
  789   * Fixed the problem that c extension and php implementation cannot be used
  790     together.
  791   * Added file option php_namespace to use custom php namespace instead of
  792     package.
  793   * Added fluent setter.
  794   * Added descriptor API in runtime for custom encode/decode.
  795   * Various bug fixes.
  796 
  797   Objective-C
  798   * Fix for GPBExtensionRegistry copying and add tests.
  799   * Optimize GPBDictionary.m codegen to reduce size of overall library by 46K
  800     per architecture.
  801   * Fix some cases of reading of 64bit map values.
  802   * Properly error on a tag with field number zero.
  803   * Preserve unknown fields in proto3 syntax files.
  804   * Document the exceptions on some of the writing apis.
  805 
  806   C#
  807   * Implemented IReadOnlyDictionary<K,V> in MapField<K,V>
  808   * Added TryUnpack method for Any message in addition to Unpack.
  809   * Converted C# projects to MSBuild (csproj) format.
  810 
  811   Ruby
  812   * Several bug fixes.
  813 
  814   Javascript
  815   * Added support of field option js_type. Now one can specify the JS type of a
  816     64-bit integer field to be string in the generated code by adding option
  817     [jstype = JS_STRING] on the field.
  818 
  819 2017-04-05 version 3.3.0 (C++/Java/Python/PHP/Objective-C/C#/Ruby/JavaScript)
  820   Planned Future Changes
  821   * There are some changes that are not included in this release but are
  822     planned for the near future:
  823       - Preserve unknown fields in proto3: please read this doc:
  824 
  825           https://docs.google.com/document/d/1KMRX-G91Aa-Y2FkEaHeeviLRRNblgIahbsk4wA14gRk/view
  826 
  827         for the timeline and follow up this github issue:
  828 
  829           https://github.com/protocolbuffers/protobuf/issues/272
  830 
  831         for discussion.
  832       - Make C++ implementation C++11 only: we plan to require C++11 to build
  833         protobuf code starting from 3.4.0 or 3.5.0 release. Please join this
  834         github issue:
  835 
  836           https://github.com/protocolbuffers/protobuf/issues/2780
  837 
  838         to provide your feedback.
  839 
  840   C++
  841   * Fixed map fields serialization of DynamicMessage to correctly serialize
  842     both key and value regardless of their presence.
  843   * Parser now rejects field number 0 correctly.
  844   * New API Message::SpaceUsedLong() that’s equivalent to
  845     Message::SpaceUsed() but returns the value in size_t.
  846   * JSON support
  847     - New flag always_print_enums_as_ints in JsonPrintOptions.
  848     - New flag preserve_proto_field_names in JsonPrintOptions. It will instruct
  849       the JSON printer to use the original field name declared in the .proto
  850       file instead of converting them to lowerCamelCase when printing JSON.
  851     - JsonPrintOptions.always_print_primtive_fields now works for oneof message
  852       fields.
  853     - Fixed a bug that doesn’t allow different fields to set the same json_name
  854       value.
  855     - Fixed a performance bug that causes excessive memory copy when printing
  856       large messages.
  857   * Various performance optimizations.
  858 
  859   Java
  860   * Map field setters eagerly validate inputs and throw NullPointerExceptions
  861     as appropriate.
  862   * Added ByteBuffer overloads to the generated parsing methods and the Parser
  863     interface.
  864   * proto3 enum's getNumber() method now throws on UNRECOGNIZED values.
  865   * Output of JsonFormat is now locale independent.
  866 
  867   Python
  868   * Added FindServiceByName() in the pure-Python DescriptorPool. This works only
  869     for descriptors added with DescriptorPool.Add(). Generated descriptor_pool
  870     does not support this yet.
  871   * Added a descriptor_pool parameter for parsing Any in text_format.Parse().
  872   * descriptor_pool.FindFileContainingSymbol() now is able to find nested
  873     extensions.
  874   * Extending empty [] to repeated field now sets parent message presence.
  875 
  876   PHP
  877   * Added file option php_class_prefix. The prefix will be prepended to all
  878     generated classes defined in the file.
  879   * When encoding, negative int32 values are sign-extended to int64.
  880   * Repeated/Map field setter accepts a regular PHP array. Type checking is
  881     done on the array elements.
  882   * encode/decode are renamed to serializeToString/mergeFromString.
  883   * Added mergeFrom, clear method on Message.
  884   * Fixed a bug that oneof accessor didn’t return the field name that is
  885     actually set.
  886   * C extension now works with php7.
  887   * This is the first GA release of PHP. We guarantee that old generated code
  888     can always work with new runtime and new generated code.
  889 
  890   Objective-C
  891   * Fixed help for GPBTimestamp for dates before the epoch that contain
  892     fractional seconds.
  893   * Added GPBMessageDropUnknownFieldsRecursively() to remove unknowns from a
  894     message and any sub messages.
  895   * Addressed a threading race in extension registration/lookup.
  896   * Increased the max message parsing depth to 100 to match the other languages.
  897   * Removed some use of dispatch_once in favor of atomic compare/set since it
  898     needs to be heap based.
  899   * Fixes for new Xcode 8.3 warnings.
  900 
  901   C#
  902   * Fixed MapField.Values.CopyTo, which would throw an exception unnecessarily
  903     if provided exactly the right size of array to copy to.
  904   * Fixed enum JSON formatting when multiple names mapped to the same numeric
  905     value.
  906   * Added JSON formatting option to format enums as integers.
  907   * Modified RepeatedField<T> to implement IReadOnlyList<T>.
  908   * Introduced the start of custom option handling; it's not as pleasant as it
  909     might be, but the information is at least present. We expect to extend code
  910     generation to improve this in the future.
  911   * Introduced ByteString.FromStream and ByteString.FromStreamAsync to
  912     efficiently create a ByteString from a stream.
  913   * Added whole-message deprecation, which decorates the class with [Obsolete].
  914 
  915   Ruby
  916   * Fixed Message#to_h for messages with map fields.
  917   * Fixed memcpy() in binary gems to work for old glibc, without breaking the
  918     build for non-glibc libc’s like musl.
  919 
  920   Javascript
  921   * Added compatibility tests for version 3.0.0.
  922   * Added conformance tests.
  923   * Fixed serialization of extensions: we need to emit a value even if it is
  924     falsy (like the number 0).
  925   * Use closurebuilder.py in favor of calcdeps.py for compiling JavaScript.
  926 
  927 2017-01-23 version 3.2.0 (C++/Java/Python/PHP/Ruby/Objective-C/C#/JavaScript/Lite)
  928   General
  929   * Added protoc version number to protoc plugin protocol. It can be used by
  930     protoc plugin to detect which version of protoc is used with the plugin and
  931     mitigate known problems in certain version of protoc.
  932 
  933   C++
  934   * The default parsing byte size limit has been raised from 64MB to 2GB.
  935   * Added rvalue setters for non-arena string fields.
  936   * Enabled debug logging for Android.
  937   * Fixed a double-free problem when using Reflection::SetAllocatedMessage()
  938     with extension fields.
  939   * Fixed several deterministic serialization bugs:
  940     * MessageLite::SerializeAsString() now respects the global deterministic
  941       serialization flag.
  942     * Extension fields are serialized deterministically as well.  Fixed protocol
  943       compiler to correctly report importing-self as an error.
  944   * Fixed FileDescriptor::DebugString() to print custom options correctly.
  945   * Various performance/codesize optimizations and cleanups.
  946 
  947   Java
  948   * The default parsing byte size limit has been raised from 64MB to 2GB.
  949   * Added recursion limit when parsing JSON.
  950   * Fixed a bug that enumType.getDescriptor().getOptions() doesn't have custom
  951     options.
  952   * Fixed generated code to support field numbers up to 2^29-1.
  953 
  954   Python
  955   * You can now assign NumPy scalars/arrays (np.int32, np.int64) to protobuf
  956     fields, and assigning other numeric types has been optimized for
  957     performance.
  958   * Pure-Python: message types are now garbage-collectable.
  959   * Python/C++: a lot of internal cleanup/refactoring.
  960 
  961   PHP (Alpha)
  962   * For 64-bit integers type (int64/uint64/sfixed64/fixed64/sint64), use PHP
  963     integer on 64-bit environment and PHP string on 32-bit environment.
  964   * PHP generated code also conforms to PSR-4 now.
  965   * Fixed ZTS build for c extension.
  966   * Fixed c extension build on Mac.
  967   * Fixed c extension build on 32-bit linux.
  968   * Fixed the bug that message without namespace is not found in the descriptor
  969     pool. (#2240)
  970   * Fixed the bug that repeated field is not iterable in c extension.
  971   * Message names Empty will be converted to GPBEmpty in generated code.
  972   * Added phpdoc in generated files.
  973   * The released API is almost stable. Unless there is large problem, we won't
  974     change it. See
  975     https://developers.google.com/protocol-buffers/docs/reference/php-generated
  976     for more details.
  977 
  978   Objective-C
  979   * Added support for push/pop of the stream limit on CodedInputStream for
  980     anyone doing manual parsing.
  981 
  982   C#
  983   * No changes.
  984 
  985   Ruby
  986   * Message objects now support #respond_to? for field getters/setters.
  987   * You can now compare “message == non_message_object” and it will return false
  988     instead of throwing an exception.
  989   * JRuby: fixed #hashCode to properly reflect the values in the message.
  990 
  991   Javascript
  992   * Deserialization of repeated fields no longer has quadratic performance
  993     behavior.
  994   * UTF-8 encoding/decoding now properly supports high codepoints.
  995   * Added convenience methods for some well-known types: Any, Struct, and
  996     Timestamp. These make it easier to convert data between native JavaScript
  997     types and the well-known protobuf types.
  998 
  999 2016-09-23 version 3.1.0 (C++/Java/Python/PHP/Ruby/Objective-C/C#/JavaScript/Lite)
 1000   General
 1001   * Proto3 support in PHP (alpha).
 1002   * Various bug fixes.
 1003 
 1004   C++
 1005   * Added MessageLite::ByteSizeLong() that’s equivalent to
 1006     MessageLite::ByteSize() but returns the value in size_t. Useful to check
 1007     whether a message is over the 2G size limit that protobuf can support.
 1008   * Moved default_instances to global variables. This allows default_instance
 1009     addresses to be known at compile time.
 1010   * Adding missing generic gcc 64-bit atomicops.
 1011   * Restore New*Callback into google::protobuf namespace since these are used
 1012     by the service stubs code
 1013   * JSON support.
 1014     * Fixed some conformance issues.
 1015   * Fixed a JSON serialization bug for bytes fields.
 1016 
 1017   Java
 1018   * Fixed a bug in TextFormat that doesn’t accept empty repeated fields (i.e.,
 1019     “field: [ ]”).
 1020   * JSON support
 1021     * Fixed JsonFormat to do correct snake_case-to-camelCase conversion for
 1022       non-style-conforming field names.
 1023     * Fixed JsonFormat to parse empty Any message correctly.
 1024     * Added an option to JsonFormat.Parser to ignore unknown fields.
 1025   * Experimental API
 1026     * Added UnsafeByteOperations.unsafeWrap(byte[]) to wrap a byte array into
 1027       ByteString without copy.
 1028 
 1029   Python
 1030   * JSON support
 1031     * Fixed some conformance issues.
 1032 
 1033   PHP (Alpha)
 1034   * We have added the proto3 support for PHP via both a pure PHP package and a
 1035     native c extension. The pure PHP package is intended to provide usability
 1036     to wider range of PHP platforms, while the c extension is intended to
 1037     provide higher performance. Both implementations provide the same runtime
 1038     APIs and share the same generated code. Users don’t need to re-generate
 1039     code for the same proto definition when they want to switch the
 1040     implementation later. The pure PHP package is included in the php/src
 1041     directory, and the c extension is included in the php/ext directory.
 1042 
 1043     Both implementations provide idiomatic PHP APIs:
 1044     * All messages and enums are defined as PHP classes.
 1045     * All message fields can only be accessed via getter/setter.
 1046     * Both repeated field elements and map elements are stored in containers
 1047       that act like a normal PHP array.
 1048 
 1049     Unlike several existing third-party PHP implementations for protobuf, our
 1050     implementations are built on a "strongly-typed" philosophy: message fields
 1051     and array/map containers will throw exceptions eagerly when values of the
 1052     incorrect type (not including those that can be type converted, e.g.,
 1053     double <-> integer <-> numeric string) are inserted.
 1054 
 1055     Currently, pure PHP runtime supports php5.5, 5.6 and 7 on linux. C
 1056     extension runtime supports php5.5 and 5.6 on linux.
 1057 
 1058     See php/README.md for more details about installment. See
 1059     https://developers.google.com/protocol-buffers/docs/phptutorial for more
 1060     details about APIs.
 1061 
 1062   Objective-C
 1063   * Helpers are now provided for working the Any well known type (see
 1064     GPBWellKnownTypes.h for the api additions).
 1065   * Some improvements in startup code (especially when extensions aren’t used).
 1066 
 1067   Javascript
 1068   * Fixed missing import of jspb.Map
 1069   * Fixed valueWriterFn variable name
 1070 
 1071   Ruby
 1072   * Fixed hash computation for JRuby's RubyMessage
 1073   * Make sure map parsing frames are GC-rooted.
 1074   * Added API support for well-known types.
 1075 
 1076   C#
 1077   * Removed check on dependency in the C# reflection API.
 1078 
 1079 2016-09-06 version 3.0.2 (C++/Java/Python/Ruby/Objective-C/C#/JavaScript/Lite)
 1080   General
 1081   * Various bug fixes.
 1082 
 1083   Objective C
 1084   * Fix for oneofs in proto3 syntax files where fields were set to the zero
 1085     value.
 1086   * Fix for embedded null character in strings.
 1087   * CocoaDocs support
 1088 
 1089   Ruby
 1090   * Fixed memory corruption bug in parsing that could occur under GC pressure.
 1091 
 1092   Javascript
 1093   * jspb.Map is now properly exported to CommonJS modules.
 1094 
 1095   C#
 1096   * Removed legacy_enum_values flag.
 1097 
 1098 
 1099 2016-07-27 version 3.0.0 (C++/Java/Python/Ruby/Objective-C/C#/JavaScript/Lite)
 1100   General
 1101   * This log only contains changes since the beta-4 release. Summarized change
 1102     log since the last stable release (v2.6.1) can be found in the github
 1103     release page.
 1104 
 1105   Compatibility Notice
 1106   * v3.0.0 is the first API stable release of the v3.x series. We do not expect
 1107     any future API breaking changes.
 1108   * For C++, Java Lite and Objective-C, source level compatibility is
 1109     guaranteed.  Upgrading from v3.0.0 to newer minor version releases will be
 1110     source compatible. For example, if your code compiles against protobuf
 1111     v3.0.0, it will continue to compile after you upgrade protobuf library to
 1112     v3.1.0.
 1113   * For other languages, both source level compatibility and binary level
 1114     compatibility are guaranteed. For example, if you have a Java binary built
 1115     against protobuf v3.0.0. After switching the protobuf runtime binary to
 1116     v3.1.0, your built binary should continue to work.
 1117   * Compatibility is only guaranteed for documented API and documented
 1118     behaviors. If you are using undocumented API (e.g., use anything in the C++
 1119     internal namespace), it can be broken by minor version releases in an
 1120     undetermined manner.
 1121 
 1122   Ruby
 1123   * When you assign a string field `a.string_field = "X"`, we now call
 1124     #encode(UTF-8) on the string and freeze the copy. This saves you from
 1125     needing to ensure the string is already encoded as UTF-8. It also prevents
 1126     you from mutating the string after it has been assigned (this is how we
 1127     ensure it stays valid UTF-8).
 1128   * The generated file for `foo.proto` is now `foo_pb.rb` instead of just
 1129     `foo.rb`. This makes it easier to see which imports/requires are from
 1130     protobuf generated code, and also prevents conflicts with any `foo.rb` file
 1131     you might have written directly in Ruby. It is a backward-incompatible
 1132     change: you will need to update all of your `require` statements.
 1133   * For package names like `foo_bar`, we now translate this to the Ruby module
 1134     `FooBar`. This is more idiomatic Ruby than what we used to do (`Foo_bar`).
 1135 
 1136   JavaScript
 1137   * Scalar fields like numbers and boolean now return defaults instead of
 1138     `undefined` or `null` when they are unset. You can test for presence
 1139     explicitly by calling `hasFoo()`, which we now generate for scalar fields.
 1140 
 1141   Java Lite
 1142   * Java Lite is now implemented as a separate plugin, maintained in the
 1143     `javalite` branch. Both lite runtime and protoc artifacts will be available
 1144     in Maven.
 1145 
 1146   C#
 1147   * Target platforms now .NET 4.5, selected portable subsets and .NET Core.
 1148   * legacy_enum_values option is no longer supported.
 1149 
 1150 2016-07-15 version 3.0.0-beta-4 (C++/Java/Python/Ruby/Objective-C/C#/JavaScript)
 1151   General
 1152   * Added a deterministic serialization API for C++. The deterministic
 1153     serialization guarantees that given a binary, equal messages will be
 1154     serialized to the same bytes. This allows applications like MapReduce to
 1155     group equal messages based on the serialized bytes. The deterministic
 1156     serialization is, however, NOT canonical across languages; it is also
 1157     unstable across different builds with schema changes due to unknown fields.
 1158     Users who need canonical serialization, e.g. persistent storage in a
 1159     canonical form, fingerprinting, etc, should define their own
 1160     canonicalization specification and implement the serializer using reflection
 1161     APIs rather than relying on this API.
 1162   * Added OneofOptions. You can now define custom options for oneof groups.
 1163       import "google/protobuf/descriptor.proto";
 1164       extend google.protobuf.OneofOptions {
 1165         optional int32 my_oneof_extension = 12345;
 1166       }
 1167       message Foo {
 1168         oneof oneof_group {
 1169           (my_oneof_extension) = 54321;
 1170           ...
 1171         }
 1172       }
 1173 
 1174   C++ (beta)
 1175   * Introduced a deterministic serialization API in
 1176     CodedOutputStream::SetSerializationDeterministic(bool). See the notes about
 1177     deterministic serialization in the General section.
 1178   * Added google::protobuf::Map::swap() to swap two map fields.
 1179   * Fixed a memory leak when calling Reflection::ReleaseMessage() on a message
 1180     allocated on arena.
 1181   * Improved error reporting when parsing text format protos.
 1182   * JSON
 1183       - Added a new parser option to ignore unknown fields when parsing JSON.
 1184       - Added convenient methods for message to/from JSON conversion.
 1185   * Various performance optimizations.
 1186 
 1187   Java (beta)
 1188   * File option "java_generate_equals_and_hash" is now deprecated. equals() and
 1189     hashCode() methods are generated by default.
 1190   * Added a new JSON printer option "omittingInsignificantWhitespace" to produce
 1191     a more compact JSON output. The printer will pretty-print by default.
 1192   * Updated Java runtime to be compatible with 2.5.0/2.6.1 generated protos.
 1193 
 1194   Python (beta)
 1195   * Added support to pretty print Any messages in text format.
 1196   * Added a flag to ignore unknown fields when parsing JSON.
 1197   * Bugfix: "@type" field of a JSON Any message is now correctly put before
 1198     other fields.
 1199 
 1200   Objective-C (beta)
 1201   * Updated the code to support compiling with more compiler warnings
 1202     enabled. (Issue 1616)
 1203   * Exposing more detailed errors for parsing failures. (PR 1623)
 1204   * Small (breaking) change to the naming of some methods on the support classes
 1205     for map<>. There were collisions with the system provided KVO support, so
 1206     the names were changed to avoid those issues.  (PR 1699)
 1207   * Fixed for proper Swift bridging of error handling during parsing. (PR 1712)
 1208   * Complete support for generating sources that will go into a Framework and
 1209     depend on generated sources from other Frameworks. (Issue 1457)
 1210 
 1211   C# (beta)
 1212   * RepeatedField optimizations.
 1213   * Support for .NET Core.
 1214   * Minor bug fixes.
 1215   * Ability to format a single value in JsonFormatter (advanced usage only).
 1216   * Modifications to attributes applied to generated code.
 1217 
 1218   Javascript (alpha)
 1219   * Maps now have a real map API instead of being treated as repeated fields.
 1220   * Well-known types are now provided in the google-protobuf package, and the
 1221     code generator knows to require() them from that package.
 1222   * Bugfix: non-canonical varints are correctly decoded.
 1223 
 1224   Ruby (alpha)
 1225   * Accessors for oneof fields now return default values instead of nil.
 1226 
 1227   Java Lite
 1228   * Java lite support is removed from protocol compiler. It will be supported
 1229     as a protocol compiler plugin in a separate code branch.
 1230 
 1231 2016-05-16 version 3.0.0-beta-3 (C++/Java/Python/Ruby/Nano/Objective-C/C#/JavaScript)
 1232   General
 1233   * Supported Proto3 lite-runtime in C++/Java for mobile platforms.
 1234   * Any type now supports APIs to specify prefixes other than
 1235     type.googleapis.com
 1236   * Removed javanano_use_deprecated_package option; Nano will always has its own
 1237     ".nano" package.
 1238 
 1239   C++ (Beta)
 1240   * Improved hash maps.
 1241       - Improved hash maps comments. In particular, please note that equal hash
 1242         maps will not necessarily have the same iteration order and
 1243         serialization.
 1244       - Added a new hash maps implementation that will become the default in a
 1245         later release.
 1246   * Arenas
 1247       - Several inlined methods in Arena were moved to out-of-line to improve
 1248         build performance and code size.
 1249       - Added SpaceAllocatedAndUsed() to report both space used and allocated
 1250       - Added convenient class UnsafeArenaAllocatedRepeatedPtrFieldBackInserter
 1251   * Any
 1252       - Allow custom type URL prefixes in Any packing.
 1253       - TextFormat now expand the Any type rather than printing bytes.
 1254   * Performance optimizations and various bug fixes.
 1255 
 1256   Java (Beta)
 1257   * Introduced an ExperimentalApi annotation. Annotated APIs are experimental
 1258     and are subject to change in a backward incompatible way in future releases.
 1259   * Introduced zero-copy serialization as an ExperimentalApi
 1260       - Introduction of the `ByteOutput` interface. This is similar to
 1261         `OutputStream` but provides semantics for lazy writing (i.e. no
 1262         immediate copy required) of fields that are considered to be immutable.
 1263       - `ByteString` now supports writing to a `ByteOutput`, which will directly
 1264         expose the internals of the `ByteString` (i.e. `byte[]` or `ByteBuffer`)
 1265         to the `ByteOutput` without copying.
 1266       - `CodedOutputStream` now supports writing to a `ByteOutput`. `ByteString`
 1267         instances that are too large to fit in the internal buffer will be
 1268         (lazily) written to the `ByteOutput` directly.
 1269       - This allows applications using large `ByteString` fields to avoid
 1270         duplication of these fields entirely. Such an application can supply a
 1271         `ByteOutput` that chains together the chunks received from
 1272         `CodedOutputStream` before forwarding them onto the IO system.
 1273   * Other related changes to `CodedOutputStream`
 1274       - Additional use of `sun.misc.Unsafe` where possible to perform fast
 1275         access to `byte[]` and `ByteBuffer` values and avoiding unnecessary
 1276         range checking.
 1277       - `ByteBuffer`-backed `CodedOutputStream` now writes directly to the
 1278         `ByteBuffer` rather than to an intermediate array.
 1279   * Improved lite-runtime.
 1280       - Lite protos now implement deep equals/hashCode/toString
 1281       - Significantly improved the performance of Builder#mergeFrom() and
 1282         Builder#mergeDelimitedFrom()
 1283   * Various bug fixes and small feature enhancement.
 1284       - Fixed stack overflow when in hashCode() for infinite recursive oneofs.
 1285       - Fixed the lazy field parsing in lite to merge rather than overwrite.
 1286       - TextFormat now supports reporting line/column numbers on errors.
 1287       - Updated to add appropriate @Override for better compiler errors.
 1288 
 1289   Python (Beta)
 1290   * Added JSON format for Any, Struct, Value and ListValue
 1291   * [ ] is now accepted for both repeated scalar fields and repeated message
 1292     fields in text format parser.
 1293   * Numerical field name is now supported in text format.
 1294   * Added DiscardUnknownFields API for python protobuf message.
 1295 
 1296   Objective-C (Beta)
 1297   * Proto comments now come over as HeaderDoc comments in the generated sources
 1298     so Xcode can pick them up and display them.
 1299   * The library headers have been updated to use HeaderDoc comments so Xcode can
 1300     pick them up and display them.
 1301   * The per message and per field overhead in both generated code and runtime
 1302     object sizes was reduced.
 1303   * Generated code now include deprecated annotations when the proto file
 1304     included them.
 1305 
 1306   C# (Beta)
 1307   In general: some changes are breaking, which require regenerating messages.
 1308   Most user-written code will not be impacted *except* for the renaming of enum
 1309   values.
 1310 
 1311   * Allow custom type URL prefixes in `Any` packing, and ignore them when
 1312     unpacking
 1313   * `protoc` is now in a separate NuGet package (Google.Protobuf.Tools)
 1314   * New option: `internal_access` to generate internal classes
 1315   * Enum values are now PascalCased, and if there's a prefix which matches the
 1316     name of the enum, that is removed (so an enum `COLOR` with a value
 1317     `COLOR_BLUE` would generate a value of just `Blue`). An option
 1318     (`legacy_enum_values`) is temporarily available to disable this, but the
 1319     option will be removed for GA.
 1320   * `json_name` option is now honored
 1321   * If group tags are encountered when parsing, they are validated more
 1322     thoroughly (although we don't support actual groups)
 1323   * NuGet dependencies are better specified
 1324   * Breaking: `Preconditions` is renamed to `ProtoPreconditions`
 1325   * Breaking: `GeneratedCodeInfo` is renamed to `GeneratedClrTypeInfo`
 1326   * `JsonFormatter` now allows writing to a `TextWriter`
 1327   * New interface, `ICustomDiagnosticMessage` to allow more compact
 1328     representations from `ToString`
 1329   * `CodedInputStream` and `CodedOutputStream` now implement `IDisposable`,
 1330     which simply disposes of the streams they were constructed with
 1331   * Map fields no longer support null values (in line with other languages)
 1332   * Improvements in JSON formatting and parsing
 1333 
 1334   Javascript (Alpha)
 1335   * Better support for "bytes" fields: bytes fields can be read as either a
 1336     base64 string or UInt8Array (in environments where TypedArray is supported).
 1337   * New support for CommonJS imports.  This should make it easier to use the
 1338     JavaScript support in Node.js and tools like WebPack.  See js/README.md for
 1339     more information.
 1340   * Some significant internal refactoring to simplify and modularize the code.
 1341 
 1342   Ruby (Alpha)
 1343   * JSON serialization now properly uses camelCased names, with a runtime option
 1344     that will preserve original names from .proto files instead.
 1345   * Well-known types are now included in the distribution.
 1346   * Release now includes binary gems for Windows, Mac, and Linux instead of just
 1347     source gems.
 1348   * Bugfix for serializing oneofs.
 1349 
 1350   C++/Java Lite (Alpha)
 1351     A new "lite" generator parameter was introduced in the protoc for C++ and
 1352     Java for Proto3 syntax messages. Example usage:
 1353 
 1354      ./protoc --cpp_out=lite:$OUTPUT_PATH foo.proto
 1355 
 1356     The protoc will treat the current input and all the transitive dependencies
 1357     as LITE. The same generator parameter must be used to generate the
 1358     dependencies.
 1359 
 1360     In Proto3 syntax files, "optimized_for=LITE_RUNTIME" is no longer supported.
 1361 
 1362 
 1363 2015-12-30 version 3.0.0-beta-2 (C++/Java/Python/Ruby/Nano/Objective-C/C#/JavaScript)
 1364   General
 1365   * Introduced a new language implementation: JavaScript.
 1366   * Added a new field option "json_name". By default proto field names are
 1367     converted to "lowerCamelCase" in proto3 JSON format. This option can be
 1368     used to override this behavior and specify a different JSON name for the
 1369     field.
 1370   * Added conformance tests to ensure implementations are following proto3 JSON
 1371     specification.
 1372 
 1373   C++ (Beta)
 1374   * Various bug fixes and improvements to the JSON support utility:
 1375       - Duplicate map keys in JSON are now rejected (i.e., translation will
 1376         fail).
 1377       - Fixed wire-format for google.protobuf.Value/ListValue.
 1378       - Fixed precision loss when converting google.protobuf.Timestamp.
 1379       - Fixed a bug when parsing invalid UTF-8 code points.
 1380       - Fixed a memory leak.
 1381       - Reduced call stack usage.
 1382 
 1383   Java (Beta)
 1384   * Cleaned up some unused methods on CodedOutputStream.
 1385   * Presized lists for packed fields during parsing in the lite runtime to
 1386     reduce allocations and improve performance.
 1387   * Improved the performance of unknown fields in the lite runtime.
 1388   * Introduced UnsafeByteStrings to support zero-copy ByteString creation.
 1389   * Various bug fixes and improvements to the JSON support utility:
 1390       - Fixed a thread-safety bug.
 1391       - Added a new option “preservingProtoFieldNames” to JsonFormat.
 1392       - Added a new option “includingDefaultValueFields” to JsonFormat.
 1393       - Updated the JSON utility to comply with proto3 JSON specification.
 1394 
 1395   Python (Beta)
 1396   * Added proto3 JSON format utility. It includes support for all field types
 1397     and a few well-known types except for Any and Struct.
 1398   * Added runtime support for Any, Timestamp, Duration and FieldMask.
 1399   * [ ] is now accepted for repeated scalar fields in text format parser.
 1400   * Map fields now have proper O(1) performance for lookup/insert/delete
 1401     when using the Python/C++ implementation. They were previously using O(n)
 1402     search-based algorithms because the C++ reflection interface didn't
 1403     support true map operations.
 1404 
 1405   Objective-C (Beta)
 1406   * Various bug-fixes and code tweaks to pass more strict compiler warnings.
 1407   * Now has conformance test coverage and is passing all tests.
 1408 
 1409   C# (Beta)
 1410   * Various bug-fixes.
 1411   * Code generation: Files generated in directories based on namespace.
 1412   * Code generation: Include comments from .proto files in XML doc
 1413     comments (naively)
 1414   * Code generation: Change organization/naming of "reflection class" (access
 1415     to file descriptor)
 1416   * Code generation and library: Add Parser property to MessageDescriptor,
 1417     and introduce a non-generic parser type.
 1418   * Library: Added TypeRegistry to support JSON parsing/formatting of Any.
 1419   * Library: Added Any.Pack/Unpack support.
 1420   * Library: Implemented JSON parsing.
 1421 
 1422   Javascript (Alpha)
 1423   * Added proto3 support for JavaScript. The runtime is written in pure
 1424     JavaScript and works in browsers and in Node.js. To generate JavaScript
 1425     code for your proto, invoke protoc with "--js_out". See js/README.md
 1426     for more build instructions.
 1427 
 1428 2015-08-26 version 3.0.0-beta-1 (C++/Java/Python/Ruby/Nano/Objective-C/C#)
 1429   About Beta
 1430   * This is the first beta release of protobuf v3.0.0. Not all languages
 1431     have reached beta stage. Languages not marked as beta are still in
 1432     alpha (i.e., be prepared for API breaking changes).
 1433 
 1434   General
 1435   * Proto3 JSON is supported in several languages (fully supported in C++
 1436     and Java, partially supported in Ruby/C#). The JSON spec is defined in
 1437     the proto3 language guide:
 1438 
 1439       https://developers.google.com/protocol-buffers/docs/proto3#json
 1440 
 1441     We will publish a more detailed spec to define the exact behavior of
 1442     proto3-conformant JSON serializers and parsers. Until then, do not rely
 1443     on specific behaviors of the implementation if it’s not documented in
 1444     the above spec. More specifically, the behavior is not yet finalized for
 1445     the following:
 1446       - Parsing invalid JSON input (e.g., input with trailing commas).
 1447       - Non-camelCase names in JSON input.
 1448       - The same field appears multiple times in JSON input.
 1449       - JSON arrays contain “null” values.
 1450       - The message has unknown fields.
 1451 
 1452   * Proto3 now enforces strict UTF-8 checking. Parsing will fail if a string
 1453     field contains non UTF-8 data.
 1454 
 1455   C++ (Beta)
 1456   * Introduced new utility functions/classes in the google/protobuf/util
 1457     directory:
 1458       - MessageDifferencer: compare two proto messages and report their
 1459                             differences.
 1460       - JsonUtil: support converting protobuf binary format to/from JSON.
 1461       - TimeUtil: utility functions to work with well-known types Timestamp
 1462                   and Duration.
 1463       - FieldMaskUtil: utility functions to work with FieldMask.
 1464 
 1465   * Performance optimization of arena construction and destruction.
 1466   * Bug fixes for arena and maps support.
 1467   * Changed to use cmake for Windows Visual Studio builds.
 1468   * Added Bazel support.
 1469 
 1470   Java (Beta)
 1471   * Introduced a new util package that will be distributed as a separate
 1472     artifact in maven. It contains:
 1473       - JsonFormat: convert proto messages to/from JSON.
 1474       - TimeUtil: utility functions to work with Timestamp and Duration.
 1475       - FieldMaskUtil: utility functions to work with FieldMask.
 1476 
 1477   * The static PARSER in each generated message is deprecated, and it will
 1478     be removed in a future release. A static parser() getter is generated
 1479     for each message type instead.
 1480   * Performance optimizations for String fields serialization.
 1481   * Performance optimizations for Lite runtime on Android:
 1482       - Reduced allocations
 1483       - Reduced method overhead after ProGuarding
 1484       - Reduced code size after ProGuarding
 1485 
 1486   Python (Alpha)
 1487   * Removed legacy Python 2.5 support.
 1488   * Moved to a single Python 2.x/3.x-compatible codebase, instead of using 2to3.
 1489   * Fixed build/tests on Python 2.6, 2.7, 3.3, and 3.4.
 1490       - Pure-Python works on all four.
 1491       - Python/C++ implementation works on all but 3.4, due to changes in the
 1492         Python/C++ API in 3.4.
 1493   * Some preliminary work has been done to allow for multiple DescriptorPools
 1494     with Python/C++.
 1495 
 1496   Ruby (Alpha)
 1497   * Many bugfixes:
 1498       - fixed parsing/serialization of bytes, sint, sfixed types
 1499       - other parser bugfixes
 1500       - fixed memory leak affecting Ruby 2.2
 1501 
 1502   JavaNano (Alpha)
 1503   * JavaNano generated code now will be put in a nano package by default to
 1504     avoid conflicts with Java generated code.
 1505 
 1506   Objective-C (Alpha)
 1507   * Added non-null markup to ObjC library. Requires SDK 8.4+ to build.
 1508   * Many bugfixes:
 1509       - Removed the class/enum filter.
 1510       - Renamed some internal types to avoid conflicts with the well-known types
 1511         protos.
 1512       - Added missing support for parsing repeated primitive fields in packed or
 1513         unpacked forms.
 1514       - Added *Count for repeated and map<> fields to avoid auto-create when
 1515         checking for them being set.
 1516 
 1517   C# (Alpha)
 1518   * Namespace changed to Google.Protobuf (and NuGet package will be named
 1519     correspondingly).
 1520   * Target platforms now .NET 4.5 and selected portable subsets only.
 1521   * Removed lite runtime.
 1522   * Reimplementation to use mutable message types.
 1523   * Null references used to represent "no value" for message type fields.
 1524   * Proto3 semantics supported; proto2 files are prohibited for C# codegen.
 1525     Most proto3 features supported:
 1526       - JSON formatting (a.k.a. serialization to JSON), including well-known
 1527         types (except for Any).
 1528       - Wrapper types mapped to nullable value types (or string/ByteString
 1529         allowing nullability). JSON parsing is not supported yet.
 1530       - maps
 1531       - oneof
 1532       - enum unknown value preservation
 1533 
 1534 2015-05-25 version 3.0.0-alpha-3 (Objective-C/C#):
 1535   General
 1536   * Introduced two new language implementations (Objective-C, C#) to proto3.
 1537   * Explicit "optional" keyword are disallowed in proto3 syntax, as fields are
 1538     optional by default.
 1539   * Group fields are no longer supported in proto3 syntax.
 1540   * Changed repeated primitive fields to use packed serialization by default in
 1541     proto3 (implemented for C++, Java, Python in this release).  The user can
 1542     still disable packed serialization by setting packed to false for now.
 1543   * Added well-known type protos (any.proto, empty.proto, timestamp.proto,
 1544     duration.proto, etc.). Users can import and use these protos just like
 1545     regular proto files. Additional runtime support will be added for them in
 1546     future releases (in the form of utility helper functions, or having them
 1547     replaced by language specific types in generated code).
 1548   * Added a "reserved" keyword in both proto2 and proto3 syntax. User can use
 1549     this keyword to declare reserved field numbers and names to prevent them
 1550     from being reused by other fields in the same message.
 1551 
 1552     To reserve field numbers, add a reserved declaration in your message:
 1553 
 1554       message TestMessage {
 1555         reserved 2, 15, 9 to 11, 3;
 1556       }
 1557 
 1558     This reserves field numbers 2, 3, 9, 10, 11 and 15. If a user uses any of
 1559     these as field numbers, the protocol buffer compiler will report an error.
 1560 
 1561     Field names can also be reserved:
 1562 
 1563       message TestMessage {
 1564         reserved "foo", "bar";
 1565       }
 1566 
 1567   * Various bug fixes since 3.0.0-alpha-2
 1568 
 1569   Objective-C
 1570     Objective-C includes a code generator and a native objective-c runtime
 1571     library.  By adding “--objc_out” to protoc, the code generator will generate
 1572     a header(*.pbobjc.h) and an implementation file(*.pbobjc.m) for each proto
 1573     file.
 1574 
 1575     In this first release, the generated interface provides: enums, messages,
 1576     field support(single, repeated, map, oneof), proto2 and proto3 syntax
 1577     support, parsing and serialization. It’s  compatible with ARC and non-ARC
 1578     usage. Besides, user can also access it via the swift bridging header.
 1579 
 1580     See objectivec/README.md for details.
 1581 
 1582   C#
 1583     * C# protobufs are based on project
 1584       https://github.com/jskeet/protobuf-csharp-port. The original project was
 1585       frozen and all the new development will happen here.
 1586     * Codegen plugin for C# was completely rewritten to C++ and is now an
 1587       integral part of protoc.
 1588     * Some refactorings and cleanup has been applied to the C# runtime library.
 1589     * Only proto2 is supported in C# at the moment, proto3 support is in
 1590       progress and will likely bring significant breaking changes to the API.
 1591 
 1592     See csharp/README.md for details.
 1593 
 1594   C++
 1595     * Added runtime support for Any type. To use Any in your proto file, first
 1596       import the definition of Any:
 1597 
 1598         // foo.proto
 1599         import "google/protobuf/any.proto";
 1600         message Foo {
 1601           google.protobuf.Any any_field = 1;
 1602         }
 1603         message Bar {
 1604           int32 value = 1;
 1605         }
 1606 
 1607       Then in C++ you can access the Any field using PackFrom()/UnpackTo()
 1608       methods:
 1609 
 1610         Foo foo;
 1611         Bar bar = ...;
 1612         foo.mutable_any_field()->PackFrom(bar);
 1613         ...
 1614         if (foo.any_field().IsType<Bar>()) {
 1615           foo.any_field().UnpackTo(&bar);
 1616           ...
 1617         }
 1618     * In text format, entries of a map field will be sorted by key.
 1619 
 1620   Java
 1621     * Continued optimizations on the lite runtime to improve performance for
 1622       Android.
 1623 
 1624   Python
 1625     * Added map support.
 1626       - maps now have a dict-like interface (msg.map_field[key] = value)
 1627       - existing code that modifies maps via the repeated field interface
 1628         will need to be updated.
 1629 
 1630   Ruby
 1631     * Improvements to RepeatedField's emulation of the Ruby Array API.
 1632     * Various speedups and internal cleanups.
 1633 
 1634 2015-02-26 version 3.0.0-alpha-2 (Python/Ruby/JavaNano):
 1635   General
 1636   * Introduced three new language implementations (Ruby, JavaNano, and
 1637     Python) to proto3.
 1638   * Various bug fixes since 3.0.0-alpha-1
 1639 
 1640   Python:
 1641     Python has received several updates, most notably support for proto3
 1642     semantics in any .proto file that declares syntax="proto3".
 1643     Messages declared in proto3 files no longer represent field presence
 1644     for scalar fields (number, enums, booleans, or strings).  You can
 1645     no longer call HasField() for such fields, and they are serialized
 1646     based on whether they have a non-zero/empty/false value.
 1647 
 1648     One other notable change is in the C++-accelerated implementation.
 1649     Descriptor objects (which describe the protobuf schema and allow
 1650     reflection over it) are no longer duplicated between the Python
 1651     and C++ layers.  The Python descriptors are now simple wrappers
 1652     around the C++ descriptors.  This change should significantly
 1653     reduce the memory usage of programs that use a lot of message
 1654     types.
 1655 
 1656   Ruby:
 1657     We have added proto3 support for Ruby via a native C extension.
 1658 
 1659     The Ruby extension itself is included in the ruby/ directory, and details on
 1660     building and installing the extension are in ruby/README.md. The extension
 1661     will also be published as a Ruby gem. Code generator support is included as
 1662     part of `protoc` with the `--ruby_out` flag.
 1663 
 1664     The Ruby extension implements a user-friendly DSL to define message types
 1665     (also generated by the code generator from `.proto` files).  Once a message
 1666     type is defined, the user may create instances of the message that behave in
 1667     ways idiomatic to Ruby. For example:
 1668 
 1669     - Message fields are present as ordinary Ruby properties (getter method
 1670       `foo` and setter method `foo=`).
 1671     - Repeated field elements are stored in a container that acts like a native
 1672       Ruby array, and map elements are stored in a container that acts like a
 1673       native Ruby hashmap.
 1674     - The usual well-known methods, such as `#to_s`, `#dup`, and the like, are
 1675       present.
 1676 
 1677     Unlike several existing third-party Ruby extensions for protobuf, this
 1678     extension is built on a "strongly-typed" philosophy: message fields and
 1679     array/map containers will throw exceptions eagerly when values of the
 1680     incorrect type are inserted.
 1681 
 1682     See ruby/README.md for details.
 1683 
 1684   JavaNano:
 1685     JavaNano is a special code generator and runtime library designed especially
 1686     for resource-restricted systems, like Android. It is very resource-friendly
 1687     in both the amount of code and the runtime overhead. Here is an an overview
 1688     of JavaNano features compared with the official Java protobuf:
 1689 
 1690     - No descriptors or message builders.
 1691     - All messages are mutable; fields are public Java fields.
 1692     - For optional fields only, encapsulation behind setter/getter/hazzer/
 1693       clearer functions is opt-in, which provide proper 'has' state support.
 1694     - For proto2, if not opted in, has state (field presence) is not available.
 1695       Serialization outputs all fields not equal to their defaults.
 1696       The behavior is consistent with proto3 semantics.
 1697     - Required fields (proto2 only) are always serialized.
 1698     - Enum constants are integers; protection against invalid values only
 1699       when parsing from the wire.
 1700     - Enum constants can be generated into container interfaces bearing
 1701       the enum's name (so the referencing code is in Java style).
 1702     - CodedInputByteBufferNano can only take byte[] (not InputStream).
 1703     - Similarly CodedOutputByteBufferNano can only write to byte[].
 1704     - Repeated fields are in arrays, not ArrayList or Vector. Null array
 1705       elements are allowed and silently ignored.
 1706     - Full support for serializing/deserializing repeated packed fields.
 1707     - Support  extensions (in proto2).
 1708     - Unset messages/groups are null, not an immutable empty default
 1709       instance.
 1710     - toByteArray(...) and mergeFrom(...) are now static functions of
 1711       MessageNano.
 1712     - The 'bytes' type translates to the Java type byte[].
 1713 
 1714     See javanano/README.txt for details.
 1715 
 1716 2014-12-01 version 3.0.0-alpha-1 (C++/Java):
 1717 
 1718   General
 1719   * Introduced Protocol Buffers language version 3 (aka proto3).
 1720 
 1721     When protobuf was initially opensourced it implemented Protocol Buffers
 1722     language version 2 (aka proto2), which is why the version number
 1723     started from v2.0.0. From v3.0.0, a new language version (proto3) is
 1724     introduced while the old version (proto2) will continue to be supported.
 1725 
 1726     The main intent of introducing proto3 is to clean up protobuf before
 1727     pushing the language as the foundation of Google's new API platform.
 1728     In proto3, the language is simplified, both for ease of use and  to
 1729     make it available in a wider range of programming languages. At the
 1730     same time a few features are added to better support common idioms
 1731     found in APIs.
 1732 
 1733     The following are the main new features in language version 3:
 1734 
 1735       1. Removal of field presence logic for primitive value fields, removal
 1736          of required fields, and removal of default values. This makes proto3
 1737          significantly easier to implement with open struct representations,
 1738          as in languages like Android Java, Objective C, or Go.
 1739       2. Removal of unknown fields.
 1740       3. Removal of extensions, which are instead replaced by a new standard
 1741          type called Any.
 1742       4. Fix semantics for unknown enum values.
 1743       5. Addition of maps.
 1744       6. Addition of a small set of standard types for representation of time,
 1745          dynamic data, etc.
 1746       7. A well-defined encoding in JSON as an alternative to binary proto
 1747          encoding.
 1748 
 1749     This release (v3.0.0-alpha-1) includes partial proto3 support for C++ and
 1750     Java. Items 6 (well-known types) and 7 (JSON format) in the above feature
 1751     list are not implemented.
 1752 
 1753     A new notion "syntax" is introduced to specify whether a .proto file
 1754     uses proto2 or proto3:
 1755 
 1756       // foo.proto
 1757       syntax = "proto3";
 1758       message Bar {...}
 1759 
 1760     If omitted, the protocol compiler will generate a warning and "proto2" will
 1761     be used as the default. This warning will be turned into an error in a
 1762     future release.
 1763 
 1764     We recommend that new Protocol Buffers users use proto3. However, we do not
 1765     generally recommend that existing users migrate from proto2 from proto3 due
 1766     to API incompatibility, and we will continue to support proto2 for a long
 1767     time.
 1768 
 1769   * Added support for map fields (implemented in C++/Java for both proto2 and
 1770     proto3).
 1771 
 1772     Map fields can be declared using the following syntax:
 1773 
 1774       message Foo {
 1775         map<string, string> values = 1;
 1776       }
 1777 
 1778     Data of a map field will be stored in memory as an unordered map and it
 1779     can be accessed through generated accessors.
 1780 
 1781   C++
 1782   * Added arena allocation support (for both proto2 and proto3).
 1783 
 1784     Profiling shows memory allocation and deallocation constitutes a significant
 1785     fraction of CPU-time spent in protobuf code and arena allocation is a
 1786     technique introduced to reduce this cost. With arena allocation, new
 1787     objects will be allocated from a large piece of preallocated memory and
 1788     deallocation of these objects is almost free. Early adoption shows 20% to
 1789     50% improvement in some Google binaries.
 1790 
 1791     To enable arena support, add the following option to your .proto file:
 1792 
 1793       option cc_enable_arenas = true;
 1794 
 1795     Protocol compiler will generate additional code to make the generated
 1796     message classes work with arenas. This does not change the existing API
 1797     of protobuf messages and does not affect wire format. Your existing code
 1798     should continue to work after adding this option. In the future we will
 1799     make this option enabled by default.
 1800 
 1801     To actually take advantage of arena allocation, you need to use the arena
 1802     APIs when creating messages. A quick example of using the arena API:
 1803 
 1804       {
 1805         google::protobuf::Arena arena;
 1806         // Allocate a protobuf message in the arena.
 1807         MyMessage* message = Arena::CreateMessage<MyMessage>(&arena);
 1808         // All submessages will be allocated in the same arena.
 1809         if (!message->ParseFromString(data)) {
 1810           // Deal with malformed input data.
 1811         }
 1812         // Must not delete the message here. It will be deleted automatically
 1813         // when the arena is destroyed.
 1814       }
 1815 
 1816     Currently arena does not work with map fields. Enabling arena in a .proto
 1817     file containing map fields will result in compile errors in the generated
 1818     code. This will be addressed in a future release.
 1819 
 1820 2014-10-20 version 2.6.1:
 1821 
 1822   C++
 1823   * Added atomicops support for Solaris.
 1824   * Released memory allocated by InitializeDefaultRepeatedFields() and
 1825     GetEmptyString(). Some memory sanitizers reported them as memory leaks.
 1826 
 1827   Java
 1828   * Updated DynamicMessage.setField() to handle repeated enum values
 1829     correctly.
 1830   * Fixed a bug that caused NullPointerException to be thrown when
 1831     converting manually constructed FileDescriptorProto to
 1832     FileDescriptor.
 1833 
 1834   Python
 1835   * Fixed WhichOneof() to work with de-serialized protobuf messages.
 1836   * Fixed a missing file problem of Python C++ implementation.
 1837 
 1838 2014-08-15 version 2.6.0:
 1839 
 1840   General
 1841   * Added oneofs(unions) feature. Fields in the same oneof will share
 1842     memory and at most one field can be set at the same time. Use the
 1843     oneof keyword to define a oneof like:
 1844       message SampleMessage {
 1845         oneof test_oneof {
 1846           string name = 4;
 1847           YourMessage sub_message = 9;
 1848         }
 1849       }
 1850   * Files, services, enums, messages, methods and enum values can be marked
 1851     as deprecated now.
 1852   * Added Support for list values, including lists of messages, when
 1853     parsing text-formatted protos in C++ and Java.
 1854       For example:  foo: [1, 2, 3]
 1855 
 1856   C++
 1857   * Enhanced customization on TestFormat printing.
 1858   * Added SwapFields() in reflection API to swap a subset of fields.
 1859     Added SetAllocatedMessage() in reflection API.
 1860   * Repeated primitive extensions are now packable. The
 1861     [packed=true] option only affects serializers. Therefore, it is
 1862     possible to switch a repeated extension field to packed format
 1863     without breaking backwards-compatibility.
 1864   * Various speed optimizations.
 1865 
 1866   Java
 1867   * writeTo() method in ByteString can now write a substring to an
 1868     output stream. Added endWith() method for ByteString.
 1869   * ByteString and ByteBuffer are now supported in CodedInputStream
 1870     and CodedOutputStream.
 1871   * java_generate_equals_and_hash can now be used with the LITE_RUNTIME.
 1872 
 1873   Python
 1874   * A new C++-backed extension module (aka "cpp api v2") that replaces the
 1875     old ("cpp api v1") one.  Much faster than the pure Python code.  This one
 1876     resolves many bugs and is recommended for general use over the
 1877     pure Python when possible.
 1878   * Descriptors now have enum_types_by_name and extension_types_by_name dict
 1879     attributes.
 1880   * Support for Python 3.
 1881 
 1882 2013-02-27 version 2.5.0:
 1883 
 1884   General
 1885   * New notion "import public" that allows a proto file to forward the content
 1886     it imports to its importers. For example,
 1887       // foo.proto
 1888       import public "bar.proto";
 1889       import "baz.proto";
 1890 
 1891       // qux.proto
 1892       import "foo.proto";
 1893       // Stuff defined in bar.proto may be used in this file, but stuff from
 1894       // baz.proto may NOT be used without importing it explicitly.
 1895     This is useful for moving proto files. To move a proto file, just leave
 1896     a single "import public" in the old proto file.
 1897   * New enum option "allow_alias" that specifies whether different symbols can
 1898     be assigned the same numeric value. Default value is "true". Setting it to
 1899     false causes the compiler to reject enum definitions where multiple symbols
 1900     have the same numeric value.
 1901     Note: We plan to flip the default value to "false" in a future release.
 1902     Projects using enum aliases should set the option to "true" in their .proto
 1903     files.
 1904 
 1905   C++
 1906   * New generated method set_allocated_foo(Type* foo) for message and string
 1907     fields. This method allows you to set the field to a pre-allocated object
 1908     and the containing message takes the ownership of that object.
 1909   * Added SetAllocatedExtension() and ReleaseExtension() to extensions API.
 1910   * Custom options are now formatted correctly when descriptors are printed in
 1911     text format.
 1912   * Various speed optimizations.
 1913 
 1914   Java
 1915   * Comments in proto files are now collected and put into generated code as
 1916     comments for corresponding classes and data members.
 1917   * Added Parser to parse directly into messages without a Builder. For
 1918     example,
 1919       Foo foo = Foo.PARSER.ParseFrom(input);
 1920     Using Parser is ~25% faster than using Builder to parse messages.
 1921   * Added getters/setters to access the underlying ByteString of a string field
 1922     directly.
 1923   * ByteString now supports more operations: substring(), prepend(), and
 1924     append(). The implementation of ByteString uses a binary tree structure
 1925     to support these operations efficiently.
 1926   * New method findInitializationErrors() that lists all missing required
 1927     fields.
 1928   * Various code size and speed optimizations.
 1929 
 1930   Python
 1931   * Added support for dynamic message creation. DescriptorDatabase,
 1932     DescriptorPool, and MessageFactory work like their C++ counterparts to
 1933     simplify Descriptor construction from *DescriptorProtos, and MessageFactory
 1934     provides a message instance from a Descriptor.
 1935   * Added pickle support for protobuf messages.
 1936   * Unknown fields are now preserved after parsing.
 1937   * Fixed bug where custom options were not correctly populated. Custom
 1938     options can be accessed now.
 1939   * Added EnumTypeWrapper that provides better accessibility to enum types.
 1940   * Added ParseMessage(descriptor, bytes) to generate a new Message instance
 1941     from a descriptor and a byte string.
 1942 
 1943 2011-05-01 version 2.4.1:
 1944 
 1945   C++
 1946   * Fixed the friendship problem for old compilers to make the library now gcc 3
 1947     compatible again.
 1948   * Fixed vcprojects/extract_includes.bat to extract compiler/plugin.h.
 1949 
 1950   Java
 1951   * Removed usages of JDK 1.6 only features to make the library now JDK 1.5
 1952     compatible again.
 1953   * Fixed a bug about negative enum values.
 1954   * serialVersionUID is now defined in generated messages for java serializing.
 1955   * Fixed protoc to use java.lang.Object, which makes "Object" now a valid
 1956     message name again.
 1957 
 1958   Python
 1959   * Experimental C++ implementation now requires C++ protobuf library installed.
 1960     See the README.txt in the python directory for details.
 1961 
 1962 2011-02-02 version 2.4.0:
 1963 
 1964   General
 1965   * The RPC (cc|java|py)_generic_services default value is now false instead of
 1966     true.
 1967   * Custom options can have aggregate types. For example,
 1968       message MyOption {
 1969         optional string comment = 1;
 1970         optional string author = 2;
 1971       }
 1972       extend google.protobuf.FieldOptions {
 1973         optional MyOption myoption = 12345;
 1974       }
 1975     This option can now be set as follows:
 1976       message SomeType {
 1977         optional int32 field = 1 [(myoption) = { comment:'x' author:'y' }];
 1978       }
 1979 
 1980   C++
 1981   * Various speed and code size optimizations.
 1982   * Added a release_foo() method on string and message fields.
 1983   * Fixed gzip_output_stream sub-stream handling.
 1984 
 1985   Java
 1986   * Builders now maintain sub-builders for sub-messages. Use getFooBuilder() to
 1987     get the builder for the sub-message "foo". This allows you to repeatedly
 1988     modify deeply-nested sub-messages without rebuilding them.
 1989   * Builder.build() no longer invalidates the Builder for generated messages
 1990     (You may continue to modify it and then build another message).
 1991   * Code generator will generate efficient equals() and hashCode()
 1992     implementations if new option java_generate_equals_and_hash is enabled.
 1993     (Otherwise, reflection-based implementations are used.)
 1994   * Generated messages now implement Serializable.
 1995   * Fields with [deprecated=true] will be marked with @Deprecated in Java.
 1996   * Added lazy conversion of UTF-8 encoded strings to String objects to improve
 1997     performance.
 1998   * Various optimizations.
 1999   * Enum value can be accessed directly, instead of calling getNumber() on the
 2000     enum member.
 2001   * For each enum value, an integer constant is also generated with the suffix
 2002     _VALUE.
 2003 
 2004   Python
 2005   * Added an experimental  C++ implementation for Python messages via a Python
 2006     extension. Implementation type is controlled by an environment variable
 2007     PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION (valid values: "cpp" and "python")
 2008     The default value is currently "python" but will be changed to "cpp" in
 2009     future release.
 2010   * Improved performance on message instantiation significantly.
 2011     Most of the work on message instantiation is done just once per message
 2012     class, instead of once per message instance.
 2013   * Improved performance on text message parsing.
 2014   * Allow add() to forward keyword arguments to the concrete class.
 2015       E.g. instead of
 2016         item = repeated_field.add()
 2017         item.foo = bar
 2018         item.baz = quux
 2019       You can do:
 2020         repeated_field.add(foo=bar, baz=quux)
 2021   * Added a sort() interface to the BaseContainer.
 2022   * Added an extend() method to repeated composite fields.
 2023   * Added UTF8 debug string support.
 2024 
 2025 2010-01-08 version 2.3.0:
 2026 
 2027   General
 2028   * Parsers for repeated numeric fields now always accept both packed and
 2029     unpacked input.  The [packed=true] option only affects serializers.
 2030     Therefore, it is possible to switch a field to packed format without
 2031     breaking backwards-compatibility -- as long as all parties are using
 2032     protobuf 2.3.0 or above, at least.
 2033   * The generic RPC service code generated by the C++, Java, and Python
 2034     generators can be disabled via file options:
 2035       option cc_generic_services = false;
 2036       option java_generic_services = false;
 2037       option py_generic_services = false;
 2038     This allows plugins to generate alternative code, possibly specific to some
 2039     particular RPC implementation.
 2040 
 2041   protoc
 2042   * Now supports a plugin system for code generators.  Plugins can generate
 2043     code for new languages or inject additional code into the output of other
 2044     code generators.  Plugins are just binaries which accept a protocol buffer
 2045     on stdin and write a protocol buffer to stdout, so they may be written in
 2046     any language.  See src/google/protobuf/compiler/plugin.proto.
 2047     **WARNING**:  Plugins are experimental.  The interface may change in a
 2048     future version.
 2049   * If the output location ends in .zip or .jar, protoc will write its output
 2050     to a zip/jar archive instead of a directory.  For example:
 2051       protoc --java_out=myproto_srcs.jar --python_out=myproto.zip myproto.proto
 2052     Currently the archive contents are not compressed, though this could change
 2053     in the future.
 2054   * inf, -inf, and nan can now be used as default values for float and double
 2055     fields.
 2056 
 2057   C++
 2058   * Various speed and code size optimizations.
 2059   * DynamicMessageFactory is now fully thread-safe.
 2060   * Message::Utf8DebugString() method is like DebugString() but avoids escaping
 2061     UTF-8 bytes.
 2062   * Compiled-in message types can now contain dynamic extensions, through use
 2063     of CodedInputStream::SetExtensionRegistry().
 2064   * Now compiles shared libraries (DLLs) by default on Cygwin and MinGW, to
 2065     match other platforms.  Use --disable-shared to avoid this.
 2066 
 2067   Java
 2068   * parseDelimitedFrom() and mergeDelimitedFrom() now detect EOF and return
 2069     false/null instead of throwing an exception.
 2070   * Fixed some initialization ordering bugs.
 2071   * Fixes for OpenJDK 7.
 2072 
 2073   Python
 2074   * 10-25 times faster than 2.2.0, still pure-Python.
 2075   * Calling a mutating method on a sub-message always instantiates the message
 2076     in its parent even if the mutating method doesn't actually mutate anything
 2077     (e.g. parsing from an empty string).
 2078   * Expanded descriptors a bit.
 2079 
 2080 2009-08-11 version 2.2.0:
 2081 
 2082   C++
 2083   * Lite mode:  The "optimize_for = LITE_RUNTIME" option causes the compiler
 2084     to generate code which only depends libprotobuf-lite, which is much smaller
 2085     than libprotobuf but lacks descriptors, reflection, and some other features.
 2086   * Fixed bug where Message.Swap(Message) was only implemented for
 2087     optimize_for_speed.  Swap now properly implemented in both modes
 2088     (Issue 91).
 2089   * Added RemoveLast and SwapElements(index1, index2) to Reflection
 2090     interface for repeated elements.
 2091   * Added Swap(Message) to Reflection interface.
 2092   * Floating-point literals in generated code that are intended to be
 2093     single-precision now explicitly have 'f' suffix to avoid pedantic warnings
 2094     produced by some compilers.
 2095   * The [deprecated=true] option now causes the C++ code generator to generate
 2096     a GCC-style deprecation annotation (no-op on other compilers).
 2097   * google::protobuf::GetEnumDescriptor<SomeGeneratedEnumType>() returns the
 2098     EnumDescriptor for that type -- useful for templates which cannot call
 2099     SomeGeneratedEnumType_descriptor().
 2100   * Various optimizations and obscure bug fixes.
 2101 
 2102   Java
 2103   * Lite mode:  The "optimize_for = LITE_RUNTIME" option causes the compiler
 2104     to generate code which only depends libprotobuf-lite, which is much smaller
 2105     than libprotobuf but lacks descriptors, reflection, and some other features.
 2106   * Lots of style cleanups.
 2107 
 2108   Python
 2109   * Fixed endianness bug with floats and doubles.
 2110   * Text format parsing support.
 2111   * Fix bug with parsing packed repeated fields in embedded messages.
 2112   * Ability to initialize fields by passing keyword args to constructor.
 2113   * Support iterators in extend and __setslice__ for containers.
 2114 
 2115 2009-05-13 version 2.1.0:
 2116 
 2117   General
 2118   * Repeated fields of primitive types (types other that string, group, and
 2119     nested messages) may now use the option [packed = true] to get a more
 2120     efficient encoding.  In the new encoding, the entire list is written
 2121     as a single byte blob using the "length-delimited" wire type.  Within
 2122     this blob, the individual values are encoded the same way they would
 2123     be normally except without a tag before each value (thus, they are
 2124     tightly "packed").
 2125   * For each field, the generated code contains an integer constant assigned
 2126     to the field number.  For example, the .proto file:
 2127       message Foo { optional int bar_baz = 123; }
 2128     would generate the following constants, all with the integer value 123:
 2129       C++:     Foo::kBarBazFieldNumber
 2130       Java:    Foo.BAR_BAZ_FIELD_NUMBER
 2131       Python:  Foo.BAR_BAZ_FIELD_NUMBER
 2132     Constants are also generated for extensions, with the same naming scheme.
 2133     These constants may be used as switch cases.
 2134   * Updated bundled Google Test to version 1.3.0.  Google Test is now bundled
 2135     in its verbatim form as a nested autoconf package, so you can drop in any
 2136     other version of Google Test if needed.
 2137   * optimize_for = SPEED is now the default, by popular demand.  Use
 2138     optimize_for = CODE_SIZE if code size is more important in your app.
 2139   * It is now an error to define a default value for a repeated field.
 2140     Previously, this was silently ignored (it had no effect on the generated
 2141     code).
 2142   * Fields can now be marked deprecated like:
 2143       optional int32 foo = 1 [deprecated = true];
 2144     Currently this does not have any actual effect, but in the future the code
 2145     generators may generate deprecation annotations in each language.
 2146   * Cross-compiling should now be possible using the --with-protoc option to
 2147     configure.  See README.txt for more info.
 2148 
 2149   protoc
 2150   * --error_format=msvs option causes errors to be printed in Visual Studio
 2151     format, which should allow them to be clicked on in the build log to go
 2152     directly to the error location.
 2153   * The type name resolver will no longer resolve type names to fields.  For
 2154     example, this now works:
 2155       message Foo {}
 2156       message Bar {
 2157         optional int32 Foo = 1;
 2158         optional Foo baz = 2;
 2159       }
 2160     Previously, the type of "baz" would resolve to "Bar.Foo", and you'd get
 2161     an error because Bar.Foo is a field, not a type.  Now the type of "baz"
 2162     resolves to the message type Foo.  This change is unlikely to make a
 2163     difference to anyone who follows the Protocol Buffers style guide.
 2164 
 2165   C++
 2166   * Several optimizations, including but not limited to:
 2167     - Serialization, especially to flat arrays, is 10%-50% faster, possibly
 2168       more for small objects.
 2169     - Several descriptor operations which previously required locking no longer
 2170       do.
 2171     - Descriptors are now constructed lazily on first use, rather than at
 2172       process startup time.  This should save memory in programs which do not
 2173       use descriptors or reflection.
 2174     - UnknownFieldSet completely redesigned to be more efficient (especially in
 2175       terms of memory usage).
 2176     - Various optimizations to reduce code size (though the serialization speed
 2177       optimizations increased code size).
 2178   * Message interface has method ParseFromBoundedZeroCopyStream() which parses
 2179     a limited number of bytes from an input stream rather than parsing until
 2180     EOF.
 2181   * GzipInputStream and GzipOutputStream support reading/writing gzip- or
 2182     zlib-compressed streams if zlib is available.
 2183     (google/protobuf/io/gzip_stream.h)
 2184   * DescriptorPool::FindAllExtensions() and corresponding
 2185     DescriptorDatabase::FindAllExtensions() can be used to enumerate all
 2186     extensions of a given type.
 2187   * For each enum type Foo, protoc will generate functions:
 2188       const string& Foo_Name(Foo value);
 2189       bool Foo_Parse(const string& name, Foo* result);
 2190     The former returns the name of the enum constant corresponding to the given
 2191     value while the latter finds the value corresponding to a name.
 2192   * RepeatedField and RepeatedPtrField now have back-insertion iterators.
 2193   * String fields now have setters that take a char* and a size, in addition
 2194     to the existing ones that took char* or const string&.
 2195   * DescriptorPool::AllowUnknownDependencies() may be used to tell
 2196     DescriptorPool to create placeholder descriptors for unknown entities
 2197     referenced in a FileDescriptorProto.  This can allow you to parse a .proto
 2198     file without having access to other .proto files that it imports, for
 2199     example.
 2200   * Updated gtest to latest version.  The gtest package is now included as a
 2201     nested autoconf package, so it should be able to drop new versions into the
 2202     "gtest" subdirectory without modification.
 2203 
 2204   Java
 2205   * Fixed bug where Message.mergeFrom(Message) failed to merge extensions.
 2206   * Message interface has new method toBuilder() which is equivalent to
 2207     newBuilderForType().mergeFrom(this).
 2208   * All enums now implement the ProtocolMessageEnum interface.
 2209   * Setting a field to null now throws NullPointerException.
 2210   * Fixed tendency for TextFormat's parsing to overflow the stack when
 2211     parsing large string values.  The underlying problem is with Java's
 2212     regex implementation (which unfortunately uses recursive backtracking
 2213     rather than building an NFA).  Worked around by making use of possessive
 2214     quantifiers.
 2215   * Generated service classes now also generate pure interfaces.  For a service
 2216     Foo, Foo.Interface is a pure interface containing all of the service's
 2217     defined methods.  Foo.newReflectiveService() can be called to wrap an
 2218     instance of this interface in a class that implements the generic
 2219     RpcService interface, which provides reflection support that is usually
 2220     needed by RPC server implementations.
 2221   * RPC interfaces now support blocking operation in addition to non-blocking.
 2222     The protocol compiler generates separate blocking and non-blocking stubs
 2223     which operate against separate blocking and non-blocking RPC interfaces.
 2224     RPC implementations will have to implement the new interfaces in order to
 2225     support blocking mode.
 2226   * New I/O methods parseDelimitedFrom(), mergeDelimitedFrom(), and
 2227     writeDelimitedTo() read and write "delimited" messages from/to a stream,
 2228     meaning that the message size precedes the data.  This way, you can write
 2229     multiple messages to a stream without having to worry about delimiting
 2230     them yourself.
 2231   * Throw a more descriptive exception when build() is double-called.
 2232   * Add a method to query whether CodedInputStream is at the end of the input
 2233     stream.
 2234   * Add a method to reset a CodedInputStream's size counter; useful when
 2235     reading many messages with the same stream.
 2236   * equals() and hashCode() now account for unknown fields.
 2237 
 2238   Python
 2239   * Added slicing support for repeated scalar fields. Added slice retrieval and
 2240     removal of repeated composite fields.
 2241   * Updated RPC interfaces to allow for blocking operation.  A client may
 2242     now pass None for a callback when making an RPC, in which case the
 2243     call will block until the response is received, and the response
 2244     object will be returned directly to the caller.  This interface change
 2245     cannot be used in practice until RPC implementations are updated to
 2246     implement it.
 2247   * Changes to input_stream.py should make protobuf compatible with appengine.
 2248 
 2249 2008-11-25 version 2.0.3:
 2250 
 2251   protoc
 2252   * Enum values may now have custom options, using syntax similar to field
 2253     options.
 2254   * Fixed bug where .proto files which use custom options but don't actually
 2255     define them (i.e. they import another .proto file defining the options)
 2256     had to explicitly import descriptor.proto.
 2257   * Adjacent string literals in .proto files will now be concatenated, like in
 2258     C.
 2259   * If an input file is a Windows absolute path (e.g. "C:\foo\bar.proto") and
 2260     the import path only contains "." (or contains "." but does not contain
 2261     the file), protoc incorrectly thought that the file was under ".", because
 2262     it thought that the path was relative (since it didn't start with a slash).
 2263     This has been fixed.
 2264 
 2265   C++
 2266   * Generated message classes now have a Swap() method which efficiently swaps
 2267     the contents of two objects.
 2268   * All message classes now have a SpaceUsed() method which returns an estimate
 2269     of the number of bytes of allocated memory currently owned by the object.
 2270     This is particularly useful when you are reusing a single message object
 2271     to improve performance but want to make sure it doesn't bloat up too large.
 2272   * New method Message::SerializeAsString() returns a string containing the
 2273     serialized data.  May be more convenient than calling
 2274     SerializeToString(string*).
 2275   * In debug mode, log error messages when string-type fields are found to
 2276     contain bytes that are not valid UTF-8.
 2277   * Fixed bug where a message with multiple extension ranges couldn't parse
 2278     extensions.
 2279   * Fixed bug where MergeFrom(const Message&) didn't do anything if invoked on
 2280     a message that contained no fields (but possibly contained extensions).
 2281   * Fixed ShortDebugString() to not be O(n^2).  Durr.
 2282   * Fixed crash in TextFormat parsing if the first token in the input caused a
 2283     tokenization error.
 2284   * Fixed obscure bugs in zero_copy_stream_impl.cc.
 2285   * Added support for HP C++ on Tru64.
 2286   * Only build tests on "make check", not "make".
 2287   * Fixed alignment issue that caused crashes when using DynamicMessage on
 2288     64-bit Sparc machines.
 2289   * Simplify template usage to work with MSVC 2003.
 2290   * Work around GCC 4.3.x x86_64 compiler bug that caused crashes on startup.
 2291     (This affected Fedora 9 in particular.)
 2292   * Now works on "Solaris 10 using recent Sun Studio".
 2293 
 2294   Java
 2295   * New overload of mergeFrom() which parses a slice of a byte array instead
 2296     of the whole thing.
 2297   * New method ByteString.asReadOnlyByteBuffer() does what it sounds like.
 2298   * Improved performance of isInitialized() when optimizing for code size.
 2299 
 2300   Python
 2301   * Corrected ListFields() signature in Message base class to match what
 2302     subclasses actually implement.
 2303   * Some minor refactoring.
 2304   * Don't pass self as first argument to superclass constructor (no longer
 2305     allowed in Python 2.6).
 2306 
 2307 2008-09-29 version 2.0.2:
 2308 
 2309   General
 2310   * License changed from Apache 2.0 to 3-Clause BSD.
 2311   * It is now possible to define custom "options", which are basically
 2312     annotations which may be placed on definitions in a .proto file.
 2313     For example, you might define a field option called "foo" like so:
 2314       import "google/protobuf/descriptor.proto"
 2315       extend google.protobuf.FieldOptions {
 2316         optional string foo = 12345;
 2317       }
 2318     Then you annotate a field using the "foo" option:
 2319       message MyMessage {
 2320         optional int32 some_field = 1 [(foo) = "bar"]
 2321       }
 2322     The value of this option is then visible via the message's
 2323     Descriptor:
 2324       const FieldDescriptor* field =
 2325         MyMessage::descriptor()->FindFieldByName("some_field");
 2326       assert(field->options().GetExtension(foo) == "bar");
 2327     This feature has been implemented and tested in C++ and Java.
 2328     Other languages may or may not need to do extra work to support
 2329     custom options, depending on how they construct descriptors.
 2330 
 2331   C++
 2332   * Fixed some GCC warnings that only occur when using -pedantic.
 2333   * Improved static initialization code, making ordering more
 2334     predictable among other things.
 2335   * TextFormat will no longer accept messages which contain multiple
 2336     instances of a singular field.  Previously, the latter instance
 2337     would overwrite the former.
 2338   * Now works on systems that don't have hash_map.
 2339 
 2340   Java
 2341   * Print @Override annotation in generated code where appropriate.
 2342 
 2343   Python
 2344   * Strings now use the "unicode" type rather than the "str" type.
 2345     String fields may still be assigned ASCII "str" values; they will
 2346     automatically be converted.
 2347   * Adding a property to an object representing a repeated field now
 2348     raises an exception.  For example:
 2349       # No longer works (and never should have).
 2350       message.some_repeated_field.foo = 1
 2351 
 2352   Windows
 2353   * We now build static libraries rather than DLLs by default on MSVC.
 2354     See vsprojects/readme.txt for more information.
 2355 
 2356 2008-08-15 version 2.0.1:
 2357 
 2358   protoc
 2359   * New flags --encode and --decode can be used to convert between protobuf text
 2360     format and binary format from the command-line.
 2361   * New flag --descriptor_set_out can be used to write FileDescriptorProtos for
 2362     all parsed files directly into a single output file.  This is particularly
 2363     useful if you wish to parse .proto files from programs written in languages
 2364     other than C++: just run protoc as a background process and have it output
 2365     a FileDescriptorList, then parse that natively.
 2366   * Improved error message when an enum value's name conflicts with another
 2367     symbol defined in the enum type's scope, e.g. if two enum types declared
 2368     in the same scope have values with the same name.  This is disallowed for
 2369     compatibility with C++, but this wasn't clear from the error.
 2370   * Fixed absolute output paths on Windows.
 2371   * Allow trailing slashes in --proto_path mappings.
 2372 
 2373   C++
 2374   * Reflection objects are now per-class rather than per-instance.  To make this
 2375     possible, the Reflection interface had to be changed such that all methods
 2376     take the Message instance as a parameter.  This change improves performance
 2377     significantly in memory-bandwidth-limited use cases, since it makes the
 2378     message objects smaller.  Note that source-incompatible interface changes
 2379     like this will not be made again after the library leaves beta.
 2380   * Heuristically detect sub-messages when printing unknown fields.
 2381   * Fix static initialization ordering bug that caused crashes at startup when
 2382     compiling on Mac with static linking.
 2383   * Fixed TokenizerTest when compiling with -DNDEBUG on Linux.
 2384   * Fixed incorrect definition of kint32min.
 2385   * Fix bytes type setter to work with byte sequences with embedded NULLs.
 2386   * Other irrelevant tweaks.
 2387 
 2388   Java
 2389   * Fixed UnknownFieldSet's parsing of varints larger than 32 bits.
 2390   * Fixed TextFormat's parsing of "inf" and "nan".
 2391   * Fixed TextFormat's parsing of comments.
 2392   * Added info to Java POM that will be required when we upload the
 2393     package to a Maven repo.
 2394 
 2395   Python
 2396   * MergeFrom(message) and CopyFrom(message) are now implemented.
 2397   * SerializeToString() raises an exception if the message is missing required
 2398     fields.
 2399   * Code organization improvements.
 2400   * Fixed doc comments for RpcController and RpcChannel, which had somehow been
 2401     swapped.
 2402   * Fixed text_format_test on Windows where floating-point exponents sometimes
 2403     contain extra zeros.
 2404   * Fix Python service CallMethod() implementation.
 2405 
 2406   Other
 2407   * Improved readmes.
 2408   * VIM syntax highlighting improvements.
 2409 
 2410 2008-07-07 version 2.0.0:
 2411 
 2412   * First public release.