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