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 protobuf+unsubscr...@googlegroups.com For more options, visit this group at http://groups.google.com/group/protobuf?hl=en -~----------~----~----~----~------~----~------~--~---