• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
12016-05-16 version 3.0.0-beta-3 (C++/Java/Python/Ruby/Nano/Objective-C/C#/JavaScript)
2  General
3  * Supported Proto3 lite-runtime in C++/Java for mobile platforms.
4  * Any type now supports APIs to specify prefixes other than
5    type.googleapis.com
6  * Removed javanano_use_deprecated_package option; Nano will always has its own
7    ".nano" package.
8
9  C++ (Beta)
10  * Improved hash maps.
11      - Improved hash maps comments. In particular, please note that equal hash
12        maps will not necessarily have the same iteration order and
13        serialization.
14      - Added a new hash maps implementation that will become the default in a
15        later release.
16  * Arenas
17      - Several inlined methods in Arena were moved to out-of-line to improve
18        build performance and code size.
19      - Added SpaceAllocatedAndUsed() to report both space used and allocated
20      - Added convenient class UnsafeArenaAllocatedRepeatedPtrFieldBackInserter
21  * Any
22      - Allow custom type URL prefixes in Any packing.
23      - TextFormat now expand the Any type rather than printing bytes.
24  * Performance optimizations and various bug fixes.
25
26  Java (Beta)
27  * Introduced an ExperimentalApi annotation. Annotated APIs are experimental
28    and are subject to change in a backward incompatible way in future releases.
29  * Introduced zero-copy serialization as an ExperimentalApi
30      - Introduction of the `ByteOutput` interface. This is similar to
31        `OutputStream` but provides semantics for lazy writing (i.e. no
32        immediate copy required) of fields that are considered to be immutable.
33      - `ByteString` now supports writing to a `ByteOutput`, which will directly
34        expose the internals of the `ByteString` (i.e. `byte[]` or `ByteBuffer`)
35        to the `ByteOutput` without copying.
36      - `CodedOutputStream` now supports writing to a `ByteOutput`. `ByteString`
37        instances that are too large to fit in the internal buffer will be
38        (lazily) written to the `ByteOutput` directly.
39      - This allows applications using large `ByteString` fields to avoid
40        duplication of these fields entirely. Such an application can supply a
41        `ByteOutput` that chains together the chunks received from
42        `CodedOutputStream` before forwarding them onto the IO system.
43  * Other related changes to `CodedOutputStream`
44      - Additional use of `sun.misc.Unsafe` where possible to perform fast
45        access to `byte[]` and `ByteBuffer` values and avoiding unnecessary
46        range checking.
47      - `ByteBuffer`-backed `CodedOutputStream` now writes directly to the
48        `ByteBuffer` rather than to an intermediate array.
49  * Improved lite-runtime.
50      - Lite protos now implement deep equals/hashCode/toString
51      - Significantly improved the performance of Builder#mergeFrom() and
52        Builder#mergeDelimitedFrom()
53  * Various bug fixes and small feature enhancement.
54      - Fixed stack overflow when in hashCode() for infinite recursive oneofs.
55      - Fixed the lazy field parsing in lite to merge rather than overwrite.
56      - TextFormat now supports reporting line/column numbers on errors.
57      - Updated to add appropriate @Override for better compiler errors.
58
59  Python (Beta)
60  * Added JSON format for Any, Struct, Value and ListValue
61  * [ ] is now accepted for both repeated scalar fields and repeated message
62    fields in text format parser.
63  * Numerical field name is now supported in text format.
64  * Added DiscardUnknownFields API for python protobuf message.
65
66  Objective-C (Beta)
67  * Proto comments now come over as HeaderDoc comments in the generated sources
68    so Xcode can pick them up and display them.
69  * The library headers have been updated to use HeaderDoc comments so Xcode can
70    pick them up and display them.
71  * The per message and per field overhead in both generated code and runtime
72    object sizes was reduced.
73  * Generated code now include deprecated annotations when the proto file
74    included them.
75
76  C# (Beta)
77  In general: some changes are breaking, which require regenerating messages.
78  Most user-written code will not be impacted *except* for the renaming of enum
79  values.
80
81  * Allow custom type URL prefixes in `Any` packing, and ignore them when
82    unpacking
83  * `protoc` is now in a separate NuGet package (Google.Protobuf.Tools)
84  * New option: `internal_access` to generate internal classes
85  * Enum values are now PascalCased, and if there's a prefix which matches the
86    name of the enum, that is removed (so an enum `COLOR` with a value
87    `COLOR_BLUE` would generate a value of just `Blue`). An option
88    (`legacy_enum_values`) is temporarily available to disable this, but the
89    option will be removed for GA.
90  * `json_name` option is now honored
91  * If group tags are encountered when parsing, they are validated more
92    thoroughly (although we don't support actual groups)
93  * NuGet dependencies are better specified
94  * Breaking: `Preconditions` is renamed to `ProtoPreconditions`
95  * Breaking: `GeneratedCodeInfo` is renamed to `GeneratedClrTypeInfo`
96  * `JsonFormatter` now allows writing to a `TextWriter`
97  * New interface, `ICustomDiagnosticMessage` to allow more compact
98    representations from `ToString`
99  * `CodedInputStream` and `CodedOutputStream` now implement `IDisposable`,
100    which simply disposes of the streams they were constructed with
101  * Map fields no longer support null values (in line with other languages)
102  * Improvements in JSON formatting and parsing
103
104  Javascript (Alpha)
105  * Better support for "bytes" fields: bytes fields can be read as either a
106    base64 string or UInt8Array (in environments where TypedArray is supported).
107  * New support for CommonJS imports.  This should make it easier to use the
108    JavaScript support in Node.js and tools like WebPack.  See js/README.md for
109    more information.
110  * Some significant internal refactoring to simplify and modularize the code.
111
112  Ruby (Alpha)
113  * JSON serialization now properly uses camelCased names, with a runtime option
114    that will preserve original names from .proto files instead.
115  * Well-known types are now included in the distribution.
116  * Release now includes binary gems for Windows, Mac, and Linux instead of just
117    source gems.
118  * Bugfix for serializing oneofs.
119
120  C++/Java Lite (Alpha)
121    A new "lite" generator parameter was introduced in the protoc for C++ and
122    Java for Proto3 syntax messages. Example usage:
123
124     ./protoc --cpp_out=lite:$OUTPUT_PATH foo.proto
125
126    The protoc will treat the current input and all the transitive dependencies
127    as LITE. The same generator parameter must be used to generate the
128    dependencies.
129
130    In Proto3 syntax files, "optimized_for=LITE_RUNTIME" is no longer supported.
131
132
1332015-12-30 version 3.0.0-beta-2 (C++/Java/Python/Ruby/Nano/Objective-C/C#/JavaScript)
134  General
135  * Introduced a new language implementation: JavaScript.
136  * Added a new field option "json_name". By default proto field names are
137    converted to "lowerCamelCase" in proto3 JSON format. This option can be
138    used to override this behavior and specify a different JSON name for the
139    field.
140  * Added conformance tests to ensure implementations are following proto3 JSON
141    specification.
142
143  C++ (Beta)
144  * Various bug fixes and improvements to the JSON support utility:
145      - Duplicate map keys in JSON are now rejected (i.e., translation will
146        fail).
147      - Fixed wire-format for google.protobuf.Value/ListValue.
148      - Fixed precision loss when converting google.protobuf.Timestamp.
149      - Fixed a bug when parsing invalid UTF-8 code points.
150      - Fixed a memory leak.
151      - Reduced call stack usage.
152
153  Java (Beta)
154  * Cleaned up some unused methods on CodedOutputStream.
155  * Presized lists for packed fields during parsing in the lite runtime to
156    reduce allocations and improve performance.
157  * Improved the performance of unknown fields in the lite runtime.
158  * Introduced UnsafeByteStrings to support zero-copy ByteString creation.
159  * Various bug fixes and improvements to the JSON support utility:
160      - Fixed a thread-safety bug.
161      - Added a new option “preservingProtoFieldNames” to JsonFormat.
162      - Added a new option “includingDefaultValueFields” to JsonFormat.
163      - Updated the JSON utility to comply with proto3 JSON specification.
164
165  Python (Beta)
166  * Added proto3 JSON format utility. It includes support for all field types
167    and a few well-known types except for Any and Struct.
168  * Added runtime support for Any, Timestamp, Duration and FieldMask.
169  * [ ] is now accepted for repeated scalar fields in text format parser.
170  * Map fields now have proper O(1) performance for lookup/insert/delete
171    when using the Python/C++ implementation. They were previously using O(n)
172    search-based algorithms because the C++ reflection interface didn't
173    support true map operations.
174
175  Objective-C (Beta)
176  * Various bug-fixes and code tweaks to pass more strict compiler warnings.
177  * Now has conformance test coverage and is passing all tests.
178
179  C# (Beta)
180  * Various bug-fixes.
181  * Code generation: Files generated in directories based on namespace.
182  * Code generation: Include comments from .proto files in XML doc
183    comments (naively)
184  * Code generation: Change organization/naming of "reflection class" (access
185    to file descriptor)
186  * Code generation and library: Add Parser property to MessageDescriptor,
187    and introduce a non-generic parser type.
188  * Library: Added TypeRegistry to support JSON parsing/formatting of Any.
189  * Library: Added Any.Pack/Unpack support.
190  * Library: Implemented JSON parsing.
191
192  Javascript (Alpha)
193  * Added proto3 support for JavaScript. The runtime is written in pure
194    JavaScript and works in browsers and in Node.js. To generate JavaScript
195    code for your proto, invoke protoc with "--js_out". See js/README.md
196    for more build instructions.
197
1982015-08-26 version 3.0.0-beta-1 (C++/Java/Python/Ruby/Nano/Objective-C/C#)
199  About Beta
200  * This is the first beta release of protobuf v3.0.0. Not all languages
201    have reached beta stage. Languages not marked as beta are still in
202    alpha (i.e., be prepared for API breaking changes).
203
204  General
205  * Proto3 JSON is supported in several languages (fully supported in C++
206    and Java, partially supported in Ruby/C#). The JSON spec is defined in
207    the proto3 language guide:
208
209      https://developers.google.com/protocol-buffers/docs/proto3#json
210
211    We will publish a more detailed spec to define the exact behavior of
212    proto3-conformant JSON serializers and parsers. Until then, do not rely
213    on specific behaviors of the implementation if it’s not documented in
214    the above spec. More specifically, the behavior is not yet finalized for
215    the following:
216      - Parsing invalid JSON input (e.g., input with trailing commas).
217      - Non-camelCase names in JSON input.
218      - The same field appears multiple times in JSON input.
219      - JSON arrays contain “null” values.
220      - The message has unknown fields.
221
222  * Proto3 now enforces strict UTF-8 checking. Parsing will fail if a string
223    field contains non UTF-8 data.
224
225  C++ (Beta)
226  * Introduced new utility functions/classes in the google/protobuf/util
227    directory:
228      - MessageDifferencer: compare two proto messages and report their
229                            differences.
230      - JsonUtil: support converting protobuf binary format to/from JSON.
231      - TimeUtil: utility functions to work with well-known types Timestamp
232                  and Duration.
233      - FieldMaskUtil: utility functions to work with FieldMask.
234
235  * Performance optimization of arena construction and destruction.
236  * Bug fixes for arena and maps support.
237  * Changed to use cmake for Windows Visual Studio builds.
238  * Added Bazel support.
239
240  Java (Beta)
241  * Introduced a new util package that will be distributed as a separate
242    artifact in maven. It contains:
243      - JsonFormat: convert proto messages to/from JSON.
244      - TimeUtil: utility functions to work with Timestamp and Duration.
245      - FieldMaskUtil: utility functions to work with FieldMask.
246
247  * The static PARSER in each generated message is deprecated, and it will
248    be removed in a future release. A static parser() getter is generated
249    for each message type instead.
250  * Performance optimizations for String fields serialization.
251  * Performance optimizations for Lite runtime on Android:
252      - Reduced allocations
253      - Reduced method overhead after ProGuarding
254      - Reduced code size after ProGuarding
255
256  Python (Alpha)
257  * Removed legacy Python 2.5 support.
258  * Moved to a single Python 2.x/3.x-compatible codebase, instead of using 2to3.
259  * Fixed build/tests on Python 2.6, 2.7, 3.3, and 3.4.
260      - Pure-Python works on all four.
261      - Python/C++ implementation works on all but 3.4, due to changes in the
262        Python/C++ API in 3.4.
263  * Some preliminary work has been done to allow for multiple DescriptorPools
264    with Python/C++.
265
266  Ruby (Alpha)
267  * Many bugfixes:
268      - fixed parsing/serialization of bytes, sint, sfixed types
269      - other parser bugfixes
270      - fixed memory leak affecting Ruby 2.2
271
272  JavaNano (Alpha)
273  * JavaNano generated code now will be put in a nano package by default to
274    avoid conflicts with Java generated code.
275
276  Objective-C (Alpha)
277  * Added non-null markup to ObjC library. Requires SDK 8.4+ to build.
278  * Many bugfixes:
279      - Removed the class/enum filter.
280      - Renamed some internal types to avoid conflicts with the well-known types
281        protos.
282      - Added missing support for parsing repeated primitive fields in packed or
283        unpacked forms.
284      - Added *Count for repeated and map<> fields to avoid auto-create when
285        checking for them being set.
286
287  C# (Alpha)
288  * Namespace changed to Google.Protobuf (and NuGet package will be named
289    correspondingly).
290  * Target platforms now .NET 4.5 and selected portable subsets only.
291  * Removed lite runtime.
292  * Reimplementation to use mutable message types.
293  * Null references used to represent "no value" for message type fields.
294  * Proto3 semantics supported; proto2 files are prohibited for C# codegen.
295    Most proto3 features supported:
296      - JSON formatting (a.k.a. serialization to JSON), including well-known
297        types (except for Any).
298      - Wrapper types mapped to nullable value types (or string/ByteString
299        allowing nullability). JSON parsing is not supported yet.
300      - maps
301      - oneof
302      - enum unknown value preservation
303
3042015-05-25 version 3.0.0-alpha-3 (Objective-C/C#):
305  General
306  * Introduced two new language implementations (Objective-C, C#) to proto3.
307  * Explicit "optional" keyword are disallowed in proto3 syntax, as fields are
308    optional by default.
309  * Group fields are no longer supported in proto3 syntax.
310  * Changed repeated primitive fields to use packed serialization by default in
311    proto3 (implemented for C++, Java, Python in this release).  The user can
312    still disable packed serialization by setting packed to false for now.
313  * Added well-known type protos (any.proto, empty.proto, timestamp.proto,
314    duration.proto, etc.). Users can import and use these protos just like
315    regular proto files. Additional runtime support will be added for them in
316    future releases (in the form of utility helper functions, or having them
317    replaced by language specific types in generated code).
318  * Added a "reserved" keyword in both proto2 and proto3 syntax. User can use
319    this keyword to declare reserved field numbers and names to prevent them
320    from being reused by other fields in the same message.
321
322    To reserve field numbers, add a reserved declaration in your message:
323
324      message TestMessage {
325        reserved 2, 15, 9 to 11, 3;
326      }
327
328    This reserves field numbers 2, 3, 9, 10, 11 and 15. If a user uses any of
329    these as field numbers, the protocol buffer compiler will report an error.
330
331    Field names can also be reserved:
332
333      message TestMessage {
334        reserved "foo", "bar";
335      }
336
337  * Various bug fixes since 3.0.0-alpha-2
338
339  Objective-C
340    Objective-C includes a code generator and a native objective-c runtime
341    library.  By adding “--objc_out” to protoc, the code generator will generate
342    a header(*.pbobjc.h) and an implementation file(*.pbobjc.m) for each proto
343    file.
344
345    In this first release, the generated interface provides: enums, messages,
346    field support(single, repeated, map, oneof), proto2 and proto3 syntax
347    support, parsing and serialization. It’s  compatible with ARC and non-ARC
348    usage. Besides, user can also access it via the swift bridging header.
349
350    See objectivec/README.md for details.
351
352  C#
353    * C# protobufs are based on project
354      https://github.com/jskeet/protobuf-csharp-port. The original project was
355      frozen and all the new development will happen here.
356    * Codegen plugin for C# was completely rewritten to C++ and is now an
357      integral part of protoc.
358    * Some refactorings and cleanup has been applied to the C# runtime library.
359    * Only proto2 is supported in C# at the moment, proto3 support is in
360      progress and will likely bring significant breaking changes to the API.
361
362    See csharp/README.md for details.
363
364  C++
365    * Added runtime support for Any type. To use Any in your proto file, first
366      import the definition of Any:
367
368        // foo.proto
369        import "google/protobuf/any.proto";
370        message Foo {
371          google.protobuf.Any any_field = 1;
372        }
373        message Bar {
374          int32 value = 1;
375        }
376
377      Then in C++ you can access the Any field using PackFrom()/UnpackTo()
378      methods:
379
380        Foo foo;
381        Bar bar = ...;
382        foo.mutable_any_field()->PackFrom(bar);
383        ...
384        if (foo.any_field().IsType<Bar>()) {
385          foo.any_field().UnpackTo(&bar);
386          ...
387        }
388    * In text format, entries of a map field will be sorted by key.
389
390  Java
391    * Continued optimizations on the lite runtime to improve performance for
392      Android.
393
394  Python
395    * Added map support.
396      - maps now have a dict-like interface (msg.map_field[key] = value)
397      - existing code that modifies maps via the repeated field interface
398        will need to be updated.
399
400  Ruby
401    * Improvements to RepeatedField's emulation of the Ruby Array API.
402    * Various speedups and internal cleanups.
403
4042015-02-26 version 3.0.0-alpha-2 (Python/Ruby/JavaNano):
405  General
406  * Introduced three new language implementations (Ruby, JavaNano, and
407    Python) to proto3.
408  * Various bug fixes since 3.0.0-alpha-1
409
410  Python:
411    Python has received several updates, most notably support for proto3
412    semantics in any .proto file that declares syntax="proto3".
413    Messages declared in proto3 files no longer represent field presence
414    for scalar fields (number, enums, booleans, or strings).  You can
415    no longer call HasField() for such fields, and they are serialized
416    based on whether they have a non-zero/empty/false value.
417
418    One other notable change is in the C++-accelerated implementation.
419    Descriptor objects (which describe the protobuf schema and allow
420    reflection over it) are no longer duplicated between the Python
421    and C++ layers.  The Python descriptors are now simple wrappers
422    around the C++ descriptors.  This change should significantly
423    reduce the memory usage of programs that use a lot of message
424    types.
425
426  Ruby:
427    We have added proto3 support for Ruby via a native C extension.
428
429    The Ruby extension itself is included in the ruby/ directory, and details on
430    building and installing the extension are in ruby/README.md. The extension
431    will also be published as a Ruby gem. Code generator support is included as
432    part of `protoc` with the `--ruby_out` flag.
433
434    The Ruby extension implements a user-friendly DSL to define message types
435    (also generated by the code generator from `.proto` files).  Once a message
436    type is defined, the user may create instances of the message that behave in
437    ways idiomatic to Ruby. For example:
438
439    - Message fields are present as ordinary Ruby properties (getter method
440      `foo` and setter method `foo=`).
441    - Repeated field elements are stored in a container that acts like a native
442      Ruby array, and map elements are stored in a container that acts like a
443      native Ruby hashmap.
444    - The usual well-known methods, such as `#to_s`, `#dup`, and the like, are
445      present.
446
447    Unlike several existing third-party Ruby extensions for protobuf, this
448    extension is built on a "strongly-typed" philosophy: message fields and
449    array/map containers will throw exceptions eagerly when values of the
450    incorrect type are inserted.
451
452    See ruby/README.md for details.
453
454  JavaNano:
455    JavaNano is a special code generator and runtime library designed especially
456    for resource-restricted systems, like Android. It is very resource-friendly
457    in both the amount of code and the runtime overhead. Here is an an overview
458    of JavaNano features compared with the official Java protobuf:
459
460    - No descriptors or message builders.
461    - All messages are mutable; fields are public Java fields.
462    - For optional fields only, encapsulation behind setter/getter/hazzer/
463      clearer functions is opt-in, which provide proper 'has' state support.
464    - For proto2, if not opted in, has state (field presence) is not available.
465      Serialization outputs all fields not equal to their defaults.
466      The behavior is consistent with proto3 semantics.
467    - Required fields (proto2 only) are always serialized.
468    - Enum constants are integers; protection against invalid values only
469      when parsing from the wire.
470    - Enum constants can be generated into container interfaces bearing
471      the enum's name (so the referencing code is in Java style).
472    - CodedInputByteBufferNano can only take byte[] (not InputStream).
473    - Similarly CodedOutputByteBufferNano can only write to byte[].
474    - Repeated fields are in arrays, not ArrayList or Vector. Null array
475      elements are allowed and silently ignored.
476    - Full support for serializing/deserializing repeated packed fields.
477    - Support  extensions (in proto2).
478    - Unset messages/groups are null, not an immutable empty default
479      instance.
480    - toByteArray(...) and mergeFrom(...) are now static functions of
481      MessageNano.
482    - The 'bytes' type translates to the Java type byte[].
483
484    See javanano/README.txt for details.
485
4862014-12-01 version 3.0.0-alpha-1 (C++/Java):
487
488  General
489  * Introduced Protocol Buffers language version 3 (aka proto3).
490
491    When protobuf was initially opensourced it implemented Protocol Buffers
492    language version 2 (aka proto2), which is why the version number
493    started from v2.0.0. From v3.0.0, a new language version (proto3) is
494    introduced while the old version (proto2) will continue to be supported.
495
496    The main intent of introducing proto3 is to clean up protobuf before
497    pushing the language as the foundation of Google's new API platform.
498    In proto3, the language is simplified, both for ease of use and  to
499    make it available in a wider range of programming languages. At the
500    same time a few features are added to better support common idioms
501    found in APIs.
502
503    The following are the main new features in language version 3:
504
505      1. Removal of field presence logic for primitive value fields, removal
506         of required fields, and removal of default values. This makes proto3
507         significantly easier to implement with open struct representations,
508         as in languages like Android Java, Objective C, or Go.
509      2. Removal of unknown fields.
510      3. Removal of extensions, which are instead replaced by a new standard
511         type called Any.
512      4. Fix semantics for unknown enum values.
513      5. Addition of maps.
514      6. Addition of a small set of standard types for representation of time,
515         dynamic data, etc.
516      7. A well-defined encoding in JSON as an alternative to binary proto
517         encoding.
518
519    This release (v3.0.0-alpha-1) includes partial proto3 support for C++ and
520    Java. Items 6 (well-known types) and 7 (JSON format) in the above feature
521    list are not implemented.
522
523    A new notion "syntax" is introduced to specify whether a .proto file
524    uses proto2 or proto3:
525
526      // foo.proto
527      syntax = "proto3";
528      message Bar {...}
529
530    If omitted, the protocol compiler will generate a warning and "proto2" will
531    be used as the default. This warning will be turned into an error in a
532    future release.
533
534    We recommend that new Protocol Buffers users use proto3. However, we do not
535    generally recommend that existing users migrate from proto2 from proto3 due
536    to API incompatibility, and we will continue to support proto2 for a long
537    time.
538
539  * Added support for map fields (implemented in C++/Java for both proto2 and
540    proto3).
541
542    Map fields can be declared using the following syntax:
543
544      message Foo {
545        map<string, string> values = 1;
546      }
547
548    Data of a map field will be stored in memory as an unordered map and it
549    can be accessed through generated accessors.
550
551  C++
552  * Added arena allocation support (for both proto2 and proto3).
553
554    Profiling shows memory allocation and deallocation constitutes a significant
555    fraction of CPU-time spent in protobuf code and arena allocation is a
556    technique introduced to reduce this cost. With arena allocation, new
557    objects will be allocated from a large piece of preallocated memory and
558    deallocation of these objects is almost free. Early adoption shows 20% to
559    50% improvement in some Google binaries.
560
561    To enable arena support, add the following option to your .proto file:
562
563      option cc_enable_arenas = true;
564
565    Protocol compiler will generate additional code to make the generated
566    message classes work with arenas. This does not change the existing API
567    of protobuf messages and does not affect wire format. Your existing code
568    should continue to work after adding this option. In the future we will
569    make this option enabled by default.
570
571    To actually take advantage of arena allocation, you need to use the arena
572    APIs when creating messages. A quick example of using the arena API:
573
574      {
575        google::protobuf::Arena arena;
576        // Allocate a protobuf message in the arena.
577        MyMessage* message = Arena::CreateMessage<MyMessage>(&arena);
578        // All submessages will be allocated in the same arena.
579        if (!message->ParseFromString(data)) {
580          // Deal with malformed input data.
581        }
582        // Must not delete the message here. It will be deleted automatically
583        // when the arena is destroyed.
584      }
585
586    Currently arena does not work with map fields. Enabling arena in a .proto
587    file containing map fields will result in compile errors in the generated
588    code. This will be addressed in a future release.
589
5902014-10-20 version 2.6.1:
591
592  C++
593  * Added atomicops support for Solaris.
594  * Released memory allocated by InitializeDefaultRepeatedFields() and
595    GetEmptyString(). Some memory sanitizers reported them as memory leaks.
596
597  Java
598  * Updated DynamicMessage.setField() to handle repeated enum values
599    correctly.
600  * Fixed a bug that caused NullPointerException to be thrown when
601    converting manually constructed FileDescriptorProto to
602    FileDescriptor.
603
604  Python
605  * Fixed WhichOneof() to work with de-serialized protobuf messages.
606  * Fixed a missing file problem of Python C++ implementation.
607
6082014-08-15 version 2.6.0:
609
610  General
611  * Added oneofs(unions) feature. Fields in the same oneof will share
612    memory and at most one field can be set at the same time. Use the
613    oneof keyword to define a oneof like:
614      message SampleMessage {
615        oneof test_oneof {
616          string name = 4;
617          YourMessage sub_message = 9;
618        }
619      }
620  * Files, services, enums, messages, methods and enum values can be marked
621    as deprecated now.
622  * Added Support for list values, including lists of messages, when
623    parsing text-formatted protos in C++ and Java.
624      For example:  foo: [1, 2, 3]
625
626  C++
627  * Enhanced customization on TestFormat printing.
628  * Added SwapFields() in reflection API to swap a subset of fields.
629    Added SetAllocatedMessage() in reflection API.
630  * Repeated primitive extensions are now packable. The
631    [packed=true] option only affects serializers. Therefore, it is
632    possible to switch a repeated extension field to packed format
633    without breaking backwards-compatibility.
634  * Various speed optimizations.
635
636  Java
637  * writeTo() method in ByteString can now write a substring to an
638    output stream. Added endWith() method for ByteString.
639  * ByteString and ByteBuffer are now supported in CodedInputStream
640    and CodedOutputStream.
641  * java_generate_equals_and_hash can now be used with the LITE_RUNTIME.
642
643  Python
644  * A new C++-backed extension module (aka "cpp api v2") that replaces the
645    old ("cpp api v1") one.  Much faster than the pure Python code.  This one
646    resolves many bugs and is recommended for general use over the
647    pure Python when possible.
648  * Descriptors now have enum_types_by_name and extension_types_by_name dict
649    attributes.
650  * Support for Python 3.
651
6522013-02-27 version 2.5.0:
653
654  General
655  * New notion "import public" that allows a proto file to forward the content
656    it imports to its importers. For example,
657      // foo.proto
658      import public "bar.proto";
659      import "baz.proto";
660
661      // qux.proto
662      import "foo.proto";
663      // Stuff defined in bar.proto may be used in this file, but stuff from
664      // baz.proto may NOT be used without importing it explicitly.
665    This is useful for moving proto files. To move a proto file, just leave
666    a single "import public" in the old proto file.
667  * New enum option "allow_alias" that specifies whether different symbols can
668    be assigned the same numeric value. Default value is "true". Setting it to
669    false causes the compiler to reject enum definitions where multiple symbols
670    have the same numeric value.
671    Note: We plan to flip the default value to "false" in a future release.
672    Projects using enum aliases should set the option to "true" in their .proto
673    files.
674
675  C++
676  * New generated method set_allocated_foo(Type* foo) for message and string
677    fields. This method allows you to set the field to a pre-allocated object
678    and the containing message takes the ownership of that object.
679  * Added SetAllocatedExtension() and ReleaseExtension() to extensions API.
680  * Custom options are now formatted correctly when descriptors are printed in
681    text format.
682  * Various speed optimizations.
683
684  Java
685  * Comments in proto files are now collected and put into generated code as
686    comments for corresponding classes and data members.
687  * Added Parser to parse directly into messages without a Builder. For
688    example,
689      Foo foo = Foo.PARSER.ParseFrom(input);
690    Using Parser is ~25% faster than using Builder to parse messages.
691  * Added getters/setters to access the underlying ByteString of a string field
692    directly.
693  * ByteString now supports more operations: substring(), prepend(), and
694    append(). The implementation of ByteString uses a binary tree structure
695    to support these operations efficiently.
696  * New method findInitializationErrors() that lists all missing required
697    fields.
698  * Various code size and speed optimizations.
699
700  Python
701  * Added support for dynamic message creation. DescriptorDatabase,
702    DescriptorPool, and MessageFactory work like their C++ counterparts to
703    simplify Descriptor construction from *DescriptorProtos, and MessageFactory
704    provides a message instance from a Descriptor.
705  * Added pickle support for protobuf messages.
706  * Unknown fields are now preserved after parsing.
707  * Fixed bug where custom options were not correctly populated. Custom
708    options can be accessed now.
709  * Added EnumTypeWrapper that provides better accessibility to enum types.
710  * Added ParseMessage(descriptor, bytes) to generate a new Message instance
711    from a descriptor and a byte string.
712
7132011-05-01 version 2.4.1:
714
715  C++
716  * Fixed the friendship problem for old compilers to make the library now gcc 3
717    compatible again.
718  * Fixed vcprojects/extract_includes.bat to extract compiler/plugin.h.
719
720  Java
721  * Removed usages of JDK 1.6 only features to make the library now JDK 1.5
722    compatible again.
723  * Fixed a bug about negative enum values.
724  * serialVersionUID is now defined in generated messages for java serializing.
725  * Fixed protoc to use java.lang.Object, which makes "Object" now a valid
726    message name again.
727
728  Python
729  * Experimental C++ implementation now requires C++ protobuf library installed.
730    See the README.txt in the python directory for details.
731
7322011-02-02 version 2.4.0:
733
734  General
735  * The RPC (cc|java|py)_generic_services default value is now false instead of
736    true.
737  * Custom options can have aggregate types. For example,
738      message MyOption {
739        optional string comment = 1;
740        optional string author = 2;
741      }
742      extend google.protobuf.FieldOptions {
743        optional MyOption myoption = 12345;
744      }
745    This option can now be set as follows:
746      message SomeType {
747        optional int32 field = 1 [(myoption) = { comment:'x' author:'y' }];
748      }
749
750  C++
751  * Various speed and code size optimizations.
752  * Added a release_foo() method on string and message fields.
753  * Fixed gzip_output_stream sub-stream handling.
754
755  Java
756  * Builders now maintain sub-builders for sub-messages. Use getFooBuilder() to
757    get the builder for the sub-message "foo". This allows you to repeatedly
758    modify deeply-nested sub-messages without rebuilding them.
759  * Builder.build() no longer invalidates the Builder for generated messages
760    (You may continue to modify it and then build another message).
761  * Code generator will generate efficient equals() and hashCode()
762    implementations if new option java_generate_equals_and_hash is enabled.
763    (Otherwise, reflection-based implementations are used.)
764  * Generated messages now implement Serializable.
765  * Fields with [deprecated=true] will be marked with @Deprecated in Java.
766  * Added lazy conversion of UTF-8 encoded strings to String objects to improve
767    performance.
768  * Various optimizations.
769  * Enum value can be accessed directly, instead of calling getNumber() on the
770    enum member.
771  * For each enum value, an integer constant is also generated with the suffix
772    _VALUE.
773
774  Python
775  * Added an experimental  C++ implementation for Python messages via a Python
776    extension. Implementation type is controlled by an environment variable
777    PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION (valid values: "cpp" and "python")
778    The default value is currently "python" but will be changed to "cpp" in
779    future release.
780  * Improved performance on message instantiation significantly.
781    Most of the work on message instantiation is done just once per message
782    class, instead of once per message instance.
783  * Improved performance on text message parsing.
784  * Allow add() to forward keyword arguments to the concrete class.
785      E.g. instead of
786        item = repeated_field.add()
787        item.foo = bar
788        item.baz = quux
789      You can do:
790        repeated_field.add(foo=bar, baz=quux)
791  * Added a sort() interface to the BaseContainer.
792  * Added an extend() method to repeated composite fields.
793  * Added UTF8 debug string support.
794
7952010-01-08 version 2.3.0:
796
797  General
798  * Parsers for repeated numeric fields now always accept both packed and
799    unpacked input.  The [packed=true] option only affects serializers.
800    Therefore, it is possible to switch a field to packed format without
801    breaking backwards-compatibility -- as long as all parties are using
802    protobuf 2.3.0 or above, at least.
803  * The generic RPC service code generated by the C++, Java, and Python
804    generators can be disabled via file options:
805      option cc_generic_services = false;
806      option java_generic_services = false;
807      option py_generic_services = false;
808    This allows plugins to generate alternative code, possibly specific to some
809    particular RPC implementation.
810
811  protoc
812  * Now supports a plugin system for code generators.  Plugins can generate
813    code for new languages or inject additional code into the output of other
814    code generators.  Plugins are just binaries which accept a protocol buffer
815    on stdin and write a protocol buffer to stdout, so they may be written in
816    any language.  See src/google/protobuf/compiler/plugin.proto.
817    **WARNING**:  Plugins are experimental.  The interface may change in a
818    future version.
819  * If the output location ends in .zip or .jar, protoc will write its output
820    to a zip/jar archive instead of a directory.  For example:
821      protoc --java_out=myproto_srcs.jar --python_out=myproto.zip myproto.proto
822    Currently the archive contents are not compressed, though this could change
823    in the future.
824  * inf, -inf, and nan can now be used as default values for float and double
825    fields.
826
827  C++
828  * Various speed and code size optimizations.
829  * DynamicMessageFactory is now fully thread-safe.
830  * Message::Utf8DebugString() method is like DebugString() but avoids escaping
831    UTF-8 bytes.
832  * Compiled-in message types can now contain dynamic extensions, through use
833    of CodedInputStream::SetExtensionRegistry().
834  * Now compiles shared libraries (DLLs) by default on Cygwin and MinGW, to
835    match other platforms.  Use --disable-shared to avoid this.
836
837  Java
838  * parseDelimitedFrom() and mergeDelimitedFrom() now detect EOF and return
839    false/null instead of throwing an exception.
840  * Fixed some initialization ordering bugs.
841  * Fixes for OpenJDK 7.
842
843  Python
844  * 10-25 times faster than 2.2.0, still pure-Python.
845  * Calling a mutating method on a sub-message always instantiates the message
846    in its parent even if the mutating method doesn't actually mutate anything
847    (e.g. parsing from an empty string).
848  * Expanded descriptors a bit.
849
8502009-08-11 version 2.2.0:
851
852  C++
853  * Lite mode:  The "optimize_for = LITE_RUNTIME" option causes the compiler
854    to generate code which only depends libprotobuf-lite, which is much smaller
855    than libprotobuf but lacks descriptors, reflection, and some other features.
856  * Fixed bug where Message.Swap(Message) was only implemented for
857    optimize_for_speed.  Swap now properly implemented in both modes
858    (Issue 91).
859  * Added RemoveLast and SwapElements(index1, index2) to Reflection
860    interface for repeated elements.
861  * Added Swap(Message) to Reflection interface.
862  * Floating-point literals in generated code that are intended to be
863    single-precision now explicitly have 'f' suffix to avoid pedantic warnings
864    produced by some compilers.
865  * The [deprecated=true] option now causes the C++ code generator to generate
866    a GCC-style deprecation annotation (no-op on other compilers).
867  * google::protobuf::GetEnumDescriptor<SomeGeneratedEnumType>() returns the
868    EnumDescriptor for that type -- useful for templates which cannot call
869    SomeGeneratedEnumType_descriptor().
870  * Various optimizations and obscure bug fixes.
871
872  Java
873  * Lite mode:  The "optimize_for = LITE_RUNTIME" option causes the compiler
874    to generate code which only depends libprotobuf-lite, which is much smaller
875    than libprotobuf but lacks descriptors, reflection, and some other features.
876  * Lots of style cleanups.
877
878  Python
879  * Fixed endianness bug with floats and doubles.
880  * Text format parsing support.
881  * Fix bug with parsing packed repeated fields in embedded messages.
882  * Ability to initialize fields by passing keyword args to constructor.
883  * Support iterators in extend and __setslice__ for containers.
884
8852009-05-13 version 2.1.0:
886
887  General
888  * Repeated fields of primitive types (types other that string, group, and
889    nested messages) may now use the option [packed = true] to get a more
890    efficient encoding.  In the new encoding, the entire list is written
891    as a single byte blob using the "length-delimited" wire type.  Within
892    this blob, the individual values are encoded the same way they would
893    be normally except without a tag before each value (thus, they are
894    tightly "packed").
895  * For each field, the generated code contains an integer constant assigned
896    to the field number.  For example, the .proto file:
897      message Foo { optional int bar_baz = 123; }
898    would generate the following constants, all with the integer value 123:
899      C++:     Foo::kBarBazFieldNumber
900      Java:    Foo.BAR_BAZ_FIELD_NUMBER
901      Python:  Foo.BAR_BAZ_FIELD_NUMBER
902    Constants are also generated for extensions, with the same naming scheme.
903    These constants may be used as switch cases.
904  * Updated bundled Google Test to version 1.3.0.  Google Test is now bundled
905    in its verbatim form as a nested autoconf package, so you can drop in any
906    other version of Google Test if needed.
907  * optimize_for = SPEED is now the default, by popular demand.  Use
908    optimize_for = CODE_SIZE if code size is more important in your app.
909  * It is now an error to define a default value for a repeated field.
910    Previously, this was silently ignored (it had no effect on the generated
911    code).
912  * Fields can now be marked deprecated like:
913      optional int32 foo = 1 [deprecated = true];
914    Currently this does not have any actual effect, but in the future the code
915    generators may generate deprecation annotations in each language.
916  * Cross-compiling should now be possible using the --with-protoc option to
917    configure.  See README.txt for more info.
918
919  protoc
920  * --error_format=msvs option causes errors to be printed in Visual Studio
921    format, which should allow them to be clicked on in the build log to go
922    directly to the error location.
923  * The type name resolver will no longer resolve type names to fields.  For
924    example, this now works:
925      message Foo {}
926      message Bar {
927        optional int32 Foo = 1;
928        optional Foo baz = 2;
929      }
930    Previously, the type of "baz" would resolve to "Bar.Foo", and you'd get
931    an error because Bar.Foo is a field, not a type.  Now the type of "baz"
932    resolves to the message type Foo.  This change is unlikely to make a
933    difference to anyone who follows the Protocol Buffers style guide.
934
935  C++
936  * Several optimizations, including but not limited to:
937    - Serialization, especially to flat arrays, is 10%-50% faster, possibly
938      more for small objects.
939    - Several descriptor operations which previously required locking no longer
940      do.
941    - Descriptors are now constructed lazily on first use, rather than at
942      process startup time.  This should save memory in programs which do not
943      use descriptors or reflection.
944    - UnknownFieldSet completely redesigned to be more efficient (especially in
945      terms of memory usage).
946    - Various optimizations to reduce code size (though the serialization speed
947      optimizations increased code size).
948  * Message interface has method ParseFromBoundedZeroCopyStream() which parses
949    a limited number of bytes from an input stream rather than parsing until
950    EOF.
951  * GzipInputStream and GzipOutputStream support reading/writing gzip- or
952    zlib-compressed streams if zlib is available.
953    (google/protobuf/io/gzip_stream.h)
954  * DescriptorPool::FindAllExtensions() and corresponding
955    DescriptorDatabase::FindAllExtensions() can be used to enumerate all
956    extensions of a given type.
957  * For each enum type Foo, protoc will generate functions:
958      const string& Foo_Name(Foo value);
959      bool Foo_Parse(const string& name, Foo* result);
960    The former returns the name of the enum constant corresponding to the given
961    value while the latter finds the value corresponding to a name.
962  * RepeatedField and RepeatedPtrField now have back-insertion iterators.
963  * String fields now have setters that take a char* and a size, in addition
964    to the existing ones that took char* or const string&.
965  * DescriptorPool::AllowUnknownDependencies() may be used to tell
966    DescriptorPool to create placeholder descriptors for unknown entities
967    referenced in a FileDescriptorProto.  This can allow you to parse a .proto
968    file without having access to other .proto files that it imports, for
969    example.
970  * Updated gtest to latest version.  The gtest package is now included as a
971    nested autoconf package, so it should be able to drop new versions into the
972    "gtest" subdirectory without modification.
973
974  Java
975  * Fixed bug where Message.mergeFrom(Message) failed to merge extensions.
976  * Message interface has new method toBuilder() which is equivalent to
977    newBuilderForType().mergeFrom(this).
978  * All enums now implement the ProtocolMessageEnum interface.
979  * Setting a field to null now throws NullPointerException.
980  * Fixed tendency for TextFormat's parsing to overflow the stack when
981    parsing large string values.  The underlying problem is with Java's
982    regex implementation (which unfortunately uses recursive backtracking
983    rather than building an NFA).  Worked around by making use of possessive
984    quantifiers.
985  * Generated service classes now also generate pure interfaces.  For a service
986    Foo, Foo.Interface is a pure interface containing all of the service's
987    defined methods.  Foo.newReflectiveService() can be called to wrap an
988    instance of this interface in a class that implements the generic
989    RpcService interface, which provides reflection support that is usually
990    needed by RPC server implementations.
991  * RPC interfaces now support blocking operation in addition to non-blocking.
992    The protocol compiler generates separate blocking and non-blocking stubs
993    which operate against separate blocking and non-blocking RPC interfaces.
994    RPC implementations will have to implement the new interfaces in order to
995    support blocking mode.
996  * New I/O methods parseDelimitedFrom(), mergeDelimitedFrom(), and
997    writeDelimitedTo() read and write "delimited" messages from/to a stream,
998    meaning that the message size precedes the data.  This way, you can write
999    multiple messages to a stream without having to worry about delimiting
1000    them yourself.
1001  * Throw a more descriptive exception when build() is double-called.
1002  * Add a method to query whether CodedInputStream is at the end of the input
1003    stream.
1004  * Add a method to reset a CodedInputStream's size counter; useful when
1005    reading many messages with the same stream.
1006  * equals() and hashCode() now account for unknown fields.
1007
1008  Python
1009  * Added slicing support for repeated scalar fields. Added slice retrieval and
1010    removal of repeated composite fields.
1011  * Updated RPC interfaces to allow for blocking operation.  A client may
1012    now pass None for a callback when making an RPC, in which case the
1013    call will block until the response is received, and the response
1014    object will be returned directly to the caller.  This interface change
1015    cannot be used in practice until RPC implementations are updated to
1016    implement it.
1017  * Changes to input_stream.py should make protobuf compatible with appengine.
1018
10192008-11-25 version 2.0.3:
1020
1021  protoc
1022  * Enum values may now have custom options, using syntax similar to field
1023    options.
1024  * Fixed bug where .proto files which use custom options but don't actually
1025    define them (i.e. they import another .proto file defining the options)
1026    had to explicitly import descriptor.proto.
1027  * Adjacent string literals in .proto files will now be concatenated, like in
1028    C.
1029  * If an input file is a Windows absolute path (e.g. "C:\foo\bar.proto") and
1030    the import path only contains "." (or contains "." but does not contain
1031    the file), protoc incorrectly thought that the file was under ".", because
1032    it thought that the path was relative (since it didn't start with a slash).
1033    This has been fixed.
1034
1035  C++
1036  * Generated message classes now have a Swap() method which efficiently swaps
1037    the contents of two objects.
1038  * All message classes now have a SpaceUsed() method which returns an estimate
1039    of the number of bytes of allocated memory currently owned by the object.
1040    This is particularly useful when you are reusing a single message object
1041    to improve performance but want to make sure it doesn't bloat up too large.
1042  * New method Message::SerializeAsString() returns a string containing the
1043    serialized data.  May be more convenient than calling
1044    SerializeToString(string*).
1045  * In debug mode, log error messages when string-type fields are found to
1046    contain bytes that are not valid UTF-8.
1047  * Fixed bug where a message with multiple extension ranges couldn't parse
1048    extensions.
1049  * Fixed bug where MergeFrom(const Message&) didn't do anything if invoked on
1050    a message that contained no fields (but possibly contained extensions).
1051  * Fixed ShortDebugString() to not be O(n^2).  Durr.
1052  * Fixed crash in TextFormat parsing if the first token in the input caused a
1053    tokenization error.
1054  * Fixed obscure bugs in zero_copy_stream_impl.cc.
1055  * Added support for HP C++ on Tru64.
1056  * Only build tests on "make check", not "make".
1057  * Fixed alignment issue that caused crashes when using DynamicMessage on
1058    64-bit Sparc machines.
1059  * Simplify template usage to work with MSVC 2003.
1060  * Work around GCC 4.3.x x86_64 compiler bug that caused crashes on startup.
1061    (This affected Fedora 9 in particular.)
1062  * Now works on "Solaris 10 using recent Sun Studio".
1063
1064  Java
1065  * New overload of mergeFrom() which parses a slice of a byte array instead
1066    of the whole thing.
1067  * New method ByteString.asReadOnlyByteBuffer() does what it sounds like.
1068  * Improved performance of isInitialized() when optimizing for code size.
1069
1070  Python
1071  * Corrected ListFields() signature in Message base class to match what
1072    subclasses actually implement.
1073  * Some minor refactoring.
1074  * Don't pass self as first argument to superclass constructor (no longer
1075    allowed in Python 2.6).
1076
10772008-09-29 version 2.0.2:
1078
1079  General
1080  * License changed from Apache 2.0 to New BSD.
1081  * It is now possible to define custom "options", which are basically
1082    annotations which may be placed on definitions in a .proto file.
1083    For example, you might define a field option called "foo" like so:
1084      import "google/protobuf/descriptor.proto"
1085      extend google.protobuf.FieldOptions {
1086        optional string foo = 12345;
1087      }
1088    Then you annotate a field using the "foo" option:
1089      message MyMessage {
1090        optional int32 some_field = 1 [(foo) = "bar"]
1091      }
1092    The value of this option is then visible via the message's
1093    Descriptor:
1094      const FieldDescriptor* field =
1095        MyMessage::descriptor()->FindFieldByName("some_field");
1096      assert(field->options().GetExtension(foo) == "bar");
1097    This feature has been implemented and tested in C++ and Java.
1098    Other languages may or may not need to do extra work to support
1099    custom options, depending on how they construct descriptors.
1100
1101  C++
1102  * Fixed some GCC warnings that only occur when using -pedantic.
1103  * Improved static initialization code, making ordering more
1104    predictable among other things.
1105  * TextFormat will no longer accept messages which contain multiple
1106    instances of a singular field.  Previously, the latter instance
1107    would overwrite the former.
1108  * Now works on systems that don't have hash_map.
1109
1110  Java
1111  * Print @Override annotation in generated code where appropriate.
1112
1113  Python
1114  * Strings now use the "unicode" type rather than the "str" type.
1115    String fields may still be assigned ASCII "str" values; they will
1116    automatically be converted.
1117  * Adding a property to an object representing a repeated field now
1118    raises an exception.  For example:
1119      # No longer works (and never should have).
1120      message.some_repeated_field.foo = 1
1121
1122  Windows
1123  * We now build static libraries rather than DLLs by default on MSVC.
1124    See vsprojects/readme.txt for more information.
1125
11262008-08-15 version 2.0.1:
1127
1128  protoc
1129  * New flags --encode and --decode can be used to convert between protobuf text
1130    format and binary format from the command-line.
1131  * New flag --descriptor_set_out can be used to write FileDescriptorProtos for
1132    all parsed files directly into a single output file.  This is particularly
1133    useful if you wish to parse .proto files from programs written in languages
1134    other than C++: just run protoc as a background process and have it output
1135    a FileDescriptorList, then parse that natively.
1136  * Improved error message when an enum value's name conflicts with another
1137    symbol defined in the enum type's scope, e.g. if two enum types declared
1138    in the same scope have values with the same name.  This is disallowed for
1139    compatibility with C++, but this wasn't clear from the error.
1140  * Fixed absolute output paths on Windows.
1141  * Allow trailing slashes in --proto_path mappings.
1142
1143  C++
1144  * Reflection objects are now per-class rather than per-instance.  To make this
1145    possible, the Reflection interface had to be changed such that all methods
1146    take the Message instance as a parameter.  This change improves performance
1147    significantly in memory-bandwidth-limited use cases, since it makes the
1148    message objects smaller.  Note that source-incompatible interface changes
1149    like this will not be made again after the library leaves beta.
1150  * Heuristically detect sub-messages when printing unknown fields.
1151  * Fix static initialization ordering bug that caused crashes at startup when
1152    compiling on Mac with static linking.
1153  * Fixed TokenizerTest when compiling with -DNDEBUG on Linux.
1154  * Fixed incorrect definition of kint32min.
1155  * Fix bytes type setter to work with byte sequences with embedded NULLs.
1156  * Other irrelevant tweaks.
1157
1158  Java
1159  * Fixed UnknownFieldSet's parsing of varints larger than 32 bits.
1160  * Fixed TextFormat's parsing of "inf" and "nan".
1161  * Fixed TextFormat's parsing of comments.
1162  * Added info to Java POM that will be required when we upload the
1163    package to a Maven repo.
1164
1165  Python
1166  * MergeFrom(message) and CopyFrom(message) are now implemented.
1167  * SerializeToString() raises an exception if the message is missing required
1168    fields.
1169  * Code organization improvements.
1170  * Fixed doc comments for RpcController and RpcChannel, which had somehow been
1171    swapped.
1172  * Fixed text_format_test on Windows where floating-point exponents sometimes
1173    contain extra zeros.
1174  * Fix Python service CallMethod() implementation.
1175
1176  Other
1177  * Improved readmes.
1178  * VIM syntax highlighting improvements.
1179
11802008-07-07 version 2.0.0:
1181
1182  * First public release.
1183