Updated documentation covering all this has been submitted and should go
live in a couple hours.


On Wed, May 13, 2009 at 4:06 PM, Kenton Varda <ken...@google.com> wrote:

> Here's the major changes (from CHANGES.txt):
>   General
>   * Repeated fields of primitive types (types other that string, group, and
>     nested messages) may now use the option [packed = true] to get a more
>     efficient encoding.  In the new encoding, the entire list is written
>     as a single byte blob using the "length-delimited" wire type.  Within
>     this blob, the individual values are encoded the same way they would
>     be normally except without a tag before each value (thus, they are
>     tightly "packed").
>   * For each field, the generated code contains an integer constant
> assigned
>     to the field number.  For example, the .proto file:
>       message Foo { optional int bar_baz = 123; }
>     would generate the following constants, all with the integer value 123:
>       C++:     Foo::kBarBazFieldNumber
>       Java:    Foo.BAR_BAZ_FIELD_NUMBER
>       Python:  Foo.BAR_BAZ_FIELD_NUMBER
>     Constants are also generated for extensions, with the same naming
> scheme.
>     These constants may be used as switch cases.
>   * Updated bundled Google Test to version 1.3.0.  Google Test is now
> bundled
>     in its verbatim form as a nested autoconf package, so you can drop in
> any
>     other version of Google Test if needed.
>   * optimize_for = SPEED is now the default, by popular demand.  Use
>     optimize_for = CODE_SIZE if code size is more important in your app.
>   * It is now an error to define a default value for a repeated field.
>     Previously, this was silently ignored (it had no effect on the
> generated
>     code).
>   * Fields can now be marked deprecated like:
>       optional int32 foo = 1 [deprecated = true];
>     Currently this does not have any actual effect, but in the future the
> code
>     generators may generate deprecation annotations in each language.
>   * Cross-compiling should now be possible using the --with-protoc option
> to
>     configure.  See README.txt for more info.
>   protoc
>   * --error_format=msvs option causes errors to be printed in Visual Studio
>     format, which should allow them to be clicked on in the build log to go
>     directly to the error location.
>   * The type name resolver will no longer resolve type names to fields.
>  For
>     example, this now works:
>       message Foo {}
>       message Bar {
>         optional int32 Foo = 1;
>         optional Foo baz = 2;
>       }
>     Previously, the type of "baz" would resolve to "Bar.Foo", and you'd get
>     an error because Bar.Foo is a field, not a type.  Now the type of "baz"
>     resolves to the message type Foo.  This change is unlikely to make a
>     difference to anyone who follows the Protocol Buffers style guide.
>   C++
>   * Several optimizations, including but not limited to:
>     - Serialization, especially to flat arrays, is 10%-50% faster, possibly
>       more for small objects.
>     - Several descriptor operations which previously required locking no
> longer
>       do.
>     - Descriptors are now constructed lazily on first use, rather than at
>       process startup time.  This should save memory in programs which do
> not
>       use descriptors or reflection.
>     - UnknownFieldSet completely redesigned to be more efficient
> (especially in
>       terms of memory usage).
>     - Various optimizations to reduce code size (though the serialization
> speed
>        optimizations increased code size).
>   * Message interface has method ParseFromBoundedZeroCopyStream() which
> parses
>     a limited number of bytes from an input stream rather than parsing
> until
>     EOF.
>   * GzipInputStream and GzipOutputStream support reading/writing gzip- or
>     zlib-compressed streams if zlib is available.
>     (google/protobuf/io/gzip_stream.h)
>   * DescriptorPool::FindAllExtensions() and corresponding
>     DescriptorDatabase::FindAllExtensions() can be used to enumerate all
>     extensions of a given type.
>   * For each enum type Foo, protoc will generate functions:
>       const string& Foo_Name(Foo value);
>       bool Foo_Parse(const string& name, Foo* result);
>     The former returns the name of the enum constant corresponding to the
> given
>     value while the latter finds the value corresponding to a name.
>   * RepeatedField and RepeatedPtrField now have back-insertion iterators.
>   * String fields now have setters that take a char* and a size, in
> addition
>     to the existing ones that took char* or const string&.
>   * DescriptorPool::AllowUnknownDependencies() may be used to tell
>     DescriptorPool to create placeholder descriptors for unknown entities
>     referenced in a FileDescriptorProto.  This can allow you to parse a
> .proto
>     file without having access to other .proto files that it imports, for
>     example.
>   * Updated gtest to latest version.  The gtest package is now included as
> a
>     nested autoconf package, so it should be able to drop new versions into
> the
>     "gtest" subdirectory without modification.
>   Java
>   * Fixed bug where Message.mergeFrom(Message) failed to merge extensions.
>   * Message interface has new method toBuilder() which is equivalent to
>     newBuilderForType().mergeFrom(this).
>   * All enums now implement the ProtocolMessageEnum interface.
>   * Setting a field to null now throws NullPointerException.
>   * Fixed tendency for TextFormat's parsing to overflow the stack when
>     parsing large string values.  The underlying problem is with Java's
>     regex implementation (which unfortunately uses recursive backtracking
>     rather than building an NFA).  Worked around by making use of possesive
>     quantifiers.
>   * Generated service classes now also generate pure interfaces.  For a
> service
>     Foo, Foo.Interface is a pure interface containing all of the service's
>     defined methods.  Foo.newReflectiveService() can be called to wrap an
>     instance of this interface in a class that implements the generic
>     RpcService interface, which provides reflection support that is usually
>     needed by RPC server implementations.
>   * RPC interfaces now support blocking operation in addition to
> non-blocking.
>     The protocol compiler generates separate blocking and non-blocking
> stubs
>     which operate against separate blocking and non-blocking RPC
> interfaces.
>     RPC implementations will have to implement the new interfaces in order
> to
>     support blocking mode.
>   * New I/O methods parseDelimitedFrom(), mergeDelimitedFrom(), and
>     writeDelimitedTo() read and write "delemited" messages from/to a
> stream,
>     meaning that the message size precedes the data.  This way, you can
> write
>     multiple messages to a stream without having to worry about delimiting
>     them yourself.
>   * Throw a more descriptive exception when build() is double-called.
>   * Add a method to query whether CodedInputStream is at the end of the
> input
>     stream.
>   * Add a method to reset a CodedInputStream's size counter; useful when
>     reading many messages with the same stream.
>   * equals() and hashCode() now account for unknown fields.
>   Python
>   * Added slicing support for repeated scalar fields. Added slice retrieval
> and
>     removal of repeated composite fields.
>   * Updated RPC interfaces to allow for blocking operation.  A client may
>     now pass None for a callback when making an RPC, in which case the
>     call will block until the response is received, and the response
>     object will be returned directly to the caller.  This interface change
>     cannot be used in practice until RPC implementations are updated to
>     implement it.
>   * Changes to input_stream.py should make protobuf compatible with
> appengine.

You received this message because you are subscribed to the Google Groups 
"Protocol Buffers" group.
To post to this group, send email to protobuf@googlegroups.com
To unsubscribe from this group, send email to 
For more options, visit this group at 

Reply via email to