PageRenderTime 28ms CodeModel.GetById 21ms app.highlight 2ms RepoModel.GetById 1ms app.codeStats 0ms

/thirdparty/breakpad/third_party/protobuf/protobuf/CHANGES.txt

http://github.com/tomahawk-player/tomahawk
Plain Text | 470 lines | 427 code | 43 blank | 0 comment | 0 complexity | 4ad7461d73a583001234311328d8b21a MD5 | raw file
  12011-05-01 version 2.4.1:
  2
  3  C++
  4  * Fixed the frendship problem for old compilers to make the library now gcc 3
  5    compatible again.
  6  * Fixed vcprojects/extract_includes.bat to extract compiler/plugin.h.
  7
  8  Java
  9  * Removed usages of JDK 1.6 only features to make the library now JDK 1.5
 10    compatible again.
 11  * Fixed a bug about negative enum values.
 12  * serialVersionUID is now defined in generated messages for java serializing.
 13  * Fixed protoc to use java.lang.Object, which makes "Object" now a valid
 14    message name again.
 15
 16  Python
 17  * Experimental C++ implementation now requires C++ protobuf library installed.
 18    See the README.txt in the python directory for details.
 19
 202011-02-02 version 2.4.0:
 21
 22  General
 23  * The RPC (cc|java|py)_generic_services default value is now false instead of
 24    true.
 25  * Custom options can have aggregate types. For example,
 26      message MyOption {
 27        optional string comment = 1;
 28        optional string author = 2;
 29      }
 30      extend google.protobuf.FieldOptions {
 31        optional MyOption myoption = 12345;
 32      }
 33    This option can now be set as follows:
 34      message SomeType {
 35        optional int32 field = 1 [(myoption) = { comment:'x' author:'y' }];
 36      }
 37
 38  C++
 39  * Various speed and code size optimizations.
 40  * Added a release_foo() method on string and message fields.
 41  * Fixed gzip_output_stream sub-stream handling.
 42
 43  Java
 44  * Builders now maintain sub-builders for sub-messages. Use getFooBuilder() to
 45    get the builder for the sub-message "foo". This allows you to repeatedly
 46    modify deeply-nested sub-messages without rebuilding them.
 47  * Builder.build() no longer invalidates the Builder for generated messages
 48    (You may continue to modify it and then build another message).
 49  * Code generator will generate efficient equals() and hashCode()
 50    implementations if new option java_generate_equals_and_hash is enabled.
 51    (Otherwise, reflection-based implementations are used.)
 52  * Generated messages now implement Serializable.
 53  * Fields with [deprecated=true] will be marked with @Deprecated in Java.
 54  * Added lazy conversion of UTF-8 encoded strings to String objects to improve
 55    performance.
 56  * Various optimizations.
 57  * Enum value can be accessed directly, instead of calling getNumber() on the
 58    enum member.
 59  * For each enum value, an integer constant is also generated with the suffix
 60    _VALUE.
 61
 62  Python
 63  * Added an experimental  C++ implementation for Python messages via a Python
 64    extension. Implementation type is controlled by an environment variable
 65    PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION (valid values: "cpp" and "python")
 66    The default value is currently "python" but will be changed to "cpp" in
 67    future release.
 68  * Improved performance on message instantiation significantly.
 69    Most of the work on message instantiation is done just once per message
 70    class, instead of once per message instance.
 71  * Improved performance on text message parsing.
 72  * Allow add() to forward keyword arguments to the concrete class.
 73      E.g. instead of
 74        item = repeated_field.add()
 75        item.foo = bar
 76        item.baz = quux
 77      You can do:
 78        repeated_field.add(foo=bar, baz=quux)
 79  * Added a sort() interface to the BaseContainer.
 80  * Added an extend() method to repeated composite fields.
 81  * Added UTF8 debug string support.
 82
 832010-01-08 version 2.3.0:
 84
 85  General
 86  * Parsers for repeated numeric fields now always accept both packed and
 87    unpacked input.  The [packed=true] option only affects serializers.
 88    Therefore, it is possible to switch a field to packed format without
 89    breaking backwards-compatibility -- as long as all parties are using
 90    protobuf 2.3.0 or above, at least.
 91  * The generic RPC service code generated by the C++, Java, and Python
 92    generators can be disabled via file options:
 93      option cc_generic_services = false;
 94      option java_generic_services = false;
 95      option py_generic_services = false;
 96    This allows plugins to generate alternative code, possibly specific to some
 97    particular RPC implementation.
 98
 99  protoc
100  * Now supports a plugin system for code generators.  Plugins can generate
101    code for new languages or inject additional code into the output of other
102    code generators.  Plugins are just binaries which accept a protocol buffer
103    on stdin and write a protocol buffer to stdout, so they may be written in
104    any language.  See src/google/protobuf/compiler/plugin.proto.
105    **WARNING**:  Plugins are experimental.  The interface may change in a
106    future version.
107  * If the output location ends in .zip or .jar, protoc will write its output
108    to a zip/jar archive instead of a directory.  For example:
109      protoc --java_out=myproto_srcs.jar --python_out=myproto.zip myproto.proto
110    Currently the archive contents are not compressed, though this could change
111    in the future.
112  * inf, -inf, and nan can now be used as default values for float and double
113    fields.
114
115  C++
116  * Various speed and code size optimizations.
117  * DynamicMessageFactory is now fully thread-safe.
118  * Message::Utf8DebugString() method is like DebugString() but avoids escaping
119    UTF-8 bytes.
120  * Compiled-in message types can now contain dynamic extensions, through use
121    of CodedInputStream::SetExtensionRegistry().
122  * Now compiles shared libraries (DLLs) by default on Cygwin and MinGW, to
123    match other platforms.  Use --disable-shared to avoid this.
124
125  Java
126  * parseDelimitedFrom() and mergeDelimitedFrom() now detect EOF and return
127    false/null instead of throwing an exception.
128  * Fixed some initialization ordering bugs.
129  * Fixes for OpenJDK 7.
130
131  Python
132  * 10-25 times faster than 2.2.0, still pure-Python.
133  * Calling a mutating method on a sub-message always instantiates the message
134    in its parent even if the mutating method doesn't actually mutate anything
135    (e.g. parsing from an empty string).
136  * Expanded descriptors a bit.
137
1382009-08-11 version 2.2.0:
139
140  C++
141  * Lite mode:  The "optimize_for = LITE_RUNTIME" option causes the compiler
142    to generate code which only depends libprotobuf-lite, which is much smaller
143    than libprotobuf but lacks descriptors, reflection, and some other features.
144  * Fixed bug where Message.Swap(Message) was only implemented for
145    optimize_for_speed.  Swap now properly implemented in both modes
146    (Issue 91).
147  * Added RemoveLast and SwapElements(index1, index2) to Reflection
148    interface for repeated elements.
149  * Added Swap(Message) to Reflection interface.
150  * Floating-point literals in generated code that are intended to be
151    single-precision now explicitly have 'f' suffix to avoid pedantic warnings
152    produced by some compilers.
153  * The [deprecated=true] option now causes the C++ code generator to generate
154    a GCC-style deprecation annotation (no-op on other compilers).
155  * google::protobuf::GetEnumDescriptor<SomeGeneratedEnumType>() returns the
156    EnumDescriptor for that type -- useful for templates which cannot call
157    SomeGeneratedEnumType_descriptor().
158  * Various optimizations and obscure bug fixes.
159
160  Java
161  * Lite mode:  The "optimize_for = LITE_RUNTIME" option causes the compiler
162    to generate code which only depends libprotobuf-lite, which is much smaller
163    than libprotobuf but lacks descriptors, reflection, and some other features.
164  * Lots of style cleanups.
165
166  Python
167  * Fixed endianness bug with floats and doubles.
168  * Text format parsing support.
169  * Fix bug with parsing packed repeated fields in embedded messages.
170  * Ability to initialize fields by passing keyword args to constructor.
171  * Support iterators in extend and __setslice__ for containers.
172
1732009-05-13 version 2.1.0:
174
175  General
176  * Repeated fields of primitive types (types other that string, group, and
177    nested messages) may now use the option [packed = true] to get a more
178    efficient encoding.  In the new encoding, the entire list is written
179    as a single byte blob using the "length-delimited" wire type.  Within
180    this blob, the individual values are encoded the same way they would
181    be normally except without a tag before each value (thus, they are
182    tightly "packed").
183  * For each field, the generated code contains an integer constant assigned
184    to the field number.  For example, the .proto file:
185      message Foo { optional int bar_baz = 123; }
186    would generate the following constants, all with the integer value 123:
187      C++:     Foo::kBarBazFieldNumber
188      Java:    Foo.BAR_BAZ_FIELD_NUMBER
189      Python:  Foo.BAR_BAZ_FIELD_NUMBER
190    Constants are also generated for extensions, with the same naming scheme.
191    These constants may be used as switch cases.
192  * Updated bundled Google Test to version 1.3.0.  Google Test is now bundled
193    in its verbatim form as a nested autoconf package, so you can drop in any
194    other version of Google Test if needed.
195  * optimize_for = SPEED is now the default, by popular demand.  Use
196    optimize_for = CODE_SIZE if code size is more important in your app.
197  * It is now an error to define a default value for a repeated field.
198    Previously, this was silently ignored (it had no effect on the generated
199    code).
200  * Fields can now be marked deprecated like:
201      optional int32 foo = 1 [deprecated = true];
202    Currently this does not have any actual effect, but in the future the code
203    generators may generate deprecation annotations in each language.
204  * Cross-compiling should now be possible using the --with-protoc option to
205    configure.  See README.txt for more info.
206
207  protoc
208  * --error_format=msvs option causes errors to be printed in Visual Studio
209    format, which should allow them to be clicked on in the build log to go
210    directly to the error location.
211  * The type name resolver will no longer resolve type names to fields.  For
212    example, this now works:
213      message Foo {}
214      message Bar {
215        optional int32 Foo = 1;
216        optional Foo baz = 2;
217      }
218    Previously, the type of "baz" would resolve to "Bar.Foo", and you'd get
219    an error because Bar.Foo is a field, not a type.  Now the type of "baz"
220    resolves to the message type Foo.  This change is unlikely to make a
221    difference to anyone who follows the Protocol Buffers style guide.
222
223  C++
224  * Several optimizations, including but not limited to:
225    - Serialization, especially to flat arrays, is 10%-50% faster, possibly
226      more for small objects.
227    - Several descriptor operations which previously required locking no longer
228      do.
229    - Descriptors are now constructed lazily on first use, rather than at
230      process startup time.  This should save memory in programs which do not
231      use descriptors or reflection.
232    - UnknownFieldSet completely redesigned to be more efficient (especially in
233      terms of memory usage).
234    - Various optimizations to reduce code size (though the serialization speed
235      optimizations increased code size).
236  * Message interface has method ParseFromBoundedZeroCopyStream() which parses
237    a limited number of bytes from an input stream rather than parsing until
238    EOF.
239  * GzipInputStream and GzipOutputStream support reading/writing gzip- or
240    zlib-compressed streams if zlib is available.
241    (google/protobuf/io/gzip_stream.h)
242  * DescriptorPool::FindAllExtensions() and corresponding
243    DescriptorDatabase::FindAllExtensions() can be used to enumerate all
244    extensions of a given type.
245  * For each enum type Foo, protoc will generate functions:
246      const string& Foo_Name(Foo value);
247      bool Foo_Parse(const string& name, Foo* result);
248    The former returns the name of the enum constant corresponding to the given
249    value while the latter finds the value corresponding to a name.
250  * RepeatedField and RepeatedPtrField now have back-insertion iterators.
251  * String fields now have setters that take a char* and a size, in addition
252    to the existing ones that took char* or const string&.
253  * DescriptorPool::AllowUnknownDependencies() may be used to tell
254    DescriptorPool to create placeholder descriptors for unknown entities
255    referenced in a FileDescriptorProto.  This can allow you to parse a .proto
256    file without having access to other .proto files that it imports, for
257    example.
258  * Updated gtest to latest version.  The gtest package is now included as a
259    nested autoconf package, so it should be able to drop new versions into the
260    "gtest" subdirectory without modification.
261
262  Java
263  * Fixed bug where Message.mergeFrom(Message) failed to merge extensions.
264  * Message interface has new method toBuilder() which is equivalent to
265    newBuilderForType().mergeFrom(this).
266  * All enums now implement the ProtocolMessageEnum interface.
267  * Setting a field to null now throws NullPointerException.
268  * Fixed tendency for TextFormat's parsing to overflow the stack when
269    parsing large string values.  The underlying problem is with Java's
270    regex implementation (which unfortunately uses recursive backtracking
271    rather than building an NFA).  Worked around by making use of possesive
272    quantifiers.
273  * Generated service classes now also generate pure interfaces.  For a service
274    Foo, Foo.Interface is a pure interface containing all of the service's
275    defined methods.  Foo.newReflectiveService() can be called to wrap an
276    instance of this interface in a class that implements the generic
277    RpcService interface, which provides reflection support that is usually
278    needed by RPC server implementations.
279  * RPC interfaces now support blocking operation in addition to non-blocking.
280    The protocol compiler generates separate blocking and non-blocking stubs
281    which operate against separate blocking and non-blocking RPC interfaces.
282    RPC implementations will have to implement the new interfaces in order to
283    support blocking mode.
284  * New I/O methods parseDelimitedFrom(), mergeDelimitedFrom(), and
285    writeDelimitedTo() read and write "delemited" messages from/to a stream,
286    meaning that the message size precedes the data.  This way, you can write
287    multiple messages to a stream without having to worry about delimiting
288    them yourself.
289  * Throw a more descriptive exception when build() is double-called.
290  * Add a method to query whether CodedInputStream is at the end of the input
291    stream.
292  * Add a method to reset a CodedInputStream's size counter; useful when
293    reading many messages with the same stream.
294  * equals() and hashCode() now account for unknown fields.
295
296  Python
297  * Added slicing support for repeated scalar fields. Added slice retrieval and
298    removal of repeated composite fields.
299  * Updated RPC interfaces to allow for blocking operation.  A client may
300    now pass None for a callback when making an RPC, in which case the
301    call will block until the response is received, and the response
302    object will be returned directly to the caller.  This interface change
303    cannot be used in practice until RPC implementations are updated to
304    implement it.
305  * Changes to input_stream.py should make protobuf compatible with appengine.
306
3072008-11-25 version 2.0.3:
308
309  protoc
310  * Enum values may now have custom options, using syntax similar to field
311    options.
312  * Fixed bug where .proto files which use custom options but don't actually
313    define them (i.e. they import another .proto file defining the options)
314    had to explicitly import descriptor.proto.
315  * Adjacent string literals in .proto files will now be concatenated, like in
316    C.
317  * If an input file is a Windows absolute path (e.g. "C:\foo\bar.proto") and
318    the import path only contains "." (or contains "." but does not contain
319    the file), protoc incorrectly thought that the file was under ".", because
320    it thought that the path was relative (since it didn't start with a slash).
321    This has been fixed.
322
323  C++
324  * Generated message classes now have a Swap() method which efficiently swaps
325    the contents of two objects.
326  * All message classes now have a SpaceUsed() method which returns an estimate
327    of the number of bytes of allocated memory currently owned by the object.
328    This is particularly useful when you are reusing a single message object
329    to improve performance but want to make sure it doesn't bloat up too large.
330  * New method Message::SerializeAsString() returns a string containing the
331    serialized data.  May be more convenient than calling
332    SerializeToString(string*).
333  * In debug mode, log error messages when string-type fields are found to
334    contain bytes that are not valid UTF-8.
335  * Fixed bug where a message with multiple extension ranges couldn't parse
336    extensions.
337  * Fixed bug where MergeFrom(const Message&) didn't do anything if invoked on
338    a message that contained no fields (but possibly contained extensions).
339  * Fixed ShortDebugString() to not be O(n^2).  Durr.
340  * Fixed crash in TextFormat parsing if the first token in the input caused a
341    tokenization error.
342  * Fixed obscure bugs in zero_copy_stream_impl.cc.
343  * Added support for HP C++ on Tru64.
344  * Only build tests on "make check", not "make".
345  * Fixed alignment issue that caused crashes when using DynamicMessage on
346    64-bit Sparc machines.
347  * Simplify template usage to work with MSVC 2003.
348  * Work around GCC 4.3.x x86_64 compiler bug that caused crashes on startup.
349    (This affected Fedora 9 in particular.)
350  * Now works on "Solaris 10 using recent Sun Studio".
351
352  Java
353  * New overload of mergeFrom() which parses a slice of a byte array instead
354    of the whole thing.
355  * New method ByteString.asReadOnlyByteBuffer() does what it sounds like.
356  * Improved performance of isInitialized() when optimizing for code size.
357
358  Python
359  * Corrected ListFields() signature in Message base class to match what
360    subclasses actually implement.
361  * Some minor refactoring.
362  * Don't pass self as first argument to superclass constructor (no longer
363    allowed in Python 2.6).
364
3652008-09-29 version 2.0.2:
366
367  General
368  * License changed from Apache 2.0 to New BSD.
369  * It is now possible to define custom "options", which are basically
370    annotations which may be placed on definitions in a .proto file.
371    For example, you might define a field option called "foo" like so:
372      import "google/protobuf/descriptor.proto"
373      extend google.protobuf.FieldOptions {
374        optional string foo = 12345;
375      }
376    Then you annotate a field using the "foo" option:
377      message MyMessage {
378        optional int32 some_field = 1 [(foo) = "bar"]
379      }
380    The value of this option is then visible via the message's
381    Descriptor:
382      const FieldDescriptor* field =
383        MyMessage::descriptor()->FindFieldByName("some_field");
384      assert(field->options().GetExtension(foo) == "bar");
385    This feature has been implemented and tested in C++ and Java.
386    Other languages may or may not need to do extra work to support
387    custom options, depending on how they construct descriptors.
388
389  C++
390  * Fixed some GCC warnings that only occur when using -pedantic.
391  * Improved static initialization code, making ordering more
392    predictable among other things.
393  * TextFormat will no longer accept messages which contain multiple
394    instances of a singular field.  Previously, the latter instance
395    would overwrite the former.
396  * Now works on systems that don't have hash_map.
397
398  Java
399  * Print @Override annotation in generated code where appropriate.
400
401  Python
402  * Strings now use the "unicode" type rather than the "str" type.
403    String fields may still be assigned ASCII "str" values; they will
404    automatically be converted.
405  * Adding a property to an object representing a repeated field now
406    raises an exception.  For example:
407      # No longer works (and never should have).
408      message.some_repeated_field.foo = 1
409
410  Windows
411  * We now build static libraries rather than DLLs by default on MSVC.
412    See vsprojects/readme.txt for more information.
413
4142008-08-15 version 2.0.1:
415
416  protoc
417  * New flags --encode and --decode can be used to convert between protobuf text
418    format and binary format from the command-line.
419  * New flag --descriptor_set_out can be used to write FileDescriptorProtos for
420    all parsed files directly into a single output file.  This is particularly
421    useful if you wish to parse .proto files from programs written in languages
422    other than C++: just run protoc as a background process and have it output
423    a FileDescriptorList, then parse that natively.
424  * Improved error message when an enum value's name conflicts with another
425    symbol defined in the enum type's scope, e.g. if two enum types declared
426    in the same scope have values with the same name.  This is disallowed for
427    compatibility with C++, but this wasn't clear from the error.
428  * Fixed absolute output paths on Windows.
429  * Allow trailing slashes in --proto_path mappings.
430
431  C++
432  * Reflection objects are now per-class rather than per-instance.  To make this
433    possible, the Reflection interface had to be changed such that all methods
434    take the Message instance as a parameter.  This change improves performance
435    significantly in memory-bandwidth-limited use cases, since it makes the
436    message objects smaller.  Note that source-incompatible interface changes
437    like this will not be made again after the library leaves beta.
438  * Heuristically detect sub-messages when printing unknown fields.
439  * Fix static initialization ordering bug that caused crashes at startup when
440    compiling on Mac with static linking.
441  * Fixed TokenizerTest when compiling with -DNDEBUG on Linux.
442  * Fixed incorrect definition of kint32min.
443  * Fix bytes type setter to work with byte sequences with embedded NULLs.
444  * Other irrelevant tweaks.
445
446  Java
447  * Fixed UnknownFieldSet's parsing of varints larger than 32 bits.
448  * Fixed TextFormat's parsing of "inf" and "nan".
449  * Fixed TextFormat's parsing of comments.
450  * Added info to Java POM that will be required when we upload the
451    package to a Maven repo.
452
453  Python
454  * MergeFrom(message) and CopyFrom(message) are now implemented.
455  * SerializeToString() raises an exception if the message is missing required
456    fields.
457  * Code organization improvements.
458  * Fixed doc comments for RpcController and RpcChannel, which had somehow been
459    swapped.
460  * Fixed text_format_test on Windows where floating-point exponents sometimes
461    contain extra zeros.
462  * Fix Python service CallMethod() implementation.
463
464  Other
465  * Improved readmes.
466  * VIM syntax highlighting improvements.
467
4682008-07-07 version 2.0.0:
469
470  * First public release.