AuroraMiddleware/protobuf
1
0
Fork 0
Code Issues 1 Pull Requests Projects Releases Wiki Activity

Merge 3.2.x branch into master (#2648)

Browse Source 
* Down-integrate internal changes to github.

* Update conformance test failure list.

* Explicitly import used class in nano test to avoid random test fail.

* Update _GNUC_VER to use the correct implementation of atomic operation
on Mac.

* maps_test.js: check whether Symbol is defined before using it (#2524)

Symbol is not yet available on older versions of Node.js and so this
test fails with them. This change just directly checks whether Symbol is
available before we try to use it.

* Added well_known_types_embed.cc to CLEANFILES so that it gets cleaned up

* Updated Makefile.am to fix out-of-tree builds

* Added Bazel genrule for generating well_known_types_embed.cc

In pull request #2517 I made this change for the CMake and autotools
builds but forgot to do it for the Bazel build.

* Update _GNUC_VER to use the correct implementation of atomic operation on Mac.

* Add new js file in extra dist.

* Bump version number to 3.2.0

* Fixed issue with autoloading - Invalid paths (#2538)

* PHP fix int64 decoding (#2516)

* fix int64 decoding

* fix int64 decoding + tests

* Fix int64 decoding on 32-bit machines.

* Fix warning in compiler/js/embed.cc

embed.cc: In function ‘std::string CEscape(const string&)’:
embed.cc:51:32: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
   for (int i = 0; i < str.size(); ++i) {
                                ^

* Fix include in auto-generated well_known_types_embed.cc

Restore include style fix (e3da722) that has been trampled by
auto-generation of well_known_types_embed.cc

* Fixed cross compilations with the Autotools build

Pull request #2517 caused cross compilations to start failing, because
the js_embed binary was being built to run on the target platform
instead of on the build machine. This change updates the Autotools build
to use the AX_PROG_CXX_FOR_BUILD macro to find a suitable compiler for
the build machine and always use that when building js_embed.

* Minor fix for autocreated object repeated fields and maps.

- If setting/clearing a repeated field/map that was objects, check the class
  before checking the autocreator.
- Just to be paranoid, don’t mutate within copy/mutableCopy for the autocreated
  classes to ensure there is less chance of issues if someone does something
  really crazy threading wise.
- Some more tests for the internal AutocreatedArray/AutocreatedDictionary
  classes to ensure things are working as expected.
- Add Xcode 8.2 to the full_mac_build.sh supported list.

* Fix generation of extending nested messages in JavaScript (#2439)

* Fix generation of extending nested messages in JavaScript

* Added missing test8.proto to build

* Fix generated code when there is no namespace but there is enum definition.

* Decoding unknown field should succeed.

* Add embed.cc in src/Makefile.am to fix dist check.

* Fixed "make distcheck" for the Autotools build

To make the test pass I needed to fix out-of-tree builds and update
EXTRA_DIST and CLEANFILES.

* Remove redundent embed.cc from src/Makefile.am

* Update version number to 3.2.0-rc.1 (#2578)

* Change protoc-artifacts version to 3.2.0-rc.1

* Update version number to 3.2.0rc2

* Update change logs for 3.2.0 release.

* Update php README

* Update upb, fixes some bugs (including a hash table problem). (#2611)

* Update upb, fixes some bugs (including a hash table problem).

* Ruby: added a test for the previous hash table corruption.

Verified that this triggers the bug in the currently released
version.

* Ruby: bugfix for SEGV.

* Ruby: removed old code for dup'ing defs.

* Reverting deployment target to 7.0 (#2618)

The Protobuf library doesn’t require the 7.1 deployment target so
reverting it back to 7.0

* Fix typo that breaks builds on big-endian (#2632)

* Bump version number to 3.2.0
This commit is contained in:
Paul Yang 2017-01-31 09:17:32 -08:00 committed by GitHub
parent 9d3288e651
commit 7f3e237071
146 changed files with 6844 additions and 4572 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
CHANGES.txt
View File

@ -1,3 +1,75 @@
2017-01-23 version 3.2.0 (C++/Java/Python/PHP/Ruby/Objective-C/C#/JavaScript/Lite)
General
* Added protoc version number to protoc plugin protocol. It can be used by
protoc plugin to detect which version of protoc is used with the plugin and
mitigate known problems in certain version of protoc.
C++
* The default parsing byte size limit has been raised from 64MB to 2GB.
* Added rvalue setters for non-arena string fields.
* Enabled debug logging for Android.
* Fixed a double-free problem when using Reflection::SetAllocatedMessage()
with extension fields.
* Fixed several deterministic serialization bugs:
* MessageLite::SerializeAsString() now respects the global deterministic
serialization flag.
* Extension fields are serialized deterministically as well. Fixed protocol
compiler to correctly report importing-self as an error.
* Fixed FileDescriptor::DebugString() to print custom options correctly.
* Various performance/codesize optimizations and cleanups.
Java
* The default parsing byte size limit has been raised from 64MB to 2GB.
* Added recursion limit when parsing JSON.
* Fixed a bug that enumType.getDescriptor().getOptions() doesn't have custom
options.
* Fixed generated code to support field numbers up to 2^29-1.
Python
* You can now assign NumPy scalars/arrays (np.int32, np.int64) to protobuf
fields, and assigning other numeric types has been optimized for
performance.
* Pure-Python: message types are now garbage-collectable.
* Python/C++: a lot of internal cleanup/refactoring.
PHP (Alpha)
* For 64-bit integers type (int64/uint64/sfixed64/fixed64/sint64), use PHP
integer on 64-bit environment and PHP string on 32-bit environment.
* PHP generated code also conforms to PSR-4 now.
* Fixed ZTS build for c extension.
* Fixed c extension build on Mac.
* Fixed c extension build on 32-bit linux.
* Fixed the bug that message without namespace is not found in the descriptor
pool. (#2240)
* Fixed the bug that repeated field is not iterable in c extension.
* Message names Empty will be converted to GPBEmpty in generated code.
* Added phpdoc in generated files.
* The released API is almost stable. Unless there is large problem, we won't
change it. See
https://developers.google.com/protocol-buffers/docs/reference/php-generated
for more details.
Objective-C
* Added support for push/pop of the stream limit on CodedInputStream for
anyone doing manual parsing.
C#
* No changes.
Ruby
* Message objects now support #respond_to? for field getters/setters.
* You can now compare “message == non_message_object” and it will return false
instead of throwing an exception.
* JRuby: fixed #hashCode to properly reflect the values in the message.
Javascript
* Deserialization of repeated fields no longer has quadratic performance
behavior.
* UTF-8 encoding/decoding now properly supports high codepoints.
* Added convenience methods for some well-known types: Any, Struct, and
Timestamp. These make it easier to convert data between native JavaScript
types and the well-known protobuf types.
2016-09-23 version 3.1.0 (C++/Java/Python/PHP/Ruby/Objective-C/C#/JavaScript/Lite)
General
* Proto3 support in PHP (alpha).
@ -40,23 +112,23 @@
APIs and share the same generated code. Users don’t need to re-generate
code for the same proto definition when they want to switch the
implementation later. The pure PHP package is included in the php/src
directory, and the c extension is included in the php/ext directory.
directory, and the c extension is included in the php/ext directory.
Both implementations provide idiomatic PHP APIs:
* All messages and enums are defined as PHP classes.
* All message fields can only be accessed via getter/setter.
* Both repeated field elements and map elements are stored in containers
that act like a normal PHP array.
Unlike several existing third-party PHP implementations for protobuf, our
implementations are built on a "strongly-typed" philosophy: message fields
and array/map containers will throw exceptions eagerly when values of the
incorrect type (not including those that can be type converted, e.g.,
double <-> integer <-> numeric string) are inserted.
Currently, pure PHP runtime supports php5.5, 5.6 and 7 on linux. C
extension runtime supports php5.5 and 5.6 on linux.
See php/README.md for more details about installment. See
https://developers.google.com/protocol-buffers/docs/phptutorial for more
details about APIs.

1
Makefile.am
View File

@ -825,6 +825,7 @@ js_EXTRA_DIST= \
js/binary/decoder.js \
js/binary/decoder_test.js \
js/binary/encoder.js \
js/binary/message_test.js \
js/binary/proto_test.js \
js/binary/reader.js \
js/binary/reader_test.js \

4
Protobuf.podspec
View File

@ -5,7 +5,7 @@
# dependent projects use the :git notation to refer to the library.
Pod::Spec.new do |s|
s.name = 'Protobuf'
s.version = '3.1.0'
s.version = '3.2.0'
s.summary = 'Protocol Buffers v.3 runtime library for Objective-C.'
s.homepage = 'https://github.com/google/protobuf'
s.license = 'New BSD'
@ -34,7 +34,7 @@ Pod::Spec.new do |s|
s.user_target_xcconfig = { 'GCC_PREPROCESSOR_DEFINITIONS' => '$(inherited) GPB_USE_PROTOBUF_FRAMEWORK_IMPORTS=1' }
s.pod_target_xcconfig = { 'GCC_PREPROCESSOR_DEFINITIONS' => '$(inherited) GPB_USE_PROTOBUF_FRAMEWORK_IMPORTS=1' }
s.ios.deployment_target = '7.1'
s.ios.deployment_target = '7.0'
s.osx.deployment_target = '10.9'
s.watchos.deployment_target = '2.0'
s.requires_arc = false

2
configure.ac
View File

@ -17,7 +17,7 @@ AC_PREREQ(2.59)
# In the SVN trunk, the version should always be the next anticipated release
# version with the "-pre" suffix. (We used to use "-SNAPSHOT" but this pushed
# the size of one file name in the dist tarfile over the 99-char limit.)
AC_INIT([Protocol Buffers],[3.1.0],[protobuf@googlegroups.com],[protobuf])
AC_INIT([Protocol Buffers],[3.2.0],[protobuf@googlegroups.com],[protobuf])
AM_MAINTAINER_MODE([enable])

2
csharp/Google.Protobuf.Tools.nuspec
View File

@ -5,7 +5,7 @@
<title>Google Protocol Buffers tools</title>
<summary>Tools for Protocol Buffers - Google's data interchange format.</summary>
<description>See project site for more info.</description>
<version>3.1.0</version>
<version>3.2.0</version>
<authors>Google Inc.</authors>
<owners>protobuf-packages</owners>
<licenseUrl>https://github.com/google/protobuf/blob/master/LICENSE</licenseUrl>

3
csharp/src/Google.Protobuf/Reflection/Descriptor.cs
View File

@ -1766,6 +1766,9 @@ namespace Google.Protobuf.Reflection {
[pbr::OriginalName("TYPE_STRING")] String = 9,
/// <summary>
/// Tag-delimited aggregate.
/// Group type is deprecated and not supported in proto3. However, Proto3
/// implementations should still be able to parse the group wire format and
/// treat group fields as unknown fields.
/// </summary>
[pbr::OriginalName("TYPE_GROUP")] Group = 10,
/// <summary>

10
csharp/src/Google.Protobuf/WellKnownTypes/Type.cs
View File

@ -1311,7 +1311,10 @@ namespace Google.Protobuf.WellKnownTypes {
public const int NameFieldNumber = 1;
private string name_ = "";
/// <summary>
/// The option's name. For example, `"java_package"`.
/// The option's name. For protobuf built-in options (options defined in
/// descriptor.proto), this is the short name. For example, `"map_entry"`.
/// For custom options, it should be the fully-qualified name. For example,
/// `"google.api.http"`.
/// </summary>
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public string Name {
@ -1325,7 +1328,10 @@ namespace Google.Protobuf.WellKnownTypes {
public const int ValueFieldNumber = 2;
private global::Google.Protobuf.WellKnownTypes.Any value_;
/// <summary>
/// The option's value. For example, `"com.google.protobuf"`.
/// The option's value packed in an Any message. If the value is a primitive,
/// the corresponding wrapper type defined in google/protobuf/wrappers.proto
/// should be used. If the value is an enum, it should be stored as an int32
/// value using the google.protobuf.Int32Value type.
/// </summary>
[global::System.Diagnostics.DebuggerNonUserCodeAttribute]
public global::Google.Protobuf.WellKnownTypes.Any Value {

2
csharp/src/Google.Protobuf/project.json
View File

@ -1,5 +1,5 @@
{
"version": "3.1.0",
"version": "3.2.0",
"title": "Google Protocol Buffers",
"description": "See project site for more info.",
"authors": [ "Google Inc." ],

2
java/core/pom.xml
View File

@ -6,7 +6,7 @@
<parent>
<groupId>com.google.protobuf</groupId>
<artifactId>protobuf-parent</artifactId>
<version>3.1.0</version>
<version>3.2.0</version>
</parent>
<artifactId>protobuf-java</artifactId>

1
java/core/src/main/java/com/google/protobuf/AbstractMessageLite.java
View File

@ -48,7 +48,6 @@ public abstract class AbstractMessageLite<
BuilderType extends AbstractMessageLite.Builder<MessageType, BuilderType>>
implements MessageLite {
protected int memoizedHashCode = 0;
@Override
public ByteString toByteString() {
try {

1
java/core/src/main/java/com/google/protobuf/FieldSet.java
View File

@ -220,6 +220,7 @@ final class FieldSet<FieldDescriptorType extends
return fields.entrySet().iterator();
}
/**
* Useful for implementing
* {@link Message#hasField(Descriptors.FieldDescriptor)}.

2
java/core/src/main/java/com/google/protobuf/MapFieldLite.java
View File

@ -83,7 +83,7 @@ public final class MapFieldLite<K, V> extends LinkedHashMap<K, V> {
@Override public void clear() {
ensureMutable();
clear();
super.clear();
}
@Override public V put(K key, V value) {

21
java/core/src/main/java/com/google/protobuf/SmallSortedMap.java
View File

@ -197,6 +197,7 @@ class SmallSortedMap<K extends Comparable<K>, V> extends AbstractMap<K, V> {
overflowEntries.entrySet();
}
@Override
public int size() {
return entryList.size() + overflowEntries.size();
@ -356,6 +357,7 @@ class SmallSortedMap<K extends Comparable<K>, V> extends AbstractMap<K, V> {
return lazyEntrySet;
}
/**
* @throws UnsupportedOperationException if {@link #makeImmutable()} has
* has been called.
@ -525,6 +527,7 @@ class SmallSortedMap<K extends Comparable<K>, V> extends AbstractMap<K, V> {
}
}
/**
* Iterator implementation that switches from the entry array to the overflow
* entries appropriately.
@ -617,43 +620,43 @@ class SmallSortedMap<K extends Comparable<K>, V> extends AbstractMap<K, V> {
return (Iterable<T>) ITERABLE;
}
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof SmallSortedMap)) {
return super.equals(o);
}
SmallSortedMap<?, ?> other = (SmallSortedMap<?, ?>) o;
final int size = size();
if (size != other.size()) {
return false;
}
// Best effort try to avoid allocating an entry set.
final int numArrayEntries = getNumArrayEntries();
if (numArrayEntries != other.getNumArrayEntries()) {
return entrySet().equals(other.entrySet());
}
for (int i = 0; i < numArrayEntries; i++) {
if (!getArrayEntryAt(i).equals(other.getArrayEntryAt(i))) {
return false;
}
}
if (numArrayEntries != size) {
return overflowEntries.equals(other.overflowEntries);
}
return true;
}
@Override
public int hashCode() {
int h = 0;

33
java/core/src/main/java/com/google/protobuf/UnknownFieldSet.java
View File

@ -31,7 +31,6 @@
package com.google.protobuf;
import com.google.protobuf.AbstractMessageLite.Builder.LimitedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
@ -39,6 +38,7 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.TreeMap;
@ -58,7 +58,9 @@ import java.util.TreeMap;
*/
public final class UnknownFieldSet implements MessageLite {
private UnknownFieldSet() {}
private UnknownFieldSet() {
fields = null;
}
/** Create a new {@link Builder}. */
public static Builder newBuilder() {
@ -82,16 +84,18 @@ public final class UnknownFieldSet implements MessageLite {
return defaultInstance;
}
private static final UnknownFieldSet defaultInstance =
new UnknownFieldSet(Collections.<Integer, Field>emptyMap());
new UnknownFieldSet(Collections.<Integer, Field>emptyMap(),
Collections.<Integer, Field>emptyMap());
/**
* Construct an {@code UnknownFieldSet} around the given map. The map is
* expected to be immutable.
*/
private UnknownFieldSet(final Map<Integer, Field> fields) {
private UnknownFieldSet(final Map<Integer, Field> fields,
final Map<Integer, Field> fieldsDescending) {
this.fields = fields;
}
private Map<Integer, Field> fields;
private final Map<Integer, Field> fields;
@Override
@ -224,10 +228,8 @@ public final class UnknownFieldSet implements MessageLite {
}
}
/**
* Get the number of bytes required to encode this set using
* {@code MessageSet} wire format.
*/
/** Get the number of bytes required to encode this set using {@code MessageSet} wire format. */
public int getSerializedSizeAsMessageSet() {
int result = 0;
for (final Map.Entry<Integer, Field> entry : fields.entrySet()) {
@ -343,12 +345,13 @@ public final class UnknownFieldSet implements MessageLite {
*/
@Override
public UnknownFieldSet build() {
getFieldBuilder(0); // Force lastField to be built.
getFieldBuilder(0); // Force lastField to be built.
final UnknownFieldSet result;
if (fields.isEmpty()) {
result = getDefaultInstance();
} else {
result = new UnknownFieldSet(Collections.unmodifiableMap(fields));
Map<Integer, Field> descendingFields = null;
result = new UnknownFieldSet(Collections.unmodifiableMap(fields), descendingFields);
}
fields = null;
return result;
@ -363,8 +366,9 @@ public final class UnknownFieldSet implements MessageLite {
@Override
public Builder clone() {
getFieldBuilder(0); // Force lastField to be built.
Map<Integer, Field> descendingFields = null;
return UnknownFieldSet.newBuilder().mergeFrom(
new UnknownFieldSet(fields));
new UnknownFieldSet(fields, descendingFields));
}
@Override
@ -841,9 +845,10 @@ public final class UnknownFieldSet implements MessageLite {
}
}
/**
* Get the number of bytes required to encode this field, including field
* number, using {@code MessageSet} wire format.
* Get the number of bytes required to encode this field, including field number, using {@code
* MessageSet} wire format.
*/
public int getSerializedSizeAsMessageSetExtension(final int fieldNumber) {
int result = 0;

30
java/core/src/main/java/com/google/protobuf/UnknownFieldSetLite.java
View File

@ -186,10 +186,11 @@ public final class UnknownFieldSetLite {
output.writeRawMessageSetExtension(fieldNumber, (ByteString) objects[i]);
}
}
/**
* Get the number of bytes required to encode this field, including field
* number, using {@code MessageSet} wire format.
* Get the number of bytes required to encode this field, including field number, using {@code
* MessageSet} wire format.
*/
public int getSerializedSizeAsMessageSet() {
int size = memoizedSerializedSize;
@ -251,6 +252,24 @@ public final class UnknownFieldSetLite {
return size;
}
private static boolean equals(int[] tags1, int[] tags2, int count) {
for (int i = 0; i < count; ++i) {
if (tags1[i] != tags2[i]) {
return false;
}
}
return true;
}
private static boolean equals(Object[] objects1, Object[] objects2, int count) {
for (int i = 0; i < count; ++i) {
if (!objects1[i].equals(objects2[i])) {
return false;
}
}
return true;
}
@Override
public boolean equals(Object obj) {
@ -268,9 +287,8 @@ public final class UnknownFieldSetLite {
UnknownFieldSetLite other = (UnknownFieldSetLite) obj;
if (count != other.count
// TODO(dweis): Only have to compare up to count but at worst 2x worse than we need to do.
|| !Arrays.equals(tags, other.tags)
|| !Arrays.deepEquals(objects, other.objects)) {
|| !equals(tags, other.tags, count)
|| !equals(objects, other.objects, count)) {
return false;
}

8
java/core/src/test/java/com/google/protobuf/UnknownFieldSetLiteTest.java
View File

@ -53,6 +53,14 @@ public class UnknownFieldSetLiteTest extends TestCase {
assertEquals(ByteString.EMPTY, toByteString(unknownFields));
}
public void testEmptyInstance() {
UnknownFieldSetLite instance = UnknownFieldSetLite.newInstance();
assertEquals(0, instance.getSerializedSize());
assertEquals(ByteString.EMPTY, toByteString(instance));
assertEquals(UnknownFieldSetLite.getDefaultInstance(), instance);
}
public void testMergeFieldFrom() throws IOException {
Foo foo = Foo.newBuilder()
.setValue(2)

2
java/pom.xml
View File

@ -11,7 +11,7 @@
<groupId>com.google.protobuf</groupId>
<artifactId>protobuf-parent</artifactId>
<version>3.1.0</version>
<version>3.2.0</version>
<packaging>pom</packaging>
<name>Protocol Buffers [Parent]</name>

2
java/util/pom.xml
View File

@ -6,7 +6,7 @@
<parent>
<groupId>com.google.protobuf</groupId>
<artifactId>protobuf-parent</artifactId>
<version>3.1.0</version>
<version>3.2.0</version>
</parent>
<artifactId>protobuf-java-util</artifactId>

2
javanano/pom.xml
View File

@ -10,7 +10,7 @@
</parent>
<groupId>com.google.protobuf.nano</groupId>
<artifactId>protobuf-javanano</artifactId>
<version>3.1.0</version>
<version>3.2.0</version>
<packaging>bundle</packaging>
<name>Protocol Buffer JavaNano API</name>
<description>

5
javanano/src/test/java/com/google/protobuf/nano/NanoTest.java
View File

@ -30,8 +30,11 @@
package com.google.protobuf.nano;
import com.google.protobuf.nano.MapTestProto.TestMap;
import com.google.protobuf.nano.CodedOutputByteBufferNano;
import com.google.protobuf.nano.EnumClassNanos.EnumClassNano;
import com.google.protobuf.nano.EnumClassNanos.EnumClassNano.MessageScopeEnum;
import com.google.protobuf.nano.EnumClassNanos.FileScopeEnum;
import com.google.protobuf.nano.MapTestProto.TestMap;
import com.google.protobuf.nano.MapTestProto.TestMap.MessageValue;
import com.google.protobuf.nano.NanoAccessorsOuterClass.TestNanoAccessors;
import com.google.protobuf.nano.NanoHasOuterClass.TestAllTypesNanoHas;

4
js/binary/decoder.js
View File

@ -942,7 +942,7 @@ jspb.BinaryDecoder.prototype.readEnum = function() {
/**
* Reads and parses a UTF-8 encoded unicode string from the stream.
* The code is inspired by maps.vectortown.parse.StreamedDataViewReader.
* Supports codepoints from U+0000 up to U+10FFFF.
* Supports codepoints from U+0000 up to U+10FFFF.
* (http://en.wikipedia.org/wiki/UTF-8).
* @param {number} length The length of the string to read.
* @return {string} The decoded string.
@ -984,7 +984,7 @@ jspb.BinaryDecoder.prototype.readString = function(length) {
// 4. Add 0xDC00 to the low value to form the low surrogate:
var low = (codepoint & 1023) + 0xDC00;
var high = ((codepoint >> 10) & 1023) + 0xD800;
codeUnits.push(high, low)
codeUnits.push(high, low);
}
}
// String.fromCharCode.apply is faster than manually appending characters on

10
js/binary/decoder_test.js
View File

@ -209,25 +209,25 @@ describe('binaryDecoderTest', function() {
assertEquals(hashC, decoder.readFixedHash64());
assertEquals(hashD, decoder.readFixedHash64());
});
/**
* Test encoding and decoding utf-8.
*/
it('testUtf8', function() {
var encoder = new jspb.BinaryEncoder();
var ascii = "ASCII should work in 3, 2, 1..."
var ascii = "ASCII should work in 3, 2, 1...";
var utf8_two_bytes = "©";
var utf8_three_bytes = "❄";
var utf8_four_bytes = "😁";
encoder.writeString(ascii);
encoder.writeString(utf8_two_bytes);
encoder.writeString(utf8_three_bytes);
encoder.writeString(utf8_four_bytes);
var decoder = jspb.BinaryDecoder.alloc(encoder.end());
assertEquals(ascii, decoder.readString(ascii.length));
assertEquals(utf8_two_bytes, decoder.readString(utf8_two_bytes.length));
assertEquals(utf8_three_bytes, decoder.readString(utf8_three_bytes.length));

4
js/binary/encoder.js
View File

@ -452,9 +452,9 @@ jspb.BinaryEncoder.prototype.writeFixedHash64 = function(hash) {
*/
jspb.BinaryEncoder.prototype.writeString = function(value) {
var oldLength = this.buffer_.length;
for (var i = 0; i < value.length; i++) {
var c = value.charCodeAt(i);
if (c < 128) {

60
js/binary/message_test.js Normal file
View File

@ -0,0 +1,60 @@
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Test suite is written using Jasmine -- see http://jasmine.github.io/
goog.setTestOnly();
goog.require('goog.testing.asserts');
// CommonJS-LoadFromFile: test_pb proto.jspb.test
goog.require('proto.jspb.test.Deeply.Nested.Message');
// CommonJS-LoadFromFile: test2_pb proto.jspb.test
goog.require('proto.jspb.test.ForeignNestedFieldMessage');
describe('Message test suite', function() {
// Verify that we can successfully use a field referring to a nested message
// from a different .proto file.
it('testForeignNestedMessage', function() {
var msg = new proto.jspb.test.ForeignNestedFieldMessage();
var nested = new proto.jspb.test.Deeply.Nested.Message();
nested.setCount(5);
msg.setDeeplyNestedMessage(nested);
assertEquals(5, msg.getDeeplyNestedMessage().getCount());
// After a serialization-deserialization round trip we should get back the
// same data we started with.
var serialized = msg.serializeBinary();
var deserialized =
proto.jspb.test.ForeignNestedFieldMessage.deserializeBinary(serialized);
assertEquals(5, deserialized.getDeeplyNestedMessage().getCount());
});
});

58
js/map.js
View File

@ -183,26 +183,39 @@ jspb.Map.fromObject = function(entries, valueCtor, valueFromObject) {
/**
* Helper: return an iterator over an array.
* Helper: an IteratorIterable over an array.
* @template T
* @param {!Array<T>} arr the array
* @return {!Iterator<T>} an iterator
* @implements {IteratorIterable<T>}
* @constructor @struct
* @private
*/
jspb.Map.arrayIterator_ = function(arr) {
var idx = 0;
return /** @type {!Iterator} */ ({
next: function() {
if (idx < arr.length) {
return { done: false, value: arr[idx++] };
} else {
return { done: true };
}
}
});
jspb.Map.ArrayIteratorIterable_ = function(arr) {
/** @type {number} @private */
this.idx_ = 0;
/** @const @private */
this.arr_ = arr;
};
/** @override @final */
jspb.Map.ArrayIteratorIterable_.prototype.next = function() {
if (this.idx_ < this.arr_.length) {
return {done: false, value: this.arr_[this.idx_++]};
} else {
return {done: true, value: undefined};
}
};
if (typeof(Symbol) != 'undefined') {
/** @override */
jspb.Map.ArrayIteratorIterable_.prototype[Symbol.iterator] = function() {
return this;
};
}
/**
* Returns the map's length (number of key/value pairs).
* @return {number}
@ -260,10 +273,9 @@ jspb.Map.prototype.getEntryList = function() {
/**
* Returns an iterator over [key, value] pairs in the map.
* Returns an iterator-iterable over [key, value] pairs in the map.
* Closure compiler sadly doesn't support tuples, ie. Iterator<[K,V]>.
* @return {!Iterator<!Array<K|V>>}
* The iterator
* @return {!IteratorIterable<!Array<K|V>>} The iterator-iterable.
*/
jspb.Map.prototype.entries = function() {
var entries = [];
@ -273,13 +285,13 @@ jspb.Map.prototype.entries = function() {
var entry = this.map_[strKeys[i]];
entries.push([entry.key, this.wrapEntry_(entry)]);
}
return jspb.Map.arrayIterator_(entries);
return new jspb.Map.ArrayIteratorIterable_(entries);
};
/**
* Returns an iterator over keys in the map.
* @return {!Iterator<K>} The iterator
* Returns an iterator-iterable over keys in the map.
* @return {!IteratorIterable<K>} The iterator-iterable.
*/
jspb.Map.prototype.keys = function() {
var keys = [];
@ -289,13 +301,13 @@ jspb.Map.prototype.keys = function() {
var entry = this.map_[strKeys[i]];
keys.push(entry.key);
}
return jspb.Map.arrayIterator_(keys);
return new jspb.Map.ArrayIteratorIterable_(keys);
};
/**
* Returns an iterator over values in the map.
* @return {!Iterator<V>} The iterator
* Returns an iterator-iterable over values in the map.
* @return {!IteratorIterable<V>} The iterator-iterable.
*/
jspb.Map.prototype.values = function() {
var values = [];
@ -305,7 +317,7 @@ jspb.Map.prototype.values = function() {
var entry = this.map_[strKeys[i]];
values.push(this.wrapEntry_(entry));
}
return jspb.Map.arrayIterator_(values);
return new jspb.Map.ArrayIteratorIterable_(values);
};

44
js/maps_test.js
View File

@ -288,6 +288,50 @@ function makeTests(msgInfo, submessageCtor, suffix) {
var a = msg.toArray();
assertEquals(a[0], entries); // retains original reference
});
/**
* Returns IteratorIterables for entries(), keys() and values().
*/
it('testIteratorIterables' + suffix, function() {
var msg = new msgInfo.constructor();
var m = msg.getMapStringStringMap();
m.set('key1', 'value1');
m.set('key2', 'value2');
var entryIterator = m.entries();
assertElementsEquals(entryIterator.next().value, ['key1', 'value1']);
assertElementsEquals(entryIterator.next().value, ['key2', 'value2']);
assertEquals(entryIterator.next().done, true);
if (typeof(Symbol) != 'undefined') {
var entryIterable = m.entries()[Symbol.iterator]();
assertElementsEquals(entryIterable.next().value, ['key1', 'value1']);
assertElementsEquals(entryIterable.next().value, ['key2', 'value2']);
assertEquals(entryIterable.next().done, true);
}
var keyIterator = m.keys();
assertEquals(keyIterator.next().value, 'key1');
assertEquals(keyIterator.next().value, 'key2');
assertEquals(keyIterator.next().done, true);
if (typeof(Symbol) != 'undefined') {
var keyIterable = m.keys()[Symbol.iterator]();
assertEquals(keyIterable.next().value, 'key1');
assertEquals(keyIterable.next().value, 'key2');
assertEquals(keyIterable.next().done, true);
}
var valueIterator = m.values();
assertEquals(valueIterator.next().value, 'value1');
assertEquals(valueIterator.next().value, 'value2');
assertEquals(valueIterator.next().done, true);
if (typeof(Symbol) != 'undefined') {
var valueIterable = m.values()[Symbol.iterator]();
assertEquals(valueIterable.next().value, 'value1');
assertEquals(valueIterable.next().value, 'value2');
assertEquals(valueIterable.next().done, true);
}
});
}
describe('mapsTest', function() {

34
js/message.js
View File

@ -174,6 +174,22 @@ goog.define('jspb.Message.GENERATE_TO_OBJECT', true);
goog.define('jspb.Message.GENERATE_FROM_OBJECT', !goog.DISALLOW_TEST_ONLY_CODE);
/**
* @define {boolean} Whether to generate toString methods for objects. Turn
* this off if you do use toString in your project and want to trim it from
* compiled JS.
*/
goog.define('jspb.Message.GENERATE_TO_STRING', true);
/**
* @define {boolean} Whether arrays passed to initialize() can be assumed to be
* local (e.g. not from another iframe) and thus safely classified with
* instanceof Array.
*/
goog.define('jspb.Message.ASSUME_LOCAL_ARRAYS', false);
/**
* @define {boolean} Turning on this flag does NOT change the behavior of JSPB
* and only affects private internal state. It may, however, break some
@ -363,6 +379,18 @@ jspb.Message.EMPTY_LIST_SENTINEL_ = goog.DEBUG && Object.freeze ?
[];
/**
* Returns true if the provided argument is an array.
* @param {*} o The object to classify as array or not.
* @return {boolean} True if the provided object is an array.
* @private
*/
jspb.Message.isArray_ = function(o) {
return jspb.Message.ASSUME_LOCAL_ARRAYS ? o instanceof Array :
goog.isArray(o);
};
/**
* Ensures that the array contains an extension object if necessary.
* If the array contains an extension object in its last position, then the
@ -383,8 +411,8 @@ jspb.Message.materializeExtensionObject_ = function(msg, suggestedPivot) {
// the object is not an array, since arrays are valid field values.
// NOTE(lukestebbing): We avoid looking at .length to avoid a JIT bug
// in Safari on iOS 8. See the description of CL/86511464 for details.
if (obj && typeof obj == 'object' && !goog.isArray(obj) &&
!(jspb.Message.SUPPORTS_UINT8ARRAY_ && obj instanceof Uint8Array)) {
if (obj && typeof obj == 'object' && !jspb.Message.isArray_(obj) &&
!(jspb.Message.SUPPORTS_UINT8ARRAY_ && obj instanceof Uint8Array)) {
msg.pivot_ = foundIndex - msg.arrayIndexOffset_;
msg.extensionObject_ = obj;
return;
@ -1140,6 +1168,7 @@ jspb.Message.prototype.toArray = function() {
if (jspb.Message.GENERATE_TO_STRING) {
/**
* Creates a string representation of the internal data array of this proto.
@ -1152,6 +1181,7 @@ jspb.Message.prototype.toString = function() {
return this.array.toString();
};
}
/**
* Gets the value of the extension field from the extended object.

19
js/message_test.js
View File

@ -76,12 +76,10 @@ goog.require('proto.jspb.test.TestGroup1');
goog.require('proto.jspb.test.TestMessageWithOneof');
goog.require('proto.jspb.test.TestReservedNames');
goog.require('proto.jspb.test.TestReservedNamesExtension');
goog.require('proto.jspb.test.Deeply.Nested.Message');
// CommonJS-LoadFromFile: test2_pb proto.jspb.test
goog.require('proto.jspb.test.ExtensionMessage');
goog.require('proto.jspb.test.TestExtensionsMessage');
goog.require('proto.jspb.test.ForeignNestedFieldMessage');
@ -1053,21 +1051,4 @@ describe('Message test suite', function() {
assertNan(message.getDefaultDoubleField());
});
// Verify that we can successfully use a field referring to a nested message
// from a different .proto file.
it('testForeignNestedMessage', function() {
var msg = new proto.jspb.test.ForeignNestedFieldMessage();
var nested = new proto.jspb.test.Deeply.Nested.Message();
nested.setCount(5);
msg.setDeeplyNestedMessage(nested);
assertEquals(5, msg.getDeeplyNestedMessage().getCount());
// After a serialization-deserialization round trip we should get back the
// same data we started with.
var serialized = msg.serializeBinary();
var deserialized =
proto.jspb.test.ForeignNestedFieldMessage.deserializeBinary(serialized);
assertEquals(5, deserialized.getDeeplyNestedMessage().getCount());
});
});

2
js/package.json
View File

@ -1,6 +1,6 @@
{
"name": "google-protobuf",
"version": "3.1.0",
"version": "3.2.0",
"description": "Protocol Buffers for JavaScript",
"main": "google-protobuf.js",
"files": [

14
objectivec/google/protobuf/Type.pbobjc.h
View File

@ -411,10 +411,20 @@ typedef GPB_ENUM(GPBOption_FieldNumber) {
**/
@interface GPBOption : GPBMessage
/** The option's name. For example, `"java_package"`. */
/**
* The option's name. For protobuf built-in options (options defined in
* descriptor.proto), this is the short name. For example, `"map_entry"`.
* For custom options, it should be the fully-qualified name. For example,
* `"google.api.http"`.
**/
@property(nonatomic, readwrite, copy, null_resettable) NSString *name;
/** The option's value. For example, `"com.google.protobuf"`. */
/**
* The option's value packed in an Any message. If the value is a primitive,
* the corresponding wrapper type defined in google/protobuf/wrappers.proto
* should be used. If the value is an enum, it should be stored as an int32
* value using the google.protobuf.Int32Value type.
**/
@property(nonatomic, readwrite, strong, null_resettable) GPBAny *value;
/** Test to see if @c value has been set. */
@property(nonatomic, readwrite) BOOL hasValue;

2
php/README.md
View File

@ -80,8 +80,6 @@ protoc --php_out=out_dir test.proto
## Usage
For general guide:
https://developers.google.com/protocol-buffers/phptutorial/
For generated code:
https://developers.google.com/protocol-buffers/docs/reference/php-generated

24
php/ext/google/protobuf/package.xml
View File

@ -10,11 +10,11 @@
<email>protobuf-opensource@google.com</email>
<active>yes</active>
</lead>
<date>2016-09-23</date>
<date>2017-01-13</date>
<time>16:06:07</time>
<version>
<release>3.1.0a1</release>
<api>3.1.0a1</api>
<release>3.2.0a1</release>
<api>3.2.0a1</api>
</version>
<stability>
<release>alpha</release>
@ -22,7 +22,7 @@
</stability>
<license uri="http://www.opensource.org/licenses/bsd-license.php">New BSD License</license>
<notes>
First alpha release.
Second alpha release.
</notes>
<contents>
<dir baseinstalldir="/" name="/">
@ -71,5 +71,21 @@ First alpha release.
First alpha release
</notes>
</release>
<release>
<version>
<release>3.2.0a1</release>
<api>3.2.0a1</api>
</version>
<stability>
<release>alpha</release>
<api>alpha</api>
</stability>
<date>2017-01-13</date>
<time>16:06:07</time>
<license uri="http://www.opensource.org/licenses/bsd-license.php">New BSD License</license>
<notes>
Second alpha release.
</notes>
</release>
</changelog>
</package>

2
php/ext/google/protobuf/protobuf.h
View File

@ -37,7 +37,7 @@
#include "upb.h"
#define PHP_PROTOBUF_EXTNAME "protobuf"
#define PHP_PROTOBUF_VERSION "3.1.0a1"
#define PHP_PROTOBUF_VERSION "3.2.0a1"
#define MAX_LENGTH_OF_INT64 20
#define SIZEOF_INT64 8

9
php/src/Google/Protobuf/Internal/GPBUtil.php
View File

@ -43,8 +43,15 @@ class GPBUtil
if ($isNeg) {
$value = bcsub(0, $value);
}
$high = (int) bcdiv(bcadd($value, 1), 4294967296);
$low = (int) bcmod($value, 4294967296);
$low = bcmod($value, 4294967296);
if (bccomp($low, 2147483647) > 0) {
$low = (int) bcsub($low, 4294967296);
} else {
$low = (int) $low;
}
if ($isNeg) {
$high = ~$high;
$low = ~$low;

85
php/src/Google/Protobuf/Internal/GPBWire.php
View File

@ -437,34 +437,65 @@ class GPBWire
public static function varint64Size($value)
{
if ($value < 0) {
return 10;
if (PHP_INT_SIZE == 4) {
if (bccomp($value, 0) < 0) {
return 10;
}
if (bccomp($value, 1 << 7) < 0) {
return 1;
}
if (bccomp($value, 1 << 14) < 0) {
return 2;
}
if (bccomp($value, 1 << 21) < 0) {
return 3;
}
if (bccomp($value, 1 << 28) < 0) {
return 4;
}
if (bccomp($value, '34359738368') < 0) {
return 5;
}
if (bccomp($value, '4398046511104') < 0) {
return 6;
}
if (bccomp($value, '562949953421312') < 0) {
return 7;
}
if (bccomp($value, '72057594037927936') < 0) {
return 8;
}
return 9;
} else {
if ($value < 0) {
return 10;
}
if ($value < (1 << 7)) {
return 1;
}
if ($value < (1 << 14)) {
return 2;
}
if ($value < (1 << 21)) {
return 3;
}
if ($value < (1 << 28)) {
return 4;
}
if ($value < (1 << 35)) {
return 5;
}
if ($value < (1 << 42)) {
return 6;
}
if ($value < (1 << 49)) {
return 7;
}
if ($value < (1 << 56)) {
return 8;
}
return 9;
}
if ($value < (1 << 7)) {
return 1;
}
if ($value < (1 << 14)) {
return 2;
}
if ($value < (1 << 21)) {
return 3;
}
if ($value < (1 << 28)) {
return 4;
}
if ($value < (1 << 35)) {
return 5;
}
if ($value < (1 << 42)) {
return 6;
}
if ($value < (1 << 49)) {
return 7;
}
if ($value < (1 << 56)) {
return 8;
}
return 9;
}
public static function serializeFieldToStream(

9
php/src/Google/Protobuf/Internal/InputStream.php
View File

@ -46,6 +46,9 @@ function combineInt32ToInt64($high, $low)
}
}
$result = bcadd(bcmul($high, 4294967296), $low);
if ($low < 0) {
$result = bcadd($result, 4294967296);
}
if ($isNeg) {
$result = bcsub(0, $result);
}
@ -179,9 +182,9 @@ class InputStream
if ($bits >= 32) {
$high |= (($b & 0x7F) << ($bits - 32));
} else if ($bits > 25){
$high_bits = $bits - 25;
$low = ($low | (($b & 0x7F) << $bits)) & (int) 0xFFFFFFFF;
$high = $b & ((0x1 << $high_bits) -1);
// $bits is 28 in this case.
$low |= (($b & 0x7F) << 28);
$high = ($b & 0x7F) >> 4;
} else {
$low |= (($b & 0x7F) << $bits);
}

20
php/src/Google/Protobuf/Internal/Message.php
View File

@ -186,17 +186,22 @@ class Message
case GPBType::FLOAT:
return 0.0;
case GPBType::UINT32:
case GPBType::UINT64:
case GPBType::INT32:
case GPBType::INT64:
case GPBType::FIXED32:
case GPBType::FIXED64:
case GPBType::SFIXED32:
case GPBType::SFIXED64:
case GPBType::SINT32:
case GPBType::SINT64:
case GPBType::ENUM:
return 0;
case GPBType::INT64:
case GPBType::UINT64:
case GPBType::FIXED64:
case GPBType::SFIXED64:
case GPBType::SINT64:
if (PHP_INT_SIZE === 4) {
return '0';
} else {
return 0;
}
case GPBType::BOOL:
return false;
case GPBType::STRING:
@ -406,6 +411,11 @@ class Message
$number = GPBWire::getTagFieldNumber($tag);
$field = $this->desc->getFieldByNumber($number);
// Check whether we retrieved a known field
if ($field === NULL) {
continue;
}
if (!$this->parseFieldFromStream($tag, $input, $field)) {
return false;
}

4
php/src/Google/Protobuf/descriptor.php
View File

@ -155,7 +155,11 @@ class Descriptor
public function getFieldByNumber($number)
{
if (!isset($this->field[$number])) {
return NULL;
} else {
return $this->field[$number];
}
}
public function setClass($klass)

41
php/tests/encode_decode_test.php
View File

@ -132,4 +132,45 @@ class EncodeDecodeTest extends TestBase
$to->decode(TestUtil::getGoldenTestUnpackedMessage());
TestUtil::assertTestPackedMessage($to);
}
public function testDecodeInt64()
{
// Read 64 testing
$testVals = array(
'10' => '100a',
'100' => '1064',
'800' => '10a006',
'6400' => '108032',
'70400' => '1080a604',
'774400' => '1080a22f',
'9292800' => '108098b704',
'74342400' => '1080c0b923',
'743424000' => '108080bfe202',
'8177664000' => '108080b5bb1e',
'65421312000' => '108080a8dbf301',
'785055744000' => '108080e0c7ec16',
'9420668928000' => '10808080dd969202',
'103627358208000' => '10808080fff9c717',
'1139900940288000' => '10808080f5bd978302',
'13678811283456000' => '10808080fce699a618',
'109430490267648000' => '10808080e0b7ceb1c201',
'984874412408832000' => '10808080e0f5c1bed50d',
);
$msg = new TestMessage();
foreach ($testVals as $original => $encoded) {
$msg->setOptionalInt64($original);
$data = $msg->encode();
$this->assertSame($encoded, bin2hex($data));
$msg->setOptionalInt64(0);
$msg->decode($data);
$this->assertEquals($original, $msg->getOptionalInt64());
}
}
public function testDecodeFieldNonExist() {
$data = hex2bin('c80501');
$m = new TestMessage();
$m->decode($data);
}
}

11
php/tests/generated_class_test.php
View File

@ -1,6 +1,7 @@
<?php
require_once('generated/NoNameSpace.php');
require_once('generated/NoNameSpaceEnum.php');
require_once('generated/NoNameSpaceMessage.php');
require_once('test_util.php');
use Google\Protobuf\Internal\RepeatedField;
@ -607,10 +608,14 @@ class GeneratedClassTest extends PHPUnit_Framework_TestCase
}
#########################################################
# Test oneof field.
# Test message/enum without namespace.
#########################################################
public function testMessageWithoutNamespace() {
$m = new NoNameSpace();
$m = new NoNameSpaceMessage();
}
public function testEnumWithoutNamespace() {
$m = new NoNameSpaceEnum();
}
}

50
php/tests/php_implementation_test.php
View File

@ -368,33 +368,31 @@ class ImplementationTest extends TestBase
$this->assertFalse($input->readVarint64($var));
// Read 64 testing
if (PHP_INT_SIZE > 4) {
$testVals = array(
'10' => '0a000000000000000000',
'100' => '64000000000000000000',
'800' => 'a0060000000000000000',
'6400' => '80320000000000000000',
'70400' => '80a60400000000000000',
'774400' => '80a22f00000000000000',
'9292800' => '8098b704000000000000',
'74342400' => '80c0b923000000000000',
'743424000' => '8080bfe2020000000000',
'8177664000' => '8080b5bb1e0000000000',
'65421312000' => '8080a8dbf30100000000',
'785055744000' => '8080e0c7ec1600000000',
'9420668928000' => '808080dd969202000000',
'103627358208000' => '808080fff9c717000000',
'1139900940288000' => '808080f5bd9783020000',
'13678811283456000' => '808080fce699a6180000',
'109430490267648000' => '808080e0b7ceb1c20100',
'984874412408832000' => '808080e0f5c1bed50d00',
);
$testVals = array(
'10' => '0a000000000000000000',
'100' => '64000000000000000000',
'800' => 'a0060000000000000000',
'6400' => '80320000000000000000',
'70400' => '80a60400000000000000',
'774400' => '80a22f00000000000000',
'9292800' => '8098b704000000000000',
'74342400' => '80c0b923000000000000',
'743424000' => '8080bfe2020000000000',
'8177664000' => '8080b5bb1e0000000000',
'65421312000' => '8080a8dbf30100000000',
'785055744000' => '8080e0c7ec1600000000',
'9420668928000' => '808080dd969202000000',
'103627358208000' => '808080fff9c717000000',
'1139900940288000' => '808080f5bd9783020000',
'13678811283456000' => '808080fce699a6180000',
'109430490267648000' => '808080e0b7ceb1c20100',
'984874412408832000' => '808080e0f5c1bed50d00',
);
foreach ($testVals as $original => $encoded) {
$input = new InputStream(hex2bin($encoded));
$this->assertTrue($input->readVarint64($var));
$this->assertSame($original, $var);
}
foreach ($testVals as $original => $encoded) {
$input = new InputStream(hex2bin($encoded));
$this->assertTrue($input->readVarint64($var));
$this->assertEquals($original, $var);
}
}

3
php/tests/proto/test.proto
View File

@ -92,7 +92,8 @@ message TestMessage {
int32 a = 1;
}
// NestedMessage nested_message = 90;
// Reserved for non-existing field test.
// int32 non_exist = 89;
}
enum TestEnum {

7
php/tests/proto/test_no_namespace.proto
View File

@ -1,5 +1,10 @@
syntax = "proto3";
message NoNameSpace {
message NoNameSpaceMessage {
int32 a = 1;
}
enum NoNameSpaceEnum {
VALUE_A = 0;
VALUE_B = 1;
}

2
protoc-artifacts/pom.xml
View File

@ -10,7 +10,7 @@
</parent>
<groupId>com.google.protobuf</groupId>
<artifactId>protoc</artifactId>
<version>3.1.0</version>
<version>3.2.0</version>
<packaging>pom</packaging>
<name>Protobuf Compiler</name>
<description>

2
python/google/protobuf/__init__.py
View File

@ -30,7 +30,7 @@
# Copyright 2007 Google Inc. All Rights Reserved.
__version__ = '3.1.0'
__version__ = '3.2.0'
if __name__ != '__main__':
try:

19
python/google/protobuf/internal/python_message.py
View File

@ -56,17 +56,6 @@ import sys
import weakref
import six
try:
import six.moves.copyreg as copyreg
except ImportError:
# On some platforms, for example gMac, we run native Python because there is
# nothing like hermetic Python. This means lesser control on the system and
# the six.moves package may be missing (is missing on 20150321 on gMac). Be
# extra conservative and try to load the old replacement if it fails.
try:
import copy_reg as copyreg #PY26
except ImportError:
import copyreg
# We use "as" to avoid name collisions with variables.
from google.protobuf.internal import containers
@ -179,7 +168,6 @@ class GeneratedProtocolMessageType(type):
_AddStaticMethods(cls)
_AddMessageMethods(descriptor, cls)
_AddPrivateHelperMethods(descriptor, cls)
copyreg.pickle(cls, lambda obj: (cls, (), obj.__getstate__()))
superclass = super(GeneratedProtocolMessageType, cls)
superclass.__init__(name, bases, dictionary)
@ -1271,6 +1259,12 @@ def _AddWhichOneofMethod(message_descriptor, cls):
cls.WhichOneof = WhichOneof
def _AddReduceMethod(cls):
def __reduce__(self): # pylint: disable=invalid-name
return (type(self), (), self.__getstate__())
cls.__reduce__ = __reduce__
def _Clear(self):
# Clear fields.
self._fields = {}
@ -1316,6 +1310,7 @@ def _AddMessageMethods(message_descriptor, cls):
_AddIsInitializedMethod(message_descriptor, cls)
_AddMergeFromMethod(cls)
_AddWhichOneofMethod(message_descriptor, cls)
_AddReduceMethod(cls)
# Adds methods which do not depend on cls.
cls.Clear = _Clear
cls.DiscardUnknownFields = _DiscardUnknownFields

2
python/google/protobuf/pyext/extension_dict.cc
View File

@ -126,6 +126,8 @@ PyObject* subscript(ExtensionDict* self, PyObject* key) {
CMessageClass* message_class = message_factory::GetOrCreateMessageClass(
cmessage::GetFactoryForMessage(self->parent),
descriptor->message_type());
ScopedPyObjectPtr message_class_handler(
reinterpret_cast<PyObject*>(message_class));
if (message_class == NULL) {
return NULL;
}

4
python/google/protobuf/pyext/message.cc
View File

@ -2342,8 +2342,10 @@ PyObject* InternalGetSubMessage(
const Message& sub_message = reflection->GetMessage(
*self->message, field_descriptor, factory->message_factory);
CMessageClass* message_class = message_factory::GetMessageClass(
CMessageClass* message_class = message_factory::GetOrCreateMessageClass(
factory, field_descriptor->message_type());
ScopedPyObjectPtr message_class_handler(
reinterpret_cast<PyObject*>(message_class));
if (message_class == NULL) {
return NULL;
}

7
python/setup.py
View File

@ -5,6 +5,7 @@ import glob
import os
import subprocess
import sys
import platform
# We must use setuptools, not distutils, because we need to use the
# namespace_packages option for the "google" package.
@ -189,6 +190,12 @@ if __name__ == '__main__':
if "clang" in os.popen('$CC --version 2> /dev/null').read():
extra_compile_args.append('-Wno-shorten-64-to-32')
v, _, _ = platform.mac_ver()
if v:
v = float('.'.join(v.split('.')[:2]))
if v >= 10.12:
extra_compile_args.append('-std=c++11')
if warnings_as_errors in sys.argv:
extra_compile_args.append('-Werror')
sys.argv.remove(warnings_as_errors)

4
ruby/ext/google/protobuf_c/defs.c
View File

@ -101,7 +101,7 @@ void DescriptorPool_mark(void* _self) {
void DescriptorPool_free(void* _self) {
DescriptorPool* self = _self;
upb_symtab_unref(self->symtab, &self->symtab);
upb_symtab_free(self->symtab);
xfree(self);
}
@ -113,7 +113,7 @@ void DescriptorPool_free(void* _self) {
*/
VALUE DescriptorPool_alloc(VALUE klass) {
DescriptorPool* self = ALLOC(DescriptorPool);
self->symtab = upb_symtab_new(&self->symtab);
self->symtab = upb_symtab_new();
return TypedData_Wrap_Struct(klass, &_DescriptorPool_type, self);
}

8
ruby/ext/google/protobuf_c/encode_decode.c
View File

@ -514,7 +514,7 @@ static void add_handlers_for_singular_field(upb_handlers *h,
case UPB_TYPE_INT64:
case UPB_TYPE_UINT64:
case UPB_TYPE_DOUBLE:
upb_shim_set(h, f, offset, -1);
upb_msg_setscalarhandler(h, f, offset, -1);
break;
case UPB_TYPE_STRING:
case UPB_TYPE_BYTES: {
@ -925,7 +925,7 @@ static void putmsg(VALUE msg, const Descriptor* desc,
static upb_selector_t getsel(const upb_fielddef *f, upb_handlertype_t type) {
upb_selector_t ret;
bool ok = upb_handlers_getselector(f, type, &ret);
UPB_ASSERT_VAR(ok, ok);
UPB_ASSERT(ok);
return ret;
}
@ -939,9 +939,9 @@ static void putstr(VALUE str, const upb_fielddef *f, upb_sink *sink) {
// We should be guaranteed that the string has the correct encoding because
// we ensured this at assignment time and then froze the string.
if (upb_fielddef_type(f) == UPB_TYPE_STRING) {
assert(rb_enc_from_index(ENCODING_GET(value)) == kRubyStringUtf8Encoding);
assert(rb_enc_from_index(ENCODING_GET(str)) == kRubyStringUtf8Encoding);
} else {
assert(rb_enc_from_index(ENCODING_GET(value)) == kRubyString8bitEncoding);
assert(rb_enc_from_index(ENCODING_GET(str)) == kRubyString8bitEncoding);
}
upb_sink_startstr(sink, getsel(f, UPB_HANDLER_STARTSTR), RSTRING_LEN(str),

2934
ruby/ext/google/protobuf_c/upb.c
View File

File diff suppressed because it is too large Load Diff

1240
ruby/ext/google/protobuf_c/upb.h
View File

File diff suppressed because it is too large Load Diff

2
ruby/google-protobuf.gemspec
View File

@ -1,6 +1,6 @@
Gem::Specification.new do |s|
s.name = "google-protobuf"
s.version = "3.1.0"
s.version = "3.2.0"
s.licenses = ["BSD"]
s.summary = "Protocol Buffers"
s.description = "Protocol Buffers are Google's data interchange format."

7
ruby/tests/basic.rb
View File

@ -667,6 +667,13 @@ module BasicTest
end
end
def test_map_corruption
# This pattern led to a crash in a previous version of upb/protobuf.
m = MapMessage.new(map_string_int32: { "aaa" => 1 })
m.map_string_int32['podid'] = 2
m.map_string_int32['aaa'] = 3
end
def test_map_encode_decode
m = MapMessage.new(
:map_string_int32 => {"a" => 1, "b" => 2},

6
src/Makefile.am
View File

@ -180,7 +180,7 @@ nobase_include_HEADERS = \
lib_LTLIBRARIES = libprotobuf-lite.la libprotobuf.la libprotoc.la
libprotobuf_lite_la_LIBADD = $(PTHREAD_LIBS)
libprotobuf_lite_la_LDFLAGS = -version-info 11:0:0 -export-dynamic -no-undefined
libprotobuf_lite_la_LDFLAGS = -version-info 12:0:0 -export-dynamic -no-undefined
libprotobuf_lite_la_SOURCES = \
google/protobuf/stubs/atomicops_internals_x86_gcc.cc \
google/protobuf/stubs/atomicops_internals_x86_msvc.cc \
@ -221,7 +221,7 @@ libprotobuf_lite_la_SOURCES = \
google/protobuf/io/zero_copy_stream_impl_lite.cc
libprotobuf_la_LIBADD = $(PTHREAD_LIBS)
libprotobuf_la_LDFLAGS = -version-info 11:0:0 -export-dynamic -no-undefined
libprotobuf_la_LDFLAGS = -version-info 12:0:0 -export-dynamic -no-undefined
libprotobuf_la_SOURCES = \
$(libprotobuf_lite_la_SOURCES) \
google/protobuf/any.pb.cc \
@ -305,7 +305,7 @@ libprotobuf_la_SOURCES = \
nodist_libprotobuf_la_SOURCES = $(nodist_libprotobuf_lite_la_SOURCES)
libprotoc_la_LIBADD = $(PTHREAD_LIBS) libprotobuf.la
libprotoc_la_LDFLAGS = -version-info 11:0:0 -export-dynamic -no-undefined
libprotoc_la_LDFLAGS = -version-info 12:0:0 -export-dynamic -no-undefined
libprotoc_la_SOURCES = \
google/protobuf/compiler/code_generator.cc \
google/protobuf/compiler/command_line_interface.cc \

82
src/google/protobuf/any.pb.cc
View File

@ -19,8 +19,11 @@
namespace google {
namespace protobuf {
class AnyDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Any> {};
AnyDefaultTypeInternal _Any_default_instance_;
class AnyDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Any> {
} _Any_default_instance_;
namespace protobuf_google_2fprotobuf_2fany_2eproto {
namespace {
@ -28,35 +31,30 @@ namespace {
} // namespace
const ::google::protobuf::uint32* protobuf_Offsets_google_2fprotobuf_2fany_2eproto() GOOGLE_ATTRIBUTE_COLD;
const ::google::protobuf::uint32* protobuf_Offsets_google_2fprotobuf_2fany_2eproto() {
static const ::google::protobuf::uint32 offsets[] = {
~0u, // no _has_bits_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Any, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Any, type_url_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Any, value_),
};
return offsets;
}
const ::google::protobuf::uint32 TableStruct::offsets[] = {
~0u, // no _has_bits_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Any, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Any, type_url_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Any, value_),
};
static const ::google::protobuf::internal::MigrationSchema schemas[] = {
{ 0, -1, sizeof(Any)},
};
static const ::google::protobuf::internal::DefaultInstanceData file_default_instances[] = {
{reinterpret_cast<const ::google::protobuf::Message*>(&_Any_default_instance_), NULL},
static ::google::protobuf::Message const * const file_default_instances[] = {
reinterpret_cast<const ::google::protobuf::Message*>(&_Any_default_instance_),
};
namespace {
void protobuf_AssignDescriptors() {
protobuf_AddDesc_google_2fprotobuf_2fany_2eproto();
AddDescriptors();
::google::protobuf::MessageFactory* factory = NULL;
AssignDescriptors(
"google/protobuf/any.proto", schemas, file_default_instances, protobuf_Offsets_google_2fprotobuf_2fany_2eproto(), factory,
"google/protobuf/any.proto", schemas, file_default_instances, TableStruct::offsets, factory,
file_level_metadata, NULL, NULL);
}
@ -73,24 +71,24 @@ void protobuf_RegisterTypes(const ::std::string&) {
} // namespace
void protobuf_ShutdownFile_google_2fprotobuf_2fany_2eproto() {
void TableStruct::Shutdown() {
_Any_default_instance_.Shutdown();
delete file_level_metadata[0].reflection;
}
void protobuf_InitDefaults_google_2fprotobuf_2fany_2eproto_impl() {
void TableStruct::InitDefaultsImpl() {
GOOGLE_PROTOBUF_VERIFY_VERSION;
::google::protobuf::internal::InitProtobufDefaults();
_Any_default_instance_.DefaultConstruct();
}
void protobuf_InitDefaults_google_2fprotobuf_2fany_2eproto() {
void InitDefaults() {
static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
::google::protobuf::GoogleOnceInit(&once, &protobuf_InitDefaults_google_2fprotobuf_2fany_2eproto_impl);
::google::protobuf::GoogleOnceInit(&once, &TableStruct::InitDefaultsImpl);
}
void protobuf_AddDesc_google_2fprotobuf_2fany_2eproto_impl() {
protobuf_InitDefaults_google_2fprotobuf_2fany_2eproto();
void AddDescriptorsImpl() {
InitDefaults();
static const char descriptor[] = {
"\n\031google/protobuf/any.proto\022\017google.prot"
"obuf\"&\n\003Any\022\020\n\010type_url\030\001 \001(\t\022\r\n\005value\030\002"
@ -103,20 +101,22 @@ void protobuf_AddDesc_google_2fprotobuf_2fany_2eproto_impl() {
descriptor, 205);
::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
"google/protobuf/any.proto", &protobuf_RegisterTypes);
::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_google_2fprotobuf_2fany_2eproto);
::google::protobuf::internal::OnShutdown(&TableStruct::Shutdown);
}
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_google_2fprotobuf_2fany_2eproto_once_);
void protobuf_AddDesc_google_2fprotobuf_2fany_2eproto() {
::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_google_2fprotobuf_2fany_2eproto_once_,
&protobuf_AddDesc_google_2fprotobuf_2fany_2eproto_impl);
void AddDescriptors() {
static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl);
}
// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_google_2fprotobuf_2fany_2eproto {
StaticDescriptorInitializer_google_2fprotobuf_2fany_2eproto() {
protobuf_AddDesc_google_2fprotobuf_2fany_2eproto();
struct StaticDescriptorInitializer {
StaticDescriptorInitializer() {
AddDescriptors();
}
} static_descriptor_initializer_google_2fprotobuf_2fany_2eproto_;
} static_descriptor_initializer;
} // namespace protobuf_google_2fprotobuf_2fany_2eproto
// ===================================================================
@ -141,7 +141,7 @@ const int Any::kValueFieldNumber;
Any::Any()
: ::google::protobuf::Message(), _internal_metadata_(NULL), _any_metadata_(&type_url_, &value_) {
if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
protobuf_InitDefaults_google_2fprotobuf_2fany_2eproto();
protobuf_google_2fprotobuf_2fany_2eproto::InitDefaults();
}
SharedCtor();
// @@protoc_insertion_point(constructor:google.protobuf.Any)
@ -185,12 +185,12 @@ void Any::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Any::descriptor() {
protobuf_AssignDescriptorsOnce();
return file_level_metadata[0].descriptor;
protobuf_google_2fprotobuf_2fany_2eproto::protobuf_AssignDescriptorsOnce();
return protobuf_google_2fprotobuf_2fany_2eproto::file_level_metadata[0].descriptor;
}
const Any& Any::default_instance() {
protobuf_InitDefaults_google_2fprotobuf_2fany_2eproto();
protobuf_google_2fprotobuf_2fany_2eproto::InitDefaults();
return *internal_default_instance();
}
@ -289,7 +289,7 @@ void Any::SerializeWithCachedSizes(
::google::protobuf::uint8* Any::InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const {
(void)deterministic; // Unused
(void)deterministic; // Unused
// @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Any)
// string type_url = 1;
if (this->type_url().size() > 0) {
@ -396,8 +396,8 @@ void Any::InternalSwap(Any* other) {
}
::google::protobuf::Metadata Any::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
return file_level_metadata[0];
protobuf_google_2fprotobuf_2fany_2eproto::protobuf_AssignDescriptorsOnce();
return protobuf_google_2fprotobuf_2fany_2eproto::file_level_metadata[0];
}
#if PROTOBUF_INLINE_NOT_IN_HEADERS

25
src/google/protobuf/any.pb.h
View File

@ -8,17 +8,18 @@
#include <google/protobuf/stubs/common.h>
#if GOOGLE_PROTOBUF_VERSION < 3001000
#if GOOGLE_PROTOBUF_VERSION < 3002000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3001000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#if 3002000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
@ -40,9 +41,16 @@ LIBPROTOBUF_EXPORT extern AnyDefaultTypeInternal _Any_default_instance_;
namespace google {
namespace protobuf {
namespace protobuf_google_2fprotobuf_2fany_2eproto {
// Internal implementation detail -- do not call these.
void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fany_2eproto();
void LIBPROTOBUF_EXPORT protobuf_InitDefaults_google_2fprotobuf_2fany_2eproto();
struct LIBPROTOBUF_EXPORT TableStruct {
static const ::google::protobuf::uint32 offsets[];
static void InitDefaultsImpl();
static void Shutdown();
};
void LIBPROTOBUF_EXPORT AddDescriptors();
void LIBPROTOBUF_EXPORT InitDefaults();
} // namespace protobuf_google_2fprotobuf_2fany_2eproto
// ===================================================================
@ -99,7 +107,8 @@ class LIBPROTOBUF_EXPORT Any : public ::google::protobuf::Message /* @@protoc_in
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
const PROTOBUF_FINAL {
return InternalSerializeWithCachedSizesToArray(false, output);
return InternalSerializeWithCachedSizesToArray(
::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
}
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
@ -158,11 +167,7 @@ class LIBPROTOBUF_EXPORT Any : public ::google::protobuf::Message /* @@protoc_in
::google::protobuf::internal::ArenaStringPtr value_;
mutable int _cached_size_;
::google::protobuf::internal::AnyMetadata _any_metadata_;
friend void LIBPROTOBUF_EXPORT protobuf_InitDefaults_google_2fprotobuf_2fany_2eproto_impl();
friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fany_2eproto_impl();
friend const ::google::protobuf::uint32* protobuf_Offsets_google_2fprotobuf_2fany_2eproto();
friend void protobuf_ShutdownFile_google_2fprotobuf_2fany_2eproto();
friend struct LIBPROTOBUF_EXPORT protobuf_google_2fprotobuf_2fany_2eproto::TableStruct;
};
// ===================================================================

174
src/google/protobuf/api.pb.cc
View File

@ -19,12 +19,15 @@
namespace google {
namespace protobuf {
class ApiDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Api> {};
ApiDefaultTypeInternal _Api_default_instance_;
class MethodDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Method> {};
MethodDefaultTypeInternal _Method_default_instance_;
class MixinDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Mixin> {};
MixinDefaultTypeInternal _Mixin_default_instance_;
class ApiDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Api> {
} _Api_default_instance_;
class MethodDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Method> {
} _Method_default_instance_;
class MixinDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Mixin> {
} _Mixin_default_instance_;
namespace protobuf_google_2fprotobuf_2fapi_2eproto {
namespace {
@ -32,41 +35,36 @@ namespace {
} // namespace
const ::google::protobuf::uint32* protobuf_Offsets_google_2fprotobuf_2fapi_2eproto() GOOGLE_ATTRIBUTE_COLD;
const ::google::protobuf::uint32* protobuf_Offsets_google_2fprotobuf_2fapi_2eproto() {
static const ::google::protobuf::uint32 offsets[] = {
~0u, // no _has_bits_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Api, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Api, name_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Api, methods_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Api, options_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Api, version_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Api, source_context_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Api, mixins_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Api, syntax_),
~0u, // no _has_bits_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Method, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Method, name_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Method, request_type_url_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Method, request_streaming_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Method, response_type_url_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Method, response_streaming_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Method, options_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Method, syntax_),
~0u, // no _has_bits_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Mixin, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Mixin, name_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Mixin, root_),
};
return offsets;
}
const ::google::protobuf::uint32 TableStruct::offsets[] = {
~0u, // no _has_bits_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Api, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Api, name_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Api, methods_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Api, options_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Api, version_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Api, source_context_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Api, mixins_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Api, syntax_),
~0u, // no _has_bits_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Method, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Method, name_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Method, request_type_url_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Method, request_streaming_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Method, response_type_url_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Method, response_streaming_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Method, options_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Method, syntax_),
~0u, // no _has_bits_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Mixin, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Mixin, name_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Mixin, root_),
};
static const ::google::protobuf::internal::MigrationSchema schemas[] = {
{ 0, -1, sizeof(Api)},
@ -74,19 +72,19 @@ static const ::google::protobuf::internal::MigrationSchema schemas[] = {
{ 22, -1, sizeof(Mixin)},
};
static const ::google::protobuf::internal::DefaultInstanceData file_default_instances[] = {
{reinterpret_cast<const ::google::protobuf::Message*>(&_Api_default_instance_), NULL},
{reinterpret_cast<const ::google::protobuf::Message*>(&_Method_default_instance_), NULL},
{reinterpret_cast<const ::google::protobuf::Message*>(&_Mixin_default_instance_), NULL},
static ::google::protobuf::Message const * const file_default_instances[] = {
reinterpret_cast<const ::google::protobuf::Message*>(&_Api_default_instance_),
reinterpret_cast<const ::google::protobuf::Message*>(&_Method_default_instance_),
reinterpret_cast<const ::google::protobuf::Message*>(&_Mixin_default_instance_),
};
namespace {
void protobuf_AssignDescriptors() {
protobuf_AddDesc_google_2fprotobuf_2fapi_2eproto();
AddDescriptors();
::google::protobuf::MessageFactory* factory = NULL;
AssignDescriptors(
"google/protobuf/api.proto", schemas, file_default_instances, protobuf_Offsets_google_2fprotobuf_2fapi_2eproto(), factory,
"google/protobuf/api.proto", schemas, file_default_instances, TableStruct::offsets, factory,
file_level_metadata, NULL, NULL);
}
@ -103,7 +101,7 @@ void protobuf_RegisterTypes(const ::std::string&) {
} // namespace
void protobuf_ShutdownFile_google_2fprotobuf_2fapi_2eproto() {
void TableStruct::Shutdown() {
_Api_default_instance_.Shutdown();
delete file_level_metadata[0].reflection;
_Method_default_instance_.Shutdown();
@ -112,12 +110,12 @@ void protobuf_ShutdownFile_google_2fprotobuf_2fapi_2eproto() {
delete file_level_metadata[2].reflection;
}
void protobuf_InitDefaults_google_2fprotobuf_2fapi_2eproto_impl() {
void TableStruct::InitDefaultsImpl() {
GOOGLE_PROTOBUF_VERIFY_VERSION;
::google::protobuf::protobuf_InitDefaults_google_2fprotobuf_2fsource_5fcontext_2eproto();
::google::protobuf::protobuf_InitDefaults_google_2fprotobuf_2ftype_2eproto();
::google::protobuf::internal::InitProtobufDefaults();
::google::protobuf::protobuf_google_2fprotobuf_2fsource_5fcontext_2eproto::InitDefaults();
::google::protobuf::protobuf_google_2fprotobuf_2ftype_2eproto::InitDefaults();
_Api_default_instance_.DefaultConstruct();
_Method_default_instance_.DefaultConstruct();
_Mixin_default_instance_.DefaultConstruct();
@ -125,12 +123,12 @@ void protobuf_InitDefaults_google_2fprotobuf_2fapi_2eproto_impl() {
::google::protobuf::SourceContext::internal_default_instance());
}
void protobuf_InitDefaults_google_2fprotobuf_2fapi_2eproto() {
void InitDefaults() {
static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
::google::protobuf::GoogleOnceInit(&once, &protobuf_InitDefaults_google_2fprotobuf_2fapi_2eproto_impl);
::google::protobuf::GoogleOnceInit(&once, &TableStruct::InitDefaultsImpl);
}
void protobuf_AddDesc_google_2fprotobuf_2fapi_2eproto_impl() {
protobuf_InitDefaults_google_2fprotobuf_2fapi_2eproto();
void AddDescriptorsImpl() {
InitDefaults();
static const char descriptor[] = {
"\n\031google/protobuf/api.proto\022\017google.prot"
"obuf\032$google/protobuf/source_context.pro"
@ -156,22 +154,24 @@ void protobuf_AddDesc_google_2fprotobuf_2fapi_2eproto_impl() {
descriptor, 750);
::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
"google/protobuf/api.proto", &protobuf_RegisterTypes);
::google::protobuf::protobuf_AddDesc_google_2fprotobuf_2fsource_5fcontext_2eproto();
::google::protobuf::protobuf_AddDesc_google_2fprotobuf_2ftype_2eproto();
::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_google_2fprotobuf_2fapi_2eproto);
::google::protobuf::protobuf_google_2fprotobuf_2fsource_5fcontext_2eproto::AddDescriptors();
::google::protobuf::protobuf_google_2fprotobuf_2ftype_2eproto::AddDescriptors();
::google::protobuf::internal::OnShutdown(&TableStruct::Shutdown);
}
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_google_2fprotobuf_2fapi_2eproto_once_);
void protobuf_AddDesc_google_2fprotobuf_2fapi_2eproto() {
::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_google_2fprotobuf_2fapi_2eproto_once_,
&protobuf_AddDesc_google_2fprotobuf_2fapi_2eproto_impl);
void AddDescriptors() {
static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl);
}
// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_google_2fprotobuf_2fapi_2eproto {
StaticDescriptorInitializer_google_2fprotobuf_2fapi_2eproto() {
protobuf_AddDesc_google_2fprotobuf_2fapi_2eproto();
struct StaticDescriptorInitializer {
StaticDescriptorInitializer() {
AddDescriptors();
}
} static_descriptor_initializer_google_2fprotobuf_2fapi_2eproto_;
} static_descriptor_initializer;
} // namespace protobuf_google_2fprotobuf_2fapi_2eproto
// ===================================================================
@ -188,7 +188,7 @@ const int Api::kSyntaxFieldNumber;
Api::Api()
: ::google::protobuf::Message(), _internal_metadata_(NULL) {
if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
protobuf_InitDefaults_google_2fprotobuf_2fapi_2eproto();
protobuf_google_2fprotobuf_2fapi_2eproto::InitDefaults();
}
SharedCtor();
// @@protoc_insertion_point(constructor:google.protobuf.Api)
@ -245,12 +245,12 @@ void Api::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Api::descriptor() {
protobuf_AssignDescriptorsOnce();
return file_level_metadata[0].descriptor;
protobuf_google_2fprotobuf_2fapi_2eproto::protobuf_AssignDescriptorsOnce();
return protobuf_google_2fprotobuf_2fapi_2eproto::file_level_metadata[0].descriptor;
}
const Api& Api::default_instance() {
protobuf_InitDefaults_google_2fprotobuf_2fapi_2eproto();
protobuf_google_2fprotobuf_2fapi_2eproto::InitDefaults();
return *internal_default_instance();
}
@ -459,7 +459,7 @@ void Api::SerializeWithCachedSizes(
::google::protobuf::uint8* Api::InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const {
(void)deterministic; // Unused
(void)deterministic; // Unused
// @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Api)
// string name = 1;
if (this->name().size() > 0) {
@ -664,8 +664,8 @@ void Api::InternalSwap(Api* other) {
}
::google::protobuf::Metadata Api::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
return file_level_metadata[0];
protobuf_google_2fprotobuf_2fapi_2eproto::protobuf_AssignDescriptorsOnce();
return protobuf_google_2fprotobuf_2fapi_2eproto::file_level_metadata[0];
}
#if PROTOBUF_INLINE_NOT_IN_HEADERS
@ -935,7 +935,7 @@ const int Method::kSyntaxFieldNumber;
Method::Method()
: ::google::protobuf::Message(), _internal_metadata_(NULL) {
if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
protobuf_InitDefaults_google_2fprotobuf_2fapi_2eproto();
protobuf_google_2fprotobuf_2fapi_2eproto::InitDefaults();
}
SharedCtor();
// @@protoc_insertion_point(constructor:google.protobuf.Method)
@ -990,12 +990,12 @@ void Method::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Method::descriptor() {
protobuf_AssignDescriptorsOnce();
return file_level_metadata[1].descriptor;
protobuf_google_2fprotobuf_2fapi_2eproto::protobuf_AssignDescriptorsOnce();
return protobuf_google_2fprotobuf_2fapi_2eproto::file_level_metadata[1].descriptor;
}
const Method& Method::default_instance() {
protobuf_InitDefaults_google_2fprotobuf_2fapi_2eproto();
protobuf_google_2fprotobuf_2fapi_2eproto::InitDefaults();
return *internal_default_instance();
}
@ -1206,7 +1206,7 @@ void Method::SerializeWithCachedSizes(
::google::protobuf::uint8* Method::InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const {
(void)deterministic; // Unused
(void)deterministic; // Unused
// @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Method)
// string name = 1;
if (this->name().size() > 0) {
@ -1404,8 +1404,8 @@ void Method::InternalSwap(Method* other) {
}
::google::protobuf::Metadata Method::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
return file_level_metadata[1];
protobuf_google_2fprotobuf_2fapi_2eproto::protobuf_AssignDescriptorsOnce();
return protobuf_google_2fprotobuf_2fapi_2eproto::file_level_metadata[1];
}
#if PROTOBUF_INLINE_NOT_IN_HEADERS
@ -1651,7 +1651,7 @@ const int Mixin::kRootFieldNumber;
Mixin::Mixin()
: ::google::protobuf::Message(), _internal_metadata_(NULL) {
if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
protobuf_InitDefaults_google_2fprotobuf_2fapi_2eproto();
protobuf_google_2fprotobuf_2fapi_2eproto::InitDefaults();
}
SharedCtor();
// @@protoc_insertion_point(constructor:google.protobuf.Mixin)
@ -1694,12 +1694,12 @@ void Mixin::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Mixin::descriptor() {
protobuf_AssignDescriptorsOnce();
return file_level_metadata[2].descriptor;
protobuf_google_2fprotobuf_2fapi_2eproto::protobuf_AssignDescriptorsOnce();
return protobuf_google_2fprotobuf_2fapi_2eproto::file_level_metadata[2].descriptor;
}
const Mixin& Mixin::default_instance() {
protobuf_InitDefaults_google_2fprotobuf_2fapi_2eproto();
protobuf_google_2fprotobuf_2fapi_2eproto::InitDefaults();
return *internal_default_instance();
}
@ -1806,7 +1806,7 @@ void Mixin::SerializeWithCachedSizes(
::google::protobuf::uint8* Mixin::InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const {
(void)deterministic; // Unused
(void)deterministic; // Unused
// @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Mixin)
// string name = 1;
if (this->name().size() > 0) {
@ -1917,8 +1917,8 @@ void Mixin::InternalSwap(Mixin* other) {
}
::google::protobuf::Metadata Mixin::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
return file_level_metadata[2];
protobuf_google_2fprotobuf_2fapi_2eproto::protobuf_AssignDescriptorsOnce();
return protobuf_google_2fprotobuf_2fapi_2eproto::file_level_metadata[2];
}
#if PROTOBUF_INLINE_NOT_IN_HEADERS

131
src/google/protobuf/api.pb.h
View File

@ -8,17 +8,18 @@
#include <google/protobuf/stubs/common.h>
#if GOOGLE_PROTOBUF_VERSION < 3001000
#if GOOGLE_PROTOBUF_VERSION < 3002000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3001000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#if 3002000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
@ -65,9 +66,16 @@ LIBPROTOBUF_EXPORT extern TypeDefaultTypeInternal _Type_default_instance_;
namespace google {
namespace protobuf {
namespace protobuf_google_2fprotobuf_2fapi_2eproto {
// Internal implementation detail -- do not call these.
void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fapi_2eproto();
void LIBPROTOBUF_EXPORT protobuf_InitDefaults_google_2fprotobuf_2fapi_2eproto();
struct LIBPROTOBUF_EXPORT TableStruct {
static const ::google::protobuf::uint32 offsets[];
static void InitDefaultsImpl();
static void Shutdown();
};
void LIBPROTOBUF_EXPORT AddDescriptors();
void LIBPROTOBUF_EXPORT InitDefaults();
} // namespace protobuf_google_2fprotobuf_2fapi_2eproto
// ===================================================================
@ -114,7 +122,8 @@ class LIBPROTOBUF_EXPORT Api : public ::google::protobuf::Message /* @@protoc_in
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
const PROTOBUF_FINAL {
return InternalSerializeWithCachedSizesToArray(false, output);
return InternalSerializeWithCachedSizesToArray(
::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
}
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
@ -137,20 +146,6 @@ class LIBPROTOBUF_EXPORT Api : public ::google::protobuf::Message /* @@protoc_in
// accessors -------------------------------------------------------
// string name = 1;
void clear_name();
static const int kNameFieldNumber = 1;
const ::std::string& name() const;
void set_name(const ::std::string& value);
#if LANG_CXX11
void set_name(::std::string&& value);
#endif
void set_name(const char* value);
void set_name(const char* value, size_t size);
::std::string* mutable_name();
::std::string* release_name();
void set_allocated_name(::std::string* name);
// repeated .google.protobuf.Method methods = 2;
int methods_size() const;
void clear_methods();
@ -175,6 +170,32 @@ class LIBPROTOBUF_EXPORT Api : public ::google::protobuf::Message /* @@protoc_in
const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >&
options() const;
// repeated .google.protobuf.Mixin mixins = 6;
int mixins_size() const;
void clear_mixins();
static const int kMixinsFieldNumber = 6;
const ::google::protobuf::Mixin& mixins(int index) const;
::google::protobuf::Mixin* mutable_mixins(int index);
::google::protobuf::Mixin* add_mixins();
::google::protobuf::RepeatedPtrField< ::google::protobuf::Mixin >*
mutable_mixins();
const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Mixin >&
mixins() const;
// string name = 1;
void clear_name();
static const int kNameFieldNumber = 1;
const ::std::string& name() const;
void set_name(const ::std::string& value);
#if LANG_CXX11
void set_name(::std::string&& value);
#endif
void set_name(const char* value);
void set_name(const char* value, size_t size);
::std::string* mutable_name();
::std::string* release_name();
void set_allocated_name(::std::string* name);
// string version = 4;
void clear_version();
static const int kVersionFieldNumber = 4;
@ -198,18 +219,6 @@ class LIBPROTOBUF_EXPORT Api : public ::google::protobuf::Message /* @@protoc_in
::google::protobuf::SourceContext* release_source_context();
void set_allocated_source_context(::google::protobuf::SourceContext* source_context);
// repeated .google.protobuf.Mixin mixins = 6;
int mixins_size() const;
void clear_mixins();
static const int kMixinsFieldNumber = 6;
const ::google::protobuf::Mixin& mixins(int index) const;
::google::protobuf::Mixin* mutable_mixins(int index);
::google::protobuf::Mixin* add_mixins();
::google::protobuf::RepeatedPtrField< ::google::protobuf::Mixin >*
mutable_mixins();
const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Mixin >&
mixins() const;
// .google.protobuf.Syntax syntax = 7;
void clear_syntax();
static const int kSyntaxFieldNumber = 7;
@ -228,11 +237,7 @@ class LIBPROTOBUF_EXPORT Api : public ::google::protobuf::Message /* @@protoc_in
::google::protobuf::SourceContext* source_context_;
int syntax_;
mutable int _cached_size_;
friend void LIBPROTOBUF_EXPORT protobuf_InitDefaults_google_2fprotobuf_2fapi_2eproto_impl();
friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fapi_2eproto_impl();
friend const ::google::protobuf::uint32* protobuf_Offsets_google_2fprotobuf_2fapi_2eproto();
friend void protobuf_ShutdownFile_google_2fprotobuf_2fapi_2eproto();
friend struct LIBPROTOBUF_EXPORT protobuf_google_2fprotobuf_2fapi_2eproto::TableStruct;
};
// -------------------------------------------------------------------
@ -279,7 +284,8 @@ class LIBPROTOBUF_EXPORT Method : public ::google::protobuf::Message /* @@protoc
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
const PROTOBUF_FINAL {
return InternalSerializeWithCachedSizesToArray(false, output);
return InternalSerializeWithCachedSizesToArray(
::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
}
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
@ -302,6 +308,18 @@ class LIBPROTOBUF_EXPORT Method : public ::google::protobuf::Message /* @@protoc
// accessors -------------------------------------------------------
// repeated .google.protobuf.Option options = 6;
int options_size() const;
void clear_options();
static const int kOptionsFieldNumber = 6;
const ::google::protobuf::Option& options(int index) const;
::google::protobuf::Option* mutable_options(int index);
::google::protobuf::Option* add_options();
::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >*
mutable_options();
const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >&
options() const;
// string name = 1;
void clear_name();
static const int kNameFieldNumber = 1;
@ -330,12 +348,6 @@ class LIBPROTOBUF_EXPORT Method : public ::google::protobuf::Message /* @@protoc
::std::string* release_request_type_url();
void set_allocated_request_type_url(::std::string* request_type_url);
// bool request_streaming = 3;
void clear_request_streaming();
static const int kRequestStreamingFieldNumber = 3;
bool request_streaming() const;
void set_request_streaming(bool value);
// string response_type_url = 4;
void clear_response_type_url();
static const int kResponseTypeUrlFieldNumber = 4;
@ -350,24 +362,18 @@ class LIBPROTOBUF_EXPORT Method : public ::google::protobuf::Message /* @@protoc
::std::string* release_response_type_url();
void set_allocated_response_type_url(::std::string* response_type_url);
// bool request_streaming = 3;
void clear_request_streaming();
static const int kRequestStreamingFieldNumber = 3;
bool request_streaming() const;
void set_request_streaming(bool value);
// bool response_streaming = 5;
void clear_response_streaming();
static const int kResponseStreamingFieldNumber = 5;
bool response_streaming() const;
void set_response_streaming(bool value);
// repeated .google.protobuf.Option options = 6;
int options_size() const;
void clear_options();
static const int kOptionsFieldNumber = 6;
const ::google::protobuf::Option& options(int index) const;
::google::protobuf::Option* mutable_options(int index);
::google::protobuf::Option* add_options();
::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >*
mutable_options();
const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >&
options() const;
// .google.protobuf.Syntax syntax = 7;
void clear_syntax();
static const int kSyntaxFieldNumber = 7;
@ -386,11 +392,7 @@ class LIBPROTOBUF_EXPORT Method : public ::google::protobuf::Message /* @@protoc
bool response_streaming_;
int syntax_;
mutable int _cached_size_;
friend void LIBPROTOBUF_EXPORT protobuf_InitDefaults_google_2fprotobuf_2fapi_2eproto_impl();
friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fapi_2eproto_impl();
friend const ::google::protobuf::uint32* protobuf_Offsets_google_2fprotobuf_2fapi_2eproto();
friend void protobuf_ShutdownFile_google_2fprotobuf_2fapi_2eproto();
friend struct LIBPROTOBUF_EXPORT protobuf_google_2fprotobuf_2fapi_2eproto::TableStruct;
};
// -------------------------------------------------------------------
@ -437,7 +439,8 @@ class LIBPROTOBUF_EXPORT Mixin : public ::google::protobuf::Message /* @@protoc_
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
const PROTOBUF_FINAL {
return InternalSerializeWithCachedSizesToArray(false, output);
return InternalSerializeWithCachedSizesToArray(
::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
}
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
@ -495,11 +498,7 @@ class LIBPROTOBUF_EXPORT Mixin : public ::google::protobuf::Message /* @@protoc_
::google::protobuf::internal::ArenaStringPtr name_;
::google::protobuf::internal::ArenaStringPtr root_;
mutable int _cached_size_;
friend void LIBPROTOBUF_EXPORT protobuf_InitDefaults_google_2fprotobuf_2fapi_2eproto_impl();
friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fapi_2eproto_impl();
friend const ::google::protobuf::uint32* protobuf_Offsets_google_2fprotobuf_2fapi_2eproto();
friend void protobuf_ShutdownFile_google_2fprotobuf_2fapi_2eproto();
friend struct LIBPROTOBUF_EXPORT protobuf_google_2fprotobuf_2fapi_2eproto::TableStruct;
};
// ===================================================================

23
src/google/protobuf/arena.cc
View File

@ -62,6 +62,7 @@ void Arena::Init() {
lifecycle_id_ = lifecycle_id_generator_.GetNext();
blocks_ = 0;
hint_ = 0;
space_allocated_ = 0;
owns_first_block_ = true;
cleanup_list_ = 0;
@ -157,6 +158,7 @@ void Arena::AddBlockInternal(Block* b) {
// Direct future allocations to this block.
google::protobuf::internal::Release_Store(&hint_, reinterpret_cast<google::protobuf::internal::AtomicWord>(b));
}
space_allocated_ += b->size;
}
void Arena::AddListNode(void* elem, void (*cleanup)(void*)) {
@ -225,13 +227,8 @@ void* Arena::SlowAlloc(size_t n) {
}
uint64 Arena::SpaceAllocated() const {
uint64 space_allocated = 0;
Block* b = reinterpret_cast<Block*>(google::protobuf::internal::NoBarrier_Load(&blocks_));
while (b != NULL) {
space_allocated += (b->size);
b = b->next;
}
return space_allocated;
MutexLock l(&blocks_lock_);
return space_allocated_;
}
uint64 Arena::SpaceUsed() const {
@ -245,16 +242,7 @@ uint64 Arena::SpaceUsed() const {
}
std::pair<uint64, uint64> Arena::SpaceAllocatedAndUsed() const {
uint64 allocated = 0;
uint64 used = 0;
Block* b = reinterpret_cast<Block*>(google::protobuf::internal::NoBarrier_Load(&blocks_));
while (b != NULL) {
allocated += b->size;
used += (b->pos - kHeaderSize);
b = b->next;
}
return std::make_pair(allocated, used);
return std::make_pair(SpaceAllocated(), SpaceUsed());
}
uint64 Arena::FreeBlocks() {
@ -288,6 +276,7 @@ uint64 Arena::FreeBlocks() {
}
blocks_ = 0;
hint_ = 0;
space_allocated_ = 0;
if (!owns_first_block_) {
// Make the first block that was passed in through ArenaOptions
// available for reuse.

24
src/google/protobuf/arena.h
View File

@ -449,14 +449,17 @@ class LIBPROTOBUF_EXPORT Arena {
}
}
// Returns the total space used by the arena, which is the sums of the sizes
// of the underlying blocks. The total space used may not include the new
// blocks that are allocated by this arena from other threads concurrently
// with the call to this method.
GOOGLE_ATTRIBUTE_NOINLINE uint64 SpaceAllocated() const;
// As above, but does not include any free space in underlying blocks.
// Returns the total space allocated by the arena, which is the sum of the
// sizes of the underlying blocks. This method is relatively fast; a counter
// is kept as blocks are allocated.
uint64 SpaceAllocated() const;
// Returns the total space used by the arena. Similar to SpaceAllocated but
// does not include free space and block overhead. The total space returned
// may not include space used by other threads executing concurrently with
// the call to this method.
GOOGLE_ATTRIBUTE_NOINLINE uint64 SpaceUsed() const;
// DEPRECATED. Please use SpaceAllocated() and SpaceUsed().
//
// Combines SpaceAllocated and SpaceUsed. Returns a pair of
// <space_allocated, space_used>.
GOOGLE_ATTRIBUTE_NOINLINE std::pair<uint64, uint64> SpaceAllocatedAndUsed() const;
@ -884,8 +887,9 @@ class LIBPROTOBUF_EXPORT Arena {
int64 lifecycle_id_; // Unique for each arena. Changes on Reset().
google::protobuf::internal::AtomicWord blocks_; // Head of linked list of all allocated blocks
google::protobuf::internal::AtomicWord hint_; // Fast thread-local block access
google::protobuf::internal::AtomicWord blocks_; // Head of linked list of all allocated blocks
google::protobuf::internal::AtomicWord hint_; // Fast thread-local block access
uint64 space_allocated_; // Sum of sizes of all allocated blocks.
// Node contains the ptr of the object to be cleaned up and the associated
// cleanup function ptr.
@ -899,7 +903,7 @@ class LIBPROTOBUF_EXPORT Arena {
// ptrs and cleanup methods.
bool owns_first_block_; // Indicates that arena owns the first block
Mutex blocks_lock_;
mutable Mutex blocks_lock_;
void AddBlock(Block* b);
// Access must be synchronized, either by blocks_lock_ or by being called from

51
src/google/protobuf/compiler/command_line_interface.cc
View File

@ -116,6 +116,9 @@ static const char* kPathSeparator = ";";
static const char* kPathSeparator = ":";
#endif
static const char* kDefaultDirectDependenciesViolationMsg =
"File is imported but not declared in --direct_dependencies: %s";
// Returns true if the text looks like a Windows-style absolute path, starting
// with a drive letter. Example: "C:\foo". TODO(kenton): Share this with
// copy in importer.cc?
@ -276,12 +279,13 @@ class CommandLineInterface::ErrorPrinter : public MultiFileErrorCollector,
public io::ErrorCollector {
public:
ErrorPrinter(ErrorFormat format, DiskSourceTree *tree = NULL)
: format_(format), tree_(tree) {}
: format_(format), tree_(tree), found_errors_(false) {}
~ErrorPrinter() {}
// implements MultiFileErrorCollector ------------------------------
void AddError(const string& filename, int line, int column,
const string& message) {
found_errors_ = true;
AddErrorOrWarning(filename, line, column, message, "error", std::cerr);
}
@ -299,10 +303,12 @@ class CommandLineInterface::ErrorPrinter : public MultiFileErrorCollector,
AddErrorOrWarning("input", line, column, message, "warning", std::clog);
}
bool FoundErrors() const { return found_errors_; }
private:
void AddErrorOrWarning(
const string& filename, int line, int column,
const string& message, const string& type, ostream& out) {
void AddErrorOrWarning(const string& filename, int line, int column,
const string& message, const string& type,
std::ostream& out) {
// Print full path when running under MSVS
string dfile;
if (format_ == CommandLineInterface::ERROR_FORMAT_MSVS &&
@ -337,6 +343,7 @@ class CommandLineInterface::ErrorPrinter : public MultiFileErrorCollector,
const ErrorFormat format_;
DiskSourceTree *tree_;
bool found_errors_;
};
// -------------------------------------------------------------------
@ -708,14 +715,17 @@ CommandLineInterface::MemoryOutputStream::~MemoryOutputStream() {
// ===================================================================
CommandLineInterface::CommandLineInterface()
: mode_(MODE_COMPILE),
print_mode_(PRINT_NONE),
error_format_(ERROR_FORMAT_GCC),
direct_dependencies_explicitly_set_(false),
imports_in_descriptor_set_(false),
source_info_in_descriptor_set_(false),
disallow_services_(false),
inputs_are_proto_path_relative_(false) {}
: mode_(MODE_COMPILE),
print_mode_(PRINT_NONE),
error_format_(ERROR_FORMAT_GCC),
direct_dependencies_explicitly_set_(false),
direct_dependencies_violation_msg_(
kDefaultDirectDependenciesViolationMsg),
imports_in_descriptor_set_(false),
source_info_in_descriptor_set_(false),
disallow_services_(false),
inputs_are_proto_path_relative_(false) {
}
CommandLineInterface::~CommandLineInterface() {}
void CommandLineInterface::RegisterGenerator(const string& flag_name,
@ -800,10 +810,11 @@ int CommandLineInterface::Run(int argc, const char* const argv[]) {
if (direct_dependencies_.find(parsed_file->dependency(i)->name()) ==
direct_dependencies_.end()) {
indirect_imports = true;
cerr << parsed_file->name()
<< ": File is imported but not declared in "
<< "--direct_dependencies: "
<< parsed_file->dependency(i)->name() << std::endl;
cerr << parsed_file->name() << ": "
<< StringReplace(direct_dependencies_violation_msg_, "%s",
parsed_file->dependency(i)->name(),
true /* replace_all */)
<< std::endl;
}
}
if (indirect_imports) {
@ -895,6 +906,10 @@ int CommandLineInterface::Run(int argc, const char* const argv[]) {
}
}
if (error_collector.FoundErrors()) {
return 1;
}
if (mode_ == MODE_PRINT) {
switch (print_mode_) {
case PRINT_FREE_FIELDS:
@ -924,6 +939,7 @@ void CommandLineInterface::Clear() {
proto_path_.clear();
input_files_.clear();
direct_dependencies_.clear();
direct_dependencies_violation_msg_ = kDefaultDirectDependenciesViolationMsg;
output_directives_.clear();
codec_type_.clear();
descriptor_set_name_.clear();
@ -1209,6 +1225,9 @@ CommandLineInterface::InterpretArgument(const string& name,
GOOGLE_DCHECK(direct_dependencies_.empty());
direct_dependencies_.insert(direct.begin(), direct.end());
} else if (name == "--direct_dependencies_violation_msg") {
direct_dependencies_violation_msg_ = value;
} else if (name == "-o" || name == "--descriptor_set_out") {
if (!descriptor_set_name_.empty()) {
std::cerr << name << " may only be passed once." << std::endl;

4
src/google/protobuf/compiler/command_line_interface.h
View File

@ -365,6 +365,10 @@ class LIBPROTOC_EXPORT CommandLineInterface {
std::set<string> direct_dependencies_;
bool direct_dependencies_explicitly_set_;
// If there's a violation of depend-on-what-you-import, this string will be
// presented to the user. "%s" will be replaced with the violating import.
string direct_dependencies_violation_msg_;
// output_directives_ lists all the files we are supposed to output and what
// generator to use for each.
struct OutputDirective {

39
src/google/protobuf/compiler/command_line_interface_unittest.cc
View File

@ -101,6 +101,7 @@ class CommandLineInterfaceTest : public testing::Test {
// command is automatically split on spaces, and the string "$tmpdir"
// is replaced with TestTempDir().
void Run(const string& command);
void RunWithArgs(vector<string> args);
// -----------------------------------------------------------------
// Methods to set up the test (called before Run()).
@ -292,8 +293,10 @@ void CommandLineInterfaceTest::TearDown() {
}
void CommandLineInterfaceTest::Run(const string& command) {
std::vector<string> args = Split(command, " ", true);
RunWithArgs(Split(command, " ", true));
}
void CommandLineInterfaceTest::RunWithArgs(vector<string> args) {
if (!disallow_plugins_) {
cli_.AllowPlugins("prefix-");
#ifndef GOOGLE_THIRD_PARTY_PROTOBUF
@ -996,6 +999,27 @@ TEST_F(CommandLineInterfaceTest, DirectDependencies_ProvidedMultipleTimes) {
"':'.\n");
}
TEST_F(CommandLineInterfaceTest, DirectDependencies_CustomErrorMessage) {
CreateTempFile("foo.proto",
"syntax = \"proto2\";\n"
"import \"bar.proto\";\n"
"message Foo { optional Bar bar = 1; }");
CreateTempFile("bar.proto",
"syntax = \"proto2\";\n"
"message Bar { optional string text = 1; }");
vector<string> commands;
commands.push_back("protocol_compiler");
commands.push_back("--test_out=$tmpdir");
commands.push_back("--proto_path=$tmpdir");
commands.push_back("--direct_dependencies=");
commands.push_back("--direct_dependencies_violation_msg=Bla \"%s\" Bla");
commands.push_back("foo.proto");
RunWithArgs(commands);
ExpectErrorText("foo.proto: Bla \"bar.proto\" Bla\n");
}
TEST_F(CommandLineInterfaceTest, CwdRelativeInputs) {
// Test that we can accept working-directory-relative input files.
@ -1283,6 +1307,19 @@ TEST_F(CommandLineInterfaceTest, ParseErrorsMultipleFiles) {
"foo.proto: Import \"baz.proto\" was not found or had errors.\n");
}
TEST_F(CommandLineInterfaceTest, RecursiveImportFails) {
// Create a proto file that imports itself.
CreateTempFile("foo.proto",
"syntax = \"proto2\";\n"
"import \"foo.proto\";\n");
Run("protocol_compiler --test_out=$tmpdir "
"--proto_path=$tmpdir foo.proto");
ExpectErrorSubstring(
"foo.proto: File recursively imports itself: foo.proto -> foo.proto\n");
}
TEST_F(CommandLineInterfaceTest, InputNotFoundError) {
// Test what happens if the input file is not found.

6
src/google/protobuf/compiler/cpp/cpp_enum.cc
View File

@ -251,13 +251,15 @@ void EnumGenerator::GenerateMethods(io::Printer* printer) {
vars["classname"] = classname_;
vars["index_in_metadata"] = SimpleItoa(index_in_metadata_);
vars["constexpr"] = options_.proto_h ? "constexpr " : "";
vars["file_namespace"] = FileLevelNamespace(descriptor_->file()->name());
if (HasDescriptorMethods(descriptor_->file(), options_)) {
printer->Print(
vars,
"const ::google::protobuf::EnumDescriptor* $classname$_descriptor() {\n"
" protobuf_AssignDescriptorsOnce();\n"
" return file_level_enum_descriptors[$index_in_metadata$];\n"
" $file_namespace$::protobuf_AssignDescriptorsOnce();\n"
" return "
"$file_namespace$::file_level_enum_descriptors[$index_in_metadata$];\n"
"}\n");
}

2
src/google/protobuf/compiler/cpp/cpp_enum_field.cc
View File

@ -230,7 +230,7 @@ void EnumOneofFieldGenerator::
GenerateConstructorCode(io::Printer* printer) const {
printer->Print(
variables_,
" $classname$_default_oneof_instance_.$name$_ = $default$;\n");
"_$classname$_default_instance_.$name$_ = $default$;\n");
}
// ===================================================================

185
src/google/protobuf/compiler/cpp/cpp_file.cc
View File

@ -284,8 +284,13 @@ void FileGenerator::GenerateSource(io::Printer* printer) {
if (IsMapEntryMessage(message_generators_[i]->descriptor_)) continue;
printer->Print(
"class $classname$DefaultTypeInternal : "
"public ::google::protobuf::internal::ExplicitlyConstructed<$classname$> {};\n"
"$classname$DefaultTypeInternal _$classname$_default_instance_;\n",
"public ::google::protobuf::internal::ExplicitlyConstructed<$classname$> {\n",
"classname", message_generators_[i]->classname_);
printer->Indent();
message_generators_[i]->GenerateExtraDefaultFields(printer);
printer->Outdent();
printer->Print(
"} _$classname$_default_instance_;\n",
"classname", message_generators_[i]->classname_);
}
@ -301,6 +306,12 @@ void FileGenerator::GenerateSource(io::Printer* printer) {
}
}
printer->Print(
"\n"
"namespace $file_namespace$ {\n"
"\n",
"file_namespace", FileLevelNamespace(file_->name()));
if (HasDescriptorMethods(file_, options_)) {
printer->Print(
"\n"
@ -324,10 +335,6 @@ void FileGenerator::GenerateSource(io::Printer* printer) {
"size", SimpleItoa(file_->service_count()));
}
for (int i = 0; i < message_generators_.size(); i++) {
message_generators_[i]->GenerateDescriptorDeclarations(printer);
}
printer->Print(
"\n"
"} // namespace\n"
@ -338,6 +345,12 @@ void FileGenerator::GenerateSource(io::Printer* printer) {
// library, all this does is initialize default instances.)
GenerateBuildDescriptors(printer);
printer->Print(
"\n"
"} // namespace $file_namespace$\n"
"\n",
"file_namespace", FileLevelNamespace(file_->name()));
// Generate enums.
for (int i = 0; i < enum_generators_.size(); i++) {
enum_generators_[i]->GenerateMethods(printer);
@ -473,28 +486,16 @@ void FileGenerator::GenerateBuildDescriptors(io::Printer* printer) {
if (HasDescriptorMethods(file_, options_)) {
if (!message_generators_.empty()) {
printer->Print(
"\n"
"const ::google::protobuf::uint32* $offsetfunname$() GOOGLE_ATTRIBUTE_COLD;\n"
"const ::google::protobuf::uint32* $offsetfunname$() {\n",
"offsetfunname", GlobalOffsetTableName(file_->name()));
printer->Indent();
printer->Print("static const ::google::protobuf::uint32 offsets[] = {\n");
printer->Print("const ::google::protobuf::uint32 TableStruct::offsets[] = {\n");
printer->Indent();
std::vector<std::pair<size_t, size_t> > pairs;
for (int i = 0; i < message_generators_.size(); i++) {
pairs.push_back(message_generators_[i]->GenerateOffsets(printer));
}
printer->Outdent();
printer->Outdent();
printer->Print(
" };\n"
" return offsets;\n"
"}\n"
"\n");
printer->Print(
"};\n"
"\n"
"static const ::google::protobuf::internal::MigrationSchema schemas[] = {\n");
printer->Indent();
{
@ -508,25 +509,17 @@ void FileGenerator::GenerateBuildDescriptors(io::Printer* printer) {
printer->Outdent();
printer->Print(
"};\n"
"\n"
"static const ::google::protobuf::internal::DefaultInstanceData "
"file_default_instances[] = {\n");
"\nstatic "
"::google::protobuf::Message const * const file_default_instances[] = {\n");
printer->Indent();
for (int i = 0; i < message_generators_.size(); i++) {
const Descriptor* descriptor = message_generators_[i]->descriptor_;
if (IsMapEntryMessage(descriptor)) continue;
string oneof_default = "NULL";
if (message_generators_[i]->descriptor_->oneof_decl_count()) {
oneof_default =
"&" + ClassName(descriptor, false) + "_default_oneof_instance_";
}
printer->Print(
"{reinterpret_cast<const "
"::google::protobuf::Message*>(&_$classname$_default_instance_), "
"$oneof_default$},\n",
"classname", ClassName(descriptor, false), "oneof_default",
oneof_default);
"reinterpret_cast<const "
"::google::protobuf::Message*>(&_$classname$_default_instance_),\n",
"classname", ClassName(descriptor, false));
}
printer->Outdent();
printer->Print(
@ -535,12 +528,11 @@ void FileGenerator::GenerateBuildDescriptors(io::Printer* printer) {
} else {
// we still need these symbols to exist
printer->Print(
"inline ::google::protobuf::uint32* $offsetfunname$() { return NULL; }\n"
// MSVC doesn't like empty arrays, so we add a dummy.
"const ::google::protobuf::uint32 TableStruct::offsets[] = { ~0u };\n"
"static const ::google::protobuf::internal::MigrationSchema* schemas = NULL;\n"
"static const ::google::protobuf::internal::DefaultInstanceData* "
"file_default_instances = NULL;\n",
"offsetfunname",
GlobalOffsetTableName(file_->name()));
"static const ::google::protobuf::Message* const* "
"file_default_instances = NULL;\n");
}
// ---------------------------------------------------------------
@ -557,11 +549,11 @@ void FileGenerator::GenerateBuildDescriptors(io::Printer* printer) {
// is requested *during* static init then AddDescriptors() may not have
// been called yet, so we call it manually. Note that it's fine if
// AddDescriptors() is called multiple times.
" $adddescriptorsname$();\n"
" AddDescriptors();\n"
" ::google::protobuf::MessageFactory* factory = $factory$;\n"
" AssignDescriptors(\n"
" \"$filename$\", schemas, file_default_instances, "
"$offsetfunname$(), factory,\n"
"TableStruct::offsets, factory,\n"
" $metadata$, $enum_descriptors$, $service_descriptors$);\n"
"}\n"
"\n"
@ -570,9 +562,7 @@ void FileGenerator::GenerateBuildDescriptors(io::Printer* printer) {
" ::google::protobuf::GoogleOnceInit(&once, &protobuf_AssignDescriptors);\n"
"}\n"
"\n",
"adddescriptorsname", GlobalAddDescriptorsName(file_->name()),
"offsetfunname", GlobalOffsetTableName(file_->name()), "filename",
file_->name(), "metadata",
"filename", file_->name(), "metadata",
!message_generators_.empty() ? "file_level_metadata" : "NULL",
"enum_descriptors",
!enum_generators_.empty() ? "file_level_enum_descriptors" : "NULL",
@ -616,8 +606,7 @@ void FileGenerator::GenerateBuildDescriptors(io::Printer* printer) {
// ShutdownFile(): Deletes descriptors, default instances, etc. on shutdown.
printer->Print(
"\n"
"void $shutdownfilename$() {\n",
"shutdownfilename", GlobalShutdownFileName(file_->name()));
"void TableStruct::Shutdown() {\n");
printer->Indent();
for (int i = 0; i < message_generators_.size(); i++) {
@ -630,13 +619,12 @@ void FileGenerator::GenerateBuildDescriptors(io::Printer* printer) {
// -----------------------------------------------------------------
// Now generate the InitDefaults() function.
// Now generate the InitDefaultsImpl() function.
printer->Print(
"void $initdefaultsname$_impl() {\n"
"void TableStruct::InitDefaultsImpl() {\n"
" GOOGLE_PROTOBUF_VERIFY_VERSION;\n\n"
"",
// Vars.
"initdefaultsname", GlobalInitDefaultsName(file_->name()));
// Force initialization of primitive values we depend on.
" ::google::protobuf::internal::InitProtobufDefaults();\n");
printer->Indent();
@ -645,17 +633,13 @@ void FileGenerator::GenerateBuildDescriptors(io::Printer* printer) {
for (int i = 0; i < file_->dependency_count(); i++) {
const FileDescriptor* dependency = file_->dependency(i);
// Print the namespace prefix for the dependency.
string add_desc_name = QualifiedFileLevelSymbol(
dependency->package(), GlobalInitDefaultsName(dependency->name()));
string file_namespace = QualifiedFileLevelSymbol(
dependency->package(), FileLevelNamespace(dependency->name()));
// Call its AddDescriptors function.
printer->Print(
"$name$();\n",
"name", add_desc_name);
printer->Print("$file_namespace$::InitDefaults();\n", "file_namespace",
file_namespace);
}
// Force initialization of primitive values we depend on.
printer->Print("::google::protobuf::internal::InitProtobufDefaults();\n");
// Allocate and initialize default instances. This can't be done lazily
// since default instances are returned by simple accessors and are used with
// extensions. Speaking of which, we also register extensions at this time.
@ -672,21 +656,17 @@ void FileGenerator::GenerateBuildDescriptors(io::Printer* printer) {
printer->Print(
"}\n"
"\n"
"void $initdefaultsname$() {\n"
"void InitDefaults() {\n"
" static GOOGLE_PROTOBUF_DECLARE_ONCE(once);\n"
" ::google::protobuf::GoogleOnceInit(&once, &$initdefaultsname$_impl);\n"
"}\n",
"initdefaultsname", GlobalInitDefaultsName(file_->name()));
" ::google::protobuf::GoogleOnceInit(&once, &TableStruct::InitDefaultsImpl);\n"
"}\n");
// -----------------------------------------------------------------
// Now generate the AddDescriptors() function.
printer->Print(
"void $adddescriptorsname$_impl() {\n"
" $initdefaultsname$();\n",
// Vars.
"adddescriptorsname", GlobalAddDescriptorsName(file_->name()),
"initdefaultsname", GlobalInitDefaultsName(file_->name()));
"void AddDescriptorsImpl() {\n"
" InitDefaults();\n");
printer->Indent();
if (HasDescriptorMethods(file_, options_)) {
@ -702,12 +682,7 @@ void FileGenerator::GenerateBuildDescriptors(io::Printer* printer) {
printer->Print("static const char descriptor[] = {\n");
printer->Indent();
#ifdef _MSC_VER
bool breakdown_large_file = true;
#else
bool breakdown_large_file = false;
#endif
if (breakdown_large_file && file_data.size() > 66538) {
if (file_data.size() > 66535) {
// Workaround for MSVC: "Error C1091: compiler limit: string exceeds 65535
// bytes in length". Declare a static array of characters rather than use
// a string literal. Only write 25 bytes per line.
@ -748,42 +723,36 @@ void FileGenerator::GenerateBuildDescriptors(io::Printer* printer) {
for (int i = 0; i < file_->dependency_count(); i++) {
const FileDescriptor* dependency = file_->dependency(i);
// Print the namespace prefix for the dependency.
string add_desc_name = QualifiedFileLevelSymbol(
dependency->package(), GlobalAddDescriptorsName(dependency->name()));
string file_namespace = QualifiedFileLevelSymbol(
dependency->package(), FileLevelNamespace(dependency->name()));
// Call its AddDescriptors function.
printer->Print("$adddescriptorsname$();\n", "adddescriptorsname",
add_desc_name);
printer->Print("$file_namespace$::AddDescriptors();\n", "file_namespace",
file_namespace);
}
printer->Print(
"::google::protobuf::internal::OnShutdown(&$shutdownfilename$);\n",
"shutdownfilename", GlobalShutdownFileName(file_->name()));
"::google::protobuf::internal::OnShutdown(&TableStruct::Shutdown);\n");
printer->Outdent();
printer->Print(
"}\n"
"\n"
"GOOGLE_PROTOBUF_DECLARE_ONCE($adddescriptorsname$_once_);\n"
"void $adddescriptorsname$() {\n"
" ::google::protobuf::GoogleOnceInit(&$adddescriptorsname$_once_,\n"
" &$adddescriptorsname$_impl);\n"
"}\n",
"adddescriptorsname", GlobalAddDescriptorsName(file_->name()));
"void AddDescriptors() {\n"
" static GOOGLE_PROTOBUF_DECLARE_ONCE(once);\n"
" ::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl);\n"
"}\n");
if (!StaticInitializersForced(file_, options_)) {
printer->Print("#ifndef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER\n");
printer->Print("#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER\n");
}
printer->Print(
// With static initializers.
"// Force AddDescriptors() to be called at static initialization time.\n"
"struct StaticDescriptorInitializer_$filename$ {\n"
" StaticDescriptorInitializer_$filename$() {\n"
" $adddescriptorsname$();\n"
"struct StaticDescriptorInitializer {\n"
" StaticDescriptorInitializer() {\n"
" AddDescriptors();\n"
" }\n"
"} static_descriptor_initializer_$filename$_;\n",
// Vars.
"adddescriptorsname", GlobalAddDescriptorsName(file_->name()), "filename",
FilenameIdentifier(file_->name()));
"} static_descriptor_initializer;\n");
if (!StaticInitializersForced(file_, options_)) {
printer->Print("#endif // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER\n");
}
@ -884,10 +853,11 @@ void FileGenerator::GenerateLibraryIncludes(io::Printer* printer) {
// OK, it's now safe to #include other files.
printer->Print(
"#include <google/protobuf/arena.h>\n"
"#include <google/protobuf/arenastring.h>\n"
"#include <google/protobuf/generated_message_util.h>\n"
"#include <google/protobuf/metadata.h>\n");
"#include <google/protobuf/io/coded_stream.h>\n"
"#include <google/protobuf/arena.h>\n"
"#include <google/protobuf/arenastring.h>\n"
"#include <google/protobuf/generated_message_util.h>\n"
"#include <google/protobuf/metadata.h>\n");
if (!message_generators_.empty()) {
if (HasDescriptorMethods(file_, options_)) {
@ -982,12 +952,21 @@ void FileGenerator::GenerateGlobalStateFunctionDeclarations(
// functions, so that we can declare them to be friends of each class.
printer->Print(
"\n"
"namespace $file_namespace$ {\n"
"// Internal implementation detail -- do not call these.\n"
"void $dllexport_decl$$adddescriptorsname$();\n"
"void $dllexport_decl$$initdefaultsname$();\n",
"initdefaultsname", GlobalInitDefaultsName(file_->name()),
"adddescriptorsname", GlobalAddDescriptorsName(file_->name()),
"dllexport_decl",
"struct $dllexport_decl$TableStruct {\n"
" static const ::google::protobuf::uint32 offsets[];\n"
// The following function(s) need to be able to access private members of
// the messages defined in the file. So we make them static members.
// This is the internal implementation of InitDefaults. It should only
// be called by InitDefaults which makes sure it will be called only once.
" static void InitDefaultsImpl();\n"
" static void Shutdown();\n"
"};\n"
"void $dllexport_decl$AddDescriptors();\n"
"void $dllexport_decl$InitDefaults();\n"
"} // namespace $file_namespace$\n",
"file_namespace", FileLevelNamespace(file_->name()), "dllexport_decl",
options_.dllexport_decl.empty() ? "" : options_.dllexport_decl + " ");
}

19
src/google/protobuf/compiler/cpp/cpp_helpers.cc
View File

@ -440,23 +440,8 @@ string FilenameIdentifier(const string& filename) {
return result;
}
// Return the name of the AddDescriptors() function for a given file.
string GlobalAddDescriptorsName(const string& filename) {
return "protobuf_AddDesc_" + FilenameIdentifier(filename);
}
string GlobalInitDefaultsName(const string& filename) {
return "protobuf_InitDefaults_" + FilenameIdentifier(filename);
}
// Return the name of the AssignDescriptors() function for a given file.
string GlobalOffsetTableName(const string& filename) {
return "protobuf_Offsets_" + FilenameIdentifier(filename);
}
// Return the name of the ShutdownFile() function for a given file.
string GlobalShutdownFileName(const string& filename) {
return "protobuf_ShutdownFile_" + FilenameIdentifier(filename);
string FileLevelNamespace(const string& filename) {
return "protobuf_" + FilenameIdentifier(filename);
}
// Return the qualified C++ name for a file level symbol.

14
src/google/protobuf/compiler/cpp/cpp_helpers.h
View File

@ -144,21 +144,13 @@ string DefaultValue(const FieldDescriptor* field);
// Convert a file name into a valid identifier.
string FilenameIdentifier(const string& filename);
// Return the name of the AddDescriptors() function for a given file.
string GlobalAddDescriptorsName(const string& filename);
// Return the name of the InitDefaults() function for a given file.
string GlobalInitDefaultsName(const string& filename);
// Return the name of the offset table function for a given file.
string GlobalOffsetTableName(const string& filename);
// For each .proto file generates a unique namespace. In this namespace global
// definitions are put to prevent collisions.
string FileLevelNamespace(const string& filename);
// Return the qualified C++ name for a file level symbol.
string QualifiedFileLevelSymbol(const string& package, const string& name);
// Return the name of the ShutdownFile() function for a given file.
string GlobalShutdownFileName(const string& filename);
// Escape C++ trigraphs by escaping question marks to \?
string EscapeTrigraphs(const string& to_escape);

4
src/google/protobuf/compiler/cpp/cpp_map_field.cc
View File

@ -49,6 +49,8 @@ void SetMessageVariables(const FieldDescriptor* descriptor,
const Options& options) {
SetCommonFieldVariables(descriptor, variables, options);
(*variables)["type"] = ClassName(descriptor->message_type(), false);
(*variables)["file_namespace"] =
FileLevelNamespace(descriptor->file()->name());
(*variables)["stream_writer"] =
(*variables)["declared_type"] +
(HasFastArraySerialization(descriptor->message_type()->file(), options)
@ -174,7 +176,7 @@ GenerateConstructorCode(io::Printer* printer) const {
if (HasDescriptorMethods(descriptor_->file(), options_)) {
printer->Print(variables_,
"$name$_.SetAssignDescriptorCallback(\n"
" protobuf_AssignDescriptorsOnce);\n"
" $file_namespace$::protobuf_AssignDescriptorsOnce);\n"
"$name$_.SetEntryDescriptor(\n"
" &$type$_descriptor);\n");
}

147
src/google/protobuf/compiler/cpp/cpp_message.cc
View File

@ -505,6 +505,7 @@ MessageGenerator::MessageGenerator(const Descriptor* descriptor,
classname_(ClassName(descriptor, false)),
options_(options),
field_generators_(descriptor, options),
max_has_bit_index_(0),
nested_generators_(new google::protobuf::scoped_ptr<
MessageGenerator>[descriptor->nested_type_count()]),
enum_generators_(
@ -523,7 +524,7 @@ MessageGenerator::MessageGenerator(const Descriptor* descriptor,
OptimizePadding(&optimized_order_, options_);
if (HasFieldPresence(descriptor_->file())) {
int has_bit_index = 0;
// We use -1 as a sentinel.
has_bit_indices_.resize(descriptor_->field_count(), -1);
for (int i = 0; i < optimized_order_.size(); i++) {
const FieldDescriptor* field = optimized_order_[i];
@ -532,19 +533,7 @@ MessageGenerator::MessageGenerator(const Descriptor* descriptor,
continue;
}
has_bit_indices_[field->index()] = has_bit_index;
has_bit_index++;
}
// Assign fields that do not use has bits to be at the end. This can be
// removed once we shrink the has bits we assign.
//
// TODO(ckennelly): Shrink the has bits for these fields.
for (int i = 0; i < descriptor_->field_count(); i++) {
const FieldDescriptor* field = descriptor_->field(i);
if (has_bit_indices_[field->index()] < 0) {
has_bit_indices_[field->index()] = has_bit_index++;
}
has_bit_indices_[field->index()] = max_has_bit_index_++;
}
}
@ -581,9 +570,8 @@ MessageGenerator::MessageGenerator(const Descriptor* descriptor,
MessageGenerator::~MessageGenerator() {}
size_t MessageGenerator::HasBitsSize() const {
// TODO(jieluo) - Optimize _has_bits_ for repeated and oneof fields.
size_t sizeof_has_bits = (descriptor_->field_count() + 31) / 32 * 4;
if (descriptor_->field_count() == 0) {
size_t sizeof_has_bits = (max_has_bit_index_ + 31) / 32 * 4;
if (sizeof_has_bits == 0) {
// Zero-size arrays aren't technically allowed, and MSVC in particular
// doesn't like them. We still need to declare these arrays to make
// other code compile. Since this is an uncommon case, we'll just declare
@ -642,8 +630,28 @@ GenerateDependentFieldAccessorDeclarations(io::Printer* printer) {
void MessageGenerator::
GenerateFieldAccessorDeclarations(io::Printer* printer) {
// optimized_fields_ does not contain fields where
// field->containing_oneof() != NULL
// so we need to iterate over those as well.
//
// We place the non-oneof fields in optimized_order_, as that controls the
// order of the _has_bits_ entries and we want GDB's pretty printers to be
// able to infer these indices from the k[FIELDNAME]FieldNumber order.
std::vector<const FieldDescriptor*> ordered_fields;
ordered_fields.reserve(descriptor_->field_count());
ordered_fields.insert(
ordered_fields.begin(), optimized_order_.begin(), optimized_order_.end());
for (int i = 0; i < descriptor_->field_count(); i++) {
const FieldDescriptor* field = descriptor_->field(i);
if (field->containing_oneof() == NULL) {
continue;
}
ordered_fields.push_back(field);
}
for (int i = 0; i < ordered_fields.size(); i++) {
const FieldDescriptor* field = ordered_fields[i];
PrintFieldComment(printer, field);
@ -1191,12 +1199,14 @@ GenerateClassDefinition(io::Printer* printer) {
}
if (HasFastArraySerialization(descriptor_->file(), options_)) {
printer->Print(
"::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(\n"
" bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;\n"
"::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)\n"
" const PROTOBUF_FINAL {\n"
" return InternalSerializeWithCachedSizesToArray(false, output);\n"
"}\n");
"::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(\n"
" bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;\n"
"::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)\n"
" const PROTOBUF_FINAL {\n"
" return InternalSerializeWithCachedSizesToArray(\n"
" ::google::protobuf::io::CodedOutputStream::"
"IsDefaultSerializationDeterministic(), output);\n"
"}\n");
}
}
@ -1447,25 +1457,15 @@ GenerateClassDefinition(io::Printer* printer) {
"::google::protobuf::internal::AnyMetadata _any_metadata_;\n");
}
// Declare AddDescriptors(), BuildDescriptors(), and ShutdownFile() as
// friends so that they can access private static variables like
// default_instance_ and reflection_.
printer->Print("friend void $dllexport_decl$ $initdefaultsname$_impl();\n",
// Vars.
"dllexport_decl", options_.dllexport_decl, "initdefaultsname",
GlobalInitDefaultsName(descriptor_->file()->name()));
printer->Print("friend void $dllexport_decl$ $adddescriptorsname$_impl();\n",
// Vars.
"dllexport_decl", options_.dllexport_decl,
"adddescriptorsname",
GlobalAddDescriptorsName(descriptor_->file()->name()));
// The TableStruct struct needs access to the private parts, in order to
// construct the offsets of all members.
// Some InitDefault and Shutdown are defined as static member functions of
// TableStruct such that they are also allowed to access private members.
printer->Print(
"friend const ::google::protobuf::uint32* $offsetfunname$();\n"
"friend void $shutdownfilename$();\n"
"\n",
"offsetfunname", GlobalOffsetTableName(descriptor_->file()->name()),
"shutdownfilename", GlobalShutdownFileName(descriptor_->file()->name()));
"friend struct $dllexport_decl$ $file_namespace$::TableStruct;\n",
// Vars.
"dllexport_decl", options_.dllexport_decl, "file_namespace",
FileLevelNamespace(descriptor_->file()->name()));
printer->Outdent();
printer->Print("};");
@ -1510,15 +1510,13 @@ GenerateInlineMethods(io::Printer* printer, bool is_inline) {
}
void MessageGenerator::
GenerateDescriptorDeclarations(io::Printer* printer) {
GenerateExtraDefaultFields(io::Printer* printer) {
// Generate oneof default instance for reflection usage.
if (descriptor_->oneof_decl_count() > 0) {
printer->Print("struct $name$OneofInstance {\n",
"name", classname_);
printer->Print("public:\n");
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
for (int j = 0; j < descriptor_->oneof_decl(i)->field_count(); j++) {
const FieldDescriptor* field = descriptor_->oneof_decl(i)->field(j);
printer->Print(" ");
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE ||
(field->cpp_type() == FieldDescriptor::CPPTYPE_STRING &&
EffectiveStringCType(field) != FieldOptions::STRING)) {
@ -1527,8 +1525,6 @@ GenerateDescriptorDeclarations(io::Printer* printer) {
field_generators_.get(field).GeneratePrivateMembers(printer);
}
}
printer->Print("} $name$_default_oneof_instance_;\n", "name", classname_);
}
}
@ -1555,6 +1551,7 @@ GenerateTypeRegistrations(io::Printer* printer) {
std::map<string, string> vars;
CollectMapInfo(descriptor_, &vars);
vars["classname"] = classname_;
vars["file_namespace"] = FileLevelNamespace(descriptor_->file()->name());
const FieldDescriptor* val = descriptor_->FindFieldByName("value");
if (descriptor_->file()->syntax() == FileDescriptor::SYNTAX_PROTO2 &&
@ -1570,7 +1567,8 @@ GenerateTypeRegistrations(io::Printer* printer) {
printer->Print(
vars,
"const ::google::protobuf::Descriptor* $classname$_descriptor = "
"file_level_metadata[$index_in_metadata$].descriptor;\n"
"$file_namespace$::file_level_metadata[$index_in_metadata$].descriptor;"
"\n"
"::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(\n"
" $classname$_descriptor,\n"
" ::google::protobuf::internal::MapEntry<\n"
@ -1620,7 +1618,7 @@ GenerateDefaultInstanceInitializer(io::Printer* printer) {
HasDescriptorMethods(descriptor_->file(), options_))) {
string name;
if (field->containing_oneof()) {
name = classname_ + "_default_oneof_instance_.";
name = "_" + classname_ + "_default_instance_.";
} else {
name = "_" + classname_ + "_default_instance_.get_mutable()->";
}
@ -1740,11 +1738,12 @@ GenerateClassMethods(io::Printer* printer) {
if (HasDescriptorMethods(descriptor_->file(), options_)) {
printer->Print(
"::google::protobuf::Metadata $classname$::GetMetadata() const {\n"
" protobuf_AssignDescriptorsOnce();\n"
" return file_level_metadata[$index$];\n"
" $file_namespace$::protobuf_AssignDescriptorsOnce();\n"
" return $file_namespace$::file_level_metadata[$index$];\n"
"}\n"
"\n",
"classname", classname_, "index", SimpleItoa(index_in_metadata_));
"classname", classname_, "index", SimpleItoa(index_in_metadata_),
"file_namespace", FileLevelNamespace(descriptor_->file()->name()));
} else {
printer->Print(
"::std::string $classname$::GetTypeName() const {\n"
@ -1798,7 +1797,7 @@ std::pair<size_t, size_t> MessageGenerator::GenerateOffsets(
if (field->containing_oneof()) {
printer->Print(
"PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET("
"(&$classname$_default_oneof_instance_), $name$_),\n",
"(&_$classname$_default_instance_), $name$_),\n",
"classname", classname_, "name", FieldName(field));
} else {
printer->Print(
@ -1820,7 +1819,9 @@ std::pair<size_t, size_t> MessageGenerator::GenerateOffsets(
if (HasFieldPresence(descriptor_->file())) {
entries += has_bit_indices_.size();
for (int i = 0; i < has_bit_indices_.size(); i++) {
printer->Print("$index$,\n", "index", SimpleItoa(has_bit_indices_[i]));
const string index = has_bit_indices_[i] >= 0 ?
SimpleItoa(has_bit_indices_[i]) : "~0u";
printer->Print("$index$,\n", "index", index);
}
}
@ -1849,9 +1850,10 @@ GenerateSharedConstructorCode(io::Printer* printer) {
IsMapEntryMessage(descriptor_->nested_type(i))) {
printer->Print(
"const ::google::protobuf::Descriptor*& $type$_descriptor = "
"file_level_metadata[$index$].descriptor;\n",
"$file_namespace$::file_level_metadata[$index$].descriptor;\n",
"type", ClassName(descriptor_->nested_type(i), false), "index",
SimpleItoa(nested_generators_[i]->index_in_metadata_));
SimpleItoa(nested_generators_[i]->index_in_metadata_),
"file_namespace", FileLevelNamespace(descriptor_->file()->name()));
}
}
@ -2086,14 +2088,14 @@ GenerateStructors(io::Printer* printer) {
"$classname$::$classname$()\n"
" : $superclass$()$initializer$ {\n"
" if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {\n"
" $initdefaultsname$();\n"
" $file_namespace$::InitDefaults();\n"
" }\n"
" SharedCtor();\n"
" // @@protoc_insertion_point(constructor:$full_name$)\n"
"}\n",
"classname", classname_, "superclass", superclass, "full_name",
descriptor_->full_name(), "initializer", initializer_null,
"initdefaultsname", GlobalInitDefaultsName(descriptor_->file()->name()));
"file_namespace", FileLevelNamespace(descriptor_->file()->name()));
if (SupportsArenas(descriptor_)) {
printer->Print(
@ -2102,7 +2104,7 @@ GenerateStructors(io::Printer* printer) {
// When arenas are used it's safe to assume we have finished
// static init time (protos with arenas are unsafe during static init)
"#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER\n"
" $initdefaultsname$();\n"
" $file_namespace$::InitDefaults();\n"
"#endif // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER\n"
" SharedCtor();\n"
" RegisterArenaDtor(arena);\n"
@ -2110,8 +2112,7 @@ GenerateStructors(io::Printer* printer) {
"}\n",
"initializer", initializer_with_arena, "classname", classname_,
"superclass", superclass, "full_name", descriptor_->full_name(),
"initdefaultsname",
GlobalInitDefaultsName(descriptor_->file()->name()));
"file_namespace", FileLevelNamespace(descriptor_->file()->name()));
}
// Generate the copy constructor.
@ -2182,9 +2183,10 @@ GenerateStructors(io::Printer* printer) {
IsMapEntryMessage(descriptor_->nested_type(i))) {
printer->Print(
"const ::google::protobuf::Descriptor*& $type$_descriptor = "
"file_level_metadata[$index$].descriptor;\n",
"$file_namespace$::file_level_metadata[$index$].descriptor;\n",
"type", ClassName(descriptor_->nested_type(i), false), "index",
SimpleItoa(nested_generators_[i]->index_in_metadata_));
SimpleItoa(nested_generators_[i]->index_in_metadata_),
"file_namespace", FileLevelNamespace(descriptor_->file()->name()));
}
}
@ -2265,20 +2267,21 @@ GenerateStructors(io::Printer* printer) {
!descriptor_->options().no_standard_descriptor_accessor()) {
printer->Print(
"const ::google::protobuf::Descriptor* $classname$::descriptor() {\n"
" protobuf_AssignDescriptorsOnce();\n"
" return file_level_metadata[$index$].descriptor;\n"
" $file_namespace$::protobuf_AssignDescriptorsOnce();\n"
" return $file_namespace$::file_level_metadata[$index$].descriptor;\n"
"}\n"
"\n",
"index", SimpleItoa(index_in_metadata_), "classname", classname_);
"index", SimpleItoa(index_in_metadata_), "classname", classname_,
"file_namespace", FileLevelNamespace(descriptor_->file()->name()));
}
printer->Print(
"const $classname$& $classname$::default_instance() {\n"
" $initdefaultsname$();\n"
" $file_namespace$::InitDefaults();\n"
" return *internal_default_instance();\n"
"}\n\n",
"classname", classname_, "initdefaultsname",
GlobalInitDefaultsName(descriptor_->file()->name()));
"classname", classname_, "file_namespace",
FileLevelNamespace(descriptor_->file()->name()));
if (SupportsArenas(descriptor_)) {
printer->Print(
@ -2630,7 +2633,7 @@ GenerateSwap(io::Printer* printer) {
}
if (HasFieldPresence(descriptor_->file())) {
for (int i = 0; i < (descriptor_->field_count() + 31) / 32; ++i) {
for (int i = 0; i < HasBitsSize() / 4; ++i) {
printer->Print("std::swap(_has_bits_[$i$], other->_has_bits_[$i$]);\n",
"i", SimpleItoa(i));
}
@ -3260,7 +3263,7 @@ void MessageGenerator::GenerateSerializeOneExtensionRange(
if (to_array) {
printer->Print(vars,
"target = _extensions_.InternalSerializeWithCachedSizesToArray(\n"
" $start$, $end$, false, target);\n\n");
" $start$, $end$, deterministic, target);\n\n");
} else {
printer->Print(vars,
"_extensions_.SerializeWithCachedSizes(\n"
@ -3335,7 +3338,7 @@ GenerateSerializeWithCachedSizesToArray(io::Printer* printer) {
"classname", classname_);
printer->Indent();
printer->Print("(void)deterministic; // Unused\n");
printer->Print("(void)deterministic; // Unused\n");
printer->Print(
"// @@protoc_insertion_point(serialize_to_array_start:$full_name$)\n",
"full_name", descriptor_->full_name());

6
src/google/protobuf/compiler/cpp/cpp_message.h
View File

@ -91,9 +91,8 @@ class MessageGenerator {
// Source file stuff.
// Generate code which declares all the global descriptor pointers which
// will be initialized by the methods below.
void GenerateDescriptorDeclarations(io::Printer* printer);
// Generate extra fields
void GenerateExtraDefaultFields(io::Printer* printer);
// Generate code that calls MessageFactory::InternalRegisterGeneratedMessage()
// for all types.
@ -201,6 +200,7 @@ class MessageGenerator {
// optimized_order_ excludes oneof fields.
std::vector<const FieldDescriptor *> optimized_order_;
std::vector<int> has_bit_indices_;
int max_has_bit_index_;
google::protobuf::scoped_array<google::protobuf::scoped_ptr<MessageGenerator> > nested_generators_;
google::protobuf::scoped_array<google::protobuf::scoped_ptr<EnumGenerator> > enum_generators_;
google::protobuf::scoped_array<google::protobuf::scoped_ptr<ExtensionGenerator> > extension_generators_;

4
src/google/protobuf/compiler/cpp/cpp_message_field.cc
View File

@ -487,9 +487,6 @@ GenerateClearingCode(io::Printer* printer) const {
void MessageFieldGenerator::
GenerateMessageClearingCode(io::Printer* printer) const {
std::map<string, string> variables(variables_);
variables["type"] = FieldMessageTypeName(descriptor_);
if (!HasFieldPresence(descriptor_->file())) {
// If we don't have has-bits, message presence is indicated only by ptr !=
// NULL. Thus on clear, we need to delete the object.
@ -1035,7 +1032,6 @@ GenerateInlineAccessorDefinitions(io::Printer* printer,
"}\n");
}
if (!dependent_field_) {
printer->Print(variables,
"$inline$"

50
src/google/protobuf/compiler/cpp/cpp_primitive_field.cc
View File

@ -245,7 +245,7 @@ void PrimitiveOneofFieldGenerator::
GenerateConstructorCode(io::Printer* printer) const {
printer->Print(
variables_,
" $classname$_default_oneof_instance_.$name$_ = $default$;\n");
"_$classname$_default_instance_.$name$_ = $default$;\n");
}
void PrimitiveOneofFieldGenerator::
@ -373,6 +373,7 @@ GenerateMergeFromCodedStreamWithPacking(io::Printer* printer) const {
void RepeatedPrimitiveFieldGenerator::
GenerateSerializeWithCachedSizes(io::Printer* printer) const {
bool array_written = false;
if (descriptor_->is_packed()) {
// Write the tag and the size.
printer->Print(variables_,
@ -381,21 +382,30 @@ GenerateSerializeWithCachedSizes(io::Printer* printer) const {
"$number$, "
"::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, "
"output);\n"
" output->WriteVarint32(_$name$_cached_byte_size_);\n"
"}\n");
" output->WriteVarint32(_$name$_cached_byte_size_);\n");
if (FixedSize(descriptor_->type()) > 0) {
printer->Print(variables_,
" ::google::protobuf::internal::WireFormatLite::Write$declared_type$Array(\n"
" this->$name$().data(), this->$name$_size(), output);\n");
array_written = true; // Wrote array all at once
}
printer->Print(variables_, "}\n");
}
printer->Print(variables_,
"for (int i = 0; i < this->$name$_size(); i++) {\n");
if (descriptor_->is_packed()) {
if (!array_written) {
printer->Print(variables_,
" ::google::protobuf::internal::WireFormatLite::Write$declared_type$NoTag(\n"
" this->$name$(i), output);\n");
} else {
printer->Print(variables_,
" ::google::protobuf::internal::WireFormatLite::Write$declared_type$(\n"
" $number$, this->$name$(i), output);\n");
"for (int i = 0; i < this->$name$_size(); i++) {\n");
if (descriptor_->is_packed()) {
printer->Print(variables_,
" ::google::protobuf::internal::WireFormatLite::Write$declared_type$NoTag(\n"
" this->$name$(i), output);\n");
} else {
printer->Print(variables_,
" ::google::protobuf::internal::WireFormatLite::Write$declared_type$(\n"
" $number$, this->$name$(i), output);\n");
}
printer->Print("}\n");
}
printer->Print("}\n");
}
void RepeatedPrimitiveFieldGenerator::
@ -428,21 +438,17 @@ GenerateSerializeWithCachedSizesToArray(io::Printer* printer) const {
void RepeatedPrimitiveFieldGenerator::
GenerateByteSize(io::Printer* printer) const {
printer->Print(variables_,
"{\n"
" size_t data_size = 0;\n"
" unsigned int count = this->$name$_size();\n");
printer->Print(variables_, "{\n");
printer->Indent();
int fixed_size = FixedSize(descriptor_->type());
if (fixed_size == -1) {
printer->Print(variables_,
"for (unsigned int i = 0; i < count; i++) {\n"
" data_size += ::google::protobuf::internal::WireFormatLite::\n"
" $declared_type$Size(this->$name$(i));\n"
"}\n");
"size_t data_size = ::google::protobuf::internal::WireFormatLite::\n"
" $declared_type$Size(this->$name$_);\n");
} else {
printer->Print(variables_,
"data_size = $fixed_size$UL * count;\n");
"unsigned int count = this->$name$_size();\n"
"size_t data_size = $fixed_size$UL * count;\n");
}
if (descriptor_->is_packed()) {

7
src/google/protobuf/compiler/cpp/cpp_service.cc
View File

@ -46,6 +46,7 @@ ServiceGenerator::ServiceGenerator(const ServiceDescriptor* descriptor,
const Options& options)
: descriptor_(descriptor) {
vars_["classname"] = descriptor_->name();
vars_["file_namespace"] = FileLevelNamespace(descriptor_->file()->name());
vars_["full_name"] = descriptor_->full_name();
if (options.dllexport_decl.empty()) {
vars_["dllexport"] = "";
@ -178,8 +179,8 @@ void ServiceGenerator::GenerateImplementation(io::Printer* printer) {
"$classname$::~$classname$() {}\n"
"\n"
"const ::google::protobuf::ServiceDescriptor* $classname$::descriptor() {\n"
" protobuf_AssignDescriptorsOnce();\n"
" return file_level_service_descriptors[$index$];\n"
" $file_namespace$::protobuf_AssignDescriptorsOnce();\n"
" return $file_namespace$::file_level_service_descriptors[$index$];\n"
"}\n"
"\n"
"const ::google::protobuf::ServiceDescriptor* $classname$::GetDescriptor() {\n"
@ -241,7 +242,7 @@ void ServiceGenerator::GenerateCallMethod(io::Printer* printer) {
" ::google::protobuf::Message* response,\n"
" ::google::protobuf::Closure* done) {\n"
" GOOGLE_DCHECK_EQ(method->service(), "
"file_level_service_descriptors[$index$]);\n"
"$file_namespace$::file_level_service_descriptors[$index$]);\n"
" switch(method->index()) {\n");
for (int i = 0; i < descriptor_->method_count(); i++) {

9
src/google/protobuf/compiler/cpp/cpp_string_field.cc
View File

@ -762,7 +762,7 @@ void StringOneofFieldGenerator::
GenerateConstructorCode(io::Printer* printer) const {
printer->Print(
variables_,
"$classname$_default_oneof_instance_.$name$_.UnsafeSetDefault(\n"
"_$classname$_default_instance_.$name$_.UnsafeSetDefault(\n"
" $default_variable$);\n");
}
@ -838,9 +838,7 @@ GenerateAccessorDeclarations(io::Printer* printer) const {
"$deprecated_attr$void add_$name$(const ::std::string& value);\n"
"$deprecated_attr$void add_$name$(const char* value);\n"
"$deprecated_attr$void add_$name$(const $pointer_type$* value, size_t size)"
";\n");
printer->Print(variables_,
";\n"
"$deprecated_attr$const ::google::protobuf::RepeatedPtrField< ::std::string>& $name$() "
"const;\n"
"$deprecated_attr$::google::protobuf::RepeatedPtrField< ::std::string>* mutable_$name$()"
@ -898,8 +896,7 @@ GenerateInlineAccessorDefinitions(io::Printer* printer,
"$classname$::add_$name$(const $pointer_type$* value, size_t size) {\n"
" $name$_.Add()->assign(reinterpret_cast<const char*>(value), size);\n"
" // @@protoc_insertion_point(field_add_pointer:$full_name$)\n"
"}\n");
printer->Print(variables,
"}\n"
"$inline$const ::google::protobuf::RepeatedPtrField< ::std::string>&\n"
"$classname$::$name$() const {\n"
" // @@protoc_insertion_point(field_list:$full_name$)\n"

1
src/google/protobuf/compiler/java/java_enum_field_lite.cc
View File

@ -76,6 +76,7 @@ void SetEnumVariables(const FieldDescriptor* descriptor,
// by the proto compiler
(*variables)["deprecation"] = descriptor->options().deprecated()
? "@java.lang.Deprecated " : "";
(*variables)["required"] = descriptor->is_required() ? "true" : "false";
if (SupportFieldPresence(descriptor->file())) {
// For singular messages and builders, one bit is used for the hasField bit.

1
src/google/protobuf/compiler/java/java_message_field_lite.cc
View File

@ -70,6 +70,7 @@ void SetMessageVariables(const FieldDescriptor* descriptor,
// by the proto compiler
(*variables)["deprecation"] = descriptor->options().deprecated()
? "@java.lang.Deprecated " : "";
(*variables)["required"] = descriptor->is_required() ? "true" : "false";
if (SupportFieldPresence(descriptor->file())) {
// For singular messages and builders, one bit is used for the hasField bit.

4
src/google/protobuf/compiler/java/java_message_lite.cc
View File

@ -928,10 +928,10 @@ void ImmutableMessageLiteGenerator::GenerateDynamicMethodMergeFromStream(
"com.google.protobuf.CodedInputStream input =\n"
" (com.google.protobuf.CodedInputStream) arg0;\n"
"com.google.protobuf.ExtensionRegistryLite extensionRegistry =\n"
" (com.google.protobuf.ExtensionRegistryLite) arg1;\n"
" (com.google.protobuf.ExtensionRegistryLite) arg1;\n");
printer->Print(
"try {\n");
printer->Indent();
printer->Print(
"boolean done = false;\n"
"while (!done) {\n");

1
src/google/protobuf/compiler/java/java_primitive_field_lite.cc
View File

@ -74,6 +74,7 @@ void SetPrimitiveVariables(const FieldDescriptor* descriptor,
SimpleItoa(static_cast<int32>(WireFormat::MakeTag(descriptor)));
(*variables)["tag_size"] = SimpleItoa(
WireFormat::TagSize(descriptor->number(), GetType(descriptor)));
(*variables)["required"] = descriptor->is_required() ? "true" : "false";
string capitalized_type = UnderscoresToCamelCase(PrimitiveTypeName(javaType),
true /* cap_next_letter */);

17
src/google/protobuf/compiler/java/java_shared_code_generator.cc
View File

@ -181,13 +181,11 @@ void SharedCodeGenerator::GenerateDescriptors(io::Printer* printer) {
// Find out all dependencies.
std::vector<std::pair<string, string> > dependencies;
for (int i = 0; i < file_->dependency_count(); i++) {
if (ShouldIncludeDependency(file_->dependency(i))) {
string filename = file_->dependency(i)->name();
string classname = FileJavaPackage(file_->dependency(i)) + "." +
name_resolver_->GetDescriptorClassName(
file_->dependency(i));
dependencies.push_back(std::make_pair(filename, classname));
}
string filename = file_->dependency(i)->name();
string classname = FileJavaPackage(file_->dependency(i)) + "." +
name_resolver_->GetDescriptorClassName(
file_->dependency(i));
dependencies.push_back(std::make_pair(filename, classname));
}
// -----------------------------------------------------------------
@ -209,11 +207,6 @@ void SharedCodeGenerator::GenerateDescriptors(io::Printer* printer) {
" }, assigner);\n");
}
bool SharedCodeGenerator::ShouldIncludeDependency(
const FileDescriptor* descriptor) {
return true;
}
} // namespace java
} // namespace compiler
} // namespace protobuf

5
src/google/protobuf/compiler/java/java_shared_code_generator.h
View File

@ -77,11 +77,6 @@ class SharedCodeGenerator {
void GenerateDescriptors(io::Printer* printer);
private:
// Returns whether the dependency should be included in the output file.
// Always returns true for opensource, but used internally at Google to help
// improve compatibility with version 1 of protocol buffers.
bool ShouldIncludeDependency(const FileDescriptor* descriptor);
google::protobuf::scoped_ptr<ClassNameResolver> name_resolver_;
const FileDescriptor* file_;
const Options options_;

1
src/google/protobuf/compiler/java/java_string_field_lite.cc
View File

@ -85,6 +85,7 @@ void SetPrimitiveVariables(const FieldDescriptor* descriptor,
// by the proto compiler
(*variables)["deprecation"] = descriptor->options().deprecated()
? "@java.lang.Deprecated " : "";
(*variables)["required"] = descriptor->is_required() ? "true" : "false";
if (SupportFieldPresence(descriptor->file())) {
// For singular messages and builders, one bit is used for the hasField bit.

12
src/google/protobuf/compiler/parser.cc
View File

@ -249,11 +249,11 @@ bool Parser::ConsumeNumber(double* output, const char* error) {
input_->Next();
return true;
} else if (LookingAt("inf")) {
*output = numeric_limits<double>::infinity();
*output = std::numeric_limits<double>::infinity();
input_->Next();
return true;
} else if (LookingAt("nan")) {
*output = numeric_limits<double>::quiet_NaN();
*output = std::numeric_limits<double>::quiet_NaN();
input_->Next();
return true;
} else {
@ -282,7 +282,7 @@ bool Parser::TryConsumeEndOfDeclaration(
const char* text, const LocationRecorder* location) {
if (LookingAt(text)) {
string leading, trailing;
vector<string> detached;
std::vector<string> detached;
input_->NextWithComments(&trailing, &detached, &leading);
// Save the leading comments for next time, and recall the leading comments
@ -404,7 +404,7 @@ void Parser::LocationRecorder::RecordLegacyLocation(const Message* descriptor,
void Parser::LocationRecorder::AttachComments(
string* leading, string* trailing,
vector<string>* detached_comments) const {
std::vector<string>* detached_comments) const {
GOOGLE_CHECK(!location_->has_leading_comments());
GOOGLE_CHECK(!location_->has_trailing_comments());
@ -487,7 +487,7 @@ bool Parser::ValidateEnum(const EnumDescriptorProto* proto) {
return false;
}
set<int> used_values;
std::set<int> used_values;
bool has_duplicates = false;
for (int i = 0; i < proto->value_size(); ++i) {
const EnumValueDescriptorProto enum_value = proto->value(i);
@ -2089,7 +2089,7 @@ bool SourceLocationTable::Find(
const Message* descriptor,
DescriptorPool::ErrorCollector::ErrorLocation location,
int* line, int* column) const {
const pair<int, int>* result =
const std::pair<int, int>* result =
FindOrNull(location_map_, std::make_pair(descriptor, location));
if (result == NULL) {
*line = -1;

7
src/google/protobuf/compiler/php/php_generator.cc
View File

@ -757,12 +757,15 @@ void GenerateEnumFile(const FileDescriptor* file, const EnumDescriptor* en,
std::string fullname = FilenameToClassname(filename);
int lastindex = fullname.find_last_of("\\");
GenerateEnumDocComment(&printer, en);
if (lastindex != string::npos) {
if (!file->package().empty()) {
printer.Print(
"namespace ^name^;\n\n",
"name", fullname.substr(0, lastindex));
}
GenerateEnumDocComment(&printer, en);
if (lastindex != string::npos) {
printer.Print(
"class ^name^\n"
"{\n",

218
src/google/protobuf/compiler/plugin.pb.cc
View File

@ -20,14 +20,17 @@
namespace google {
namespace protobuf {
namespace compiler {
class VersionDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Version> {};
VersionDefaultTypeInternal _Version_default_instance_;
class CodeGeneratorRequestDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<CodeGeneratorRequest> {};
CodeGeneratorRequestDefaultTypeInternal _CodeGeneratorRequest_default_instance_;
class CodeGeneratorResponse_FileDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<CodeGeneratorResponse_File> {};
CodeGeneratorResponse_FileDefaultTypeInternal _CodeGeneratorResponse_File_default_instance_;
class CodeGeneratorResponseDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<CodeGeneratorResponse> {};
CodeGeneratorResponseDefaultTypeInternal _CodeGeneratorResponse_default_instance_;
class VersionDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Version> {
} _Version_default_instance_;
class CodeGeneratorRequestDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<CodeGeneratorRequest> {
} _CodeGeneratorRequest_default_instance_;
class CodeGeneratorResponse_FileDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<CodeGeneratorResponse_File> {
} _CodeGeneratorResponse_File_default_instance_;
class CodeGeneratorResponseDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<CodeGeneratorResponse> {
} _CodeGeneratorResponse_default_instance_;
namespace protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto {
namespace {
@ -35,55 +38,50 @@ namespace {
} // namespace
const ::google::protobuf::uint32* protobuf_Offsets_google_2fprotobuf_2fcompiler_2fplugin_2eproto() GOOGLE_ATTRIBUTE_COLD;
const ::google::protobuf::uint32* protobuf_Offsets_google_2fprotobuf_2fcompiler_2fplugin_2eproto() {
static const ::google::protobuf::uint32 offsets[] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Version, _has_bits_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Version, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Version, major_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Version, minor_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Version, patch_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Version, suffix_),
1,
2,
3,
0,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorRequest, _has_bits_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorRequest, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorRequest, file_to_generate_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorRequest, parameter_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorRequest, proto_file_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorRequest, compiler_version_),
2,
0,
3,
1,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse_File, _has_bits_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse_File, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse_File, name_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse_File, insertion_point_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse_File, content_),
0,
1,
2,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse, _has_bits_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse, error_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse, file_),
0,
1,
};
return offsets;
}
const ::google::protobuf::uint32 TableStruct::offsets[] = {
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Version, _has_bits_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Version, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Version, major_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Version, minor_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Version, patch_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Version, suffix_),
1,
2,
3,
0,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorRequest, _has_bits_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorRequest, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorRequest, file_to_generate_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorRequest, parameter_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorRequest, proto_file_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorRequest, compiler_version_),
~0u,
0,
~0u,
1,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse_File, _has_bits_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse_File, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse_File, name_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse_File, insertion_point_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse_File, content_),
0,
1,
2,
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse, _has_bits_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse, error_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CodeGeneratorResponse, file_),
0,
~0u,
};
static const ::google::protobuf::internal::MigrationSchema schemas[] = {
{ 0, 8, sizeof(Version)},
@ -92,20 +90,20 @@ static const ::google::protobuf::internal::MigrationSchema schemas[] = {
{ 34, 40, sizeof(CodeGeneratorResponse)},
};
static const ::google::protobuf::internal::DefaultInstanceData file_default_instances[] = {
{reinterpret_cast<const ::google::protobuf::Message*>(&_Version_default_instance_), NULL},
{reinterpret_cast<const ::google::protobuf::Message*>(&_CodeGeneratorRequest_default_instance_), NULL},
{reinterpret_cast<const ::google::protobuf::Message*>(&_CodeGeneratorResponse_File_default_instance_), NULL},
{reinterpret_cast<const ::google::protobuf::Message*>(&_CodeGeneratorResponse_default_instance_), NULL},
static ::google::protobuf::Message const * const file_default_instances[] = {
reinterpret_cast<const ::google::protobuf::Message*>(&_Version_default_instance_),
reinterpret_cast<const ::google::protobuf::Message*>(&_CodeGeneratorRequest_default_instance_),
reinterpret_cast<const ::google::protobuf::Message*>(&_CodeGeneratorResponse_File_default_instance_),
reinterpret_cast<const ::google::protobuf::Message*>(&_CodeGeneratorResponse_default_instance_),
};
namespace {
void protobuf_AssignDescriptors() {
protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
AddDescriptors();
::google::protobuf::MessageFactory* factory = NULL;
AssignDescriptors(
"google/protobuf/compiler/plugin.proto", schemas, file_default_instances, protobuf_Offsets_google_2fprotobuf_2fcompiler_2fplugin_2eproto(), factory,
"google/protobuf/compiler/plugin.proto", schemas, file_default_instances, TableStruct::offsets, factory,
file_level_metadata, NULL, NULL);
}
@ -122,7 +120,7 @@ void protobuf_RegisterTypes(const ::std::string&) {
} // namespace
void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fplugin_2eproto() {
void TableStruct::Shutdown() {
_Version_default_instance_.Shutdown();
delete file_level_metadata[0].reflection;
_CodeGeneratorRequest_default_instance_.Shutdown();
@ -133,11 +131,11 @@ void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fplugin_2eproto() {
delete file_level_metadata[3].reflection;
}
void protobuf_InitDefaults_google_2fprotobuf_2fcompiler_2fplugin_2eproto_impl() {
void TableStruct::InitDefaultsImpl() {
GOOGLE_PROTOBUF_VERIFY_VERSION;
::google::protobuf::protobuf_InitDefaults_google_2fprotobuf_2fdescriptor_2eproto();
::google::protobuf::internal::InitProtobufDefaults();
::google::protobuf::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaults();
_Version_default_instance_.DefaultConstruct();
_CodeGeneratorRequest_default_instance_.DefaultConstruct();
_CodeGeneratorResponse_File_default_instance_.DefaultConstruct();
@ -146,12 +144,12 @@ void protobuf_InitDefaults_google_2fprotobuf_2fcompiler_2fplugin_2eproto_impl()
::google::protobuf::compiler::Version::internal_default_instance());
}
void protobuf_InitDefaults_google_2fprotobuf_2fcompiler_2fplugin_2eproto() {
void InitDefaults() {
static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
::google::protobuf::GoogleOnceInit(&once, &protobuf_InitDefaults_google_2fprotobuf_2fcompiler_2fplugin_2eproto_impl);
::google::protobuf::GoogleOnceInit(&once, &TableStruct::InitDefaultsImpl);
}
void protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto_impl() {
protobuf_InitDefaults_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
void AddDescriptorsImpl() {
InitDefaults();
static const char descriptor[] = {
"\n%google/protobuf/compiler/plugin.proto\022"
"\030google.protobuf.compiler\032 google/protob"
@ -173,21 +171,23 @@ void protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto_impl() {
descriptor, 590);
::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
"google/protobuf/compiler/plugin.proto", &protobuf_RegisterTypes);
::google::protobuf::protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fplugin_2eproto);
::google::protobuf::protobuf_google_2fprotobuf_2fdescriptor_2eproto::AddDescriptors();
::google::protobuf::internal::OnShutdown(&TableStruct::Shutdown);
}
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto_once_);
void protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto() {
::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto_once_,
&protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto_impl);
void AddDescriptors() {
static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl);
}
// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_google_2fprotobuf_2fcompiler_2fplugin_2eproto {
StaticDescriptorInitializer_google_2fprotobuf_2fcompiler_2fplugin_2eproto() {
protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
struct StaticDescriptorInitializer {
StaticDescriptorInitializer() {
AddDescriptors();
}
} static_descriptor_initializer_google_2fprotobuf_2fcompiler_2fplugin_2eproto_;
} static_descriptor_initializer;
} // namespace protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto
// ===================================================================
@ -201,7 +201,7 @@ const int Version::kSuffixFieldNumber;
Version::Version()
: ::google::protobuf::Message(), _internal_metadata_(NULL) {
if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
protobuf_InitDefaults_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::InitDefaults();
}
SharedCtor();
// @@protoc_insertion_point(constructor:google.protobuf.compiler.Version)
@ -244,12 +244,12 @@ void Version::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Version::descriptor() {
protobuf_AssignDescriptorsOnce();
return file_level_metadata[0].descriptor;
protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::protobuf_AssignDescriptorsOnce();
return protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::file_level_metadata[0].descriptor;
}
const Version& Version::default_instance() {
protobuf_InitDefaults_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::InitDefaults();
return *internal_default_instance();
}
@ -398,7 +398,7 @@ void Version::SerializeWithCachedSizes(
::google::protobuf::uint8* Version::InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const {
(void)deterministic; // Unused
(void)deterministic; // Unused
// @@protoc_insertion_point(serialize_to_array_start:google.protobuf.compiler.Version)
// optional int32 major = 1;
if (has_major()) {
@ -549,8 +549,8 @@ void Version::InternalSwap(Version* other) {
}
::google::protobuf::Metadata Version::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
return file_level_metadata[0];
protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::protobuf_AssignDescriptorsOnce();
return protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::file_level_metadata[0];
}
#if PROTOBUF_INLINE_NOT_IN_HEADERS
@ -704,7 +704,7 @@ const int CodeGeneratorRequest::kCompilerVersionFieldNumber;
CodeGeneratorRequest::CodeGeneratorRequest()
: ::google::protobuf::Message(), _internal_metadata_(NULL) {
if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
protobuf_InitDefaults_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::InitDefaults();
}
SharedCtor();
// @@protoc_insertion_point(constructor:google.protobuf.compiler.CodeGeneratorRequest)
@ -753,12 +753,12 @@ void CodeGeneratorRequest::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CodeGeneratorRequest::descriptor() {
protobuf_AssignDescriptorsOnce();
return file_level_metadata[1].descriptor;
protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::protobuf_AssignDescriptorsOnce();
return protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::file_level_metadata[1].descriptor;
}
const CodeGeneratorRequest& CodeGeneratorRequest::default_instance() {
protobuf_InitDefaults_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::InitDefaults();
return *internal_default_instance();
}
@ -919,7 +919,7 @@ void CodeGeneratorRequest::SerializeWithCachedSizes(
::google::protobuf::uint8* CodeGeneratorRequest::InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const {
(void)deterministic; // Unused
(void)deterministic; // Unused
// @@protoc_insertion_point(serialize_to_array_start:google.protobuf.compiler.CodeGeneratorRequest)
// repeated string file_to_generate = 1;
for (int i = 0; i < this->file_to_generate_size(); i++) {
@ -1081,8 +1081,8 @@ void CodeGeneratorRequest::InternalSwap(CodeGeneratorRequest* other) {
}
::google::protobuf::Metadata CodeGeneratorRequest::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
return file_level_metadata[1];
protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::protobuf_AssignDescriptorsOnce();
return protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::file_level_metadata[1];
}
#if PROTOBUF_INLINE_NOT_IN_HEADERS
@ -1293,7 +1293,7 @@ const int CodeGeneratorResponse_File::kContentFieldNumber;
CodeGeneratorResponse_File::CodeGeneratorResponse_File()
: ::google::protobuf::Message(), _internal_metadata_(NULL) {
if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
protobuf_InitDefaults_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::InitDefaults();
}
SharedCtor();
// @@protoc_insertion_point(constructor:google.protobuf.compiler.CodeGeneratorResponse.File)
@ -1343,12 +1343,12 @@ void CodeGeneratorResponse_File::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CodeGeneratorResponse_File::descriptor() {
protobuf_AssignDescriptorsOnce();
return file_level_metadata[2].descriptor;
protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::protobuf_AssignDescriptorsOnce();
return protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::file_level_metadata[2].descriptor;
}
const CodeGeneratorResponse_File& CodeGeneratorResponse_File::default_instance() {
protobuf_InitDefaults_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::InitDefaults();
return *internal_default_instance();
}
@ -1499,7 +1499,7 @@ void CodeGeneratorResponse_File::SerializeWithCachedSizes(
::google::protobuf::uint8* CodeGeneratorResponse_File::InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const {
(void)deterministic; // Unused
(void)deterministic; // Unused
// @@protoc_insertion_point(serialize_to_array_start:google.protobuf.compiler.CodeGeneratorResponse.File)
// optional string name = 1;
if (has_name()) {
@ -1648,8 +1648,8 @@ void CodeGeneratorResponse_File::InternalSwap(CodeGeneratorResponse_File* other)
}
::google::protobuf::Metadata CodeGeneratorResponse_File::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
return file_level_metadata[2];
protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::protobuf_AssignDescriptorsOnce();
return protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::file_level_metadata[2];
}
#if PROTOBUF_INLINE_NOT_IN_HEADERS
@ -1853,7 +1853,7 @@ const int CodeGeneratorResponse::kFileFieldNumber;
CodeGeneratorResponse::CodeGeneratorResponse()
: ::google::protobuf::Message(), _internal_metadata_(NULL) {
if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
protobuf_InitDefaults_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::InitDefaults();
}
SharedCtor();
// @@protoc_insertion_point(constructor:google.protobuf.compiler.CodeGeneratorResponse)
@ -1892,12 +1892,12 @@ void CodeGeneratorResponse::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* CodeGeneratorResponse::descriptor() {
protobuf_AssignDescriptorsOnce();
return file_level_metadata[3].descriptor;
protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::protobuf_AssignDescriptorsOnce();
return protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::file_level_metadata[3].descriptor;
}
const CodeGeneratorResponse& CodeGeneratorResponse::default_instance() {
protobuf_InitDefaults_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::InitDefaults();
return *internal_default_instance();
}
@ -2008,7 +2008,7 @@ void CodeGeneratorResponse::SerializeWithCachedSizes(
::google::protobuf::uint8* CodeGeneratorResponse::InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const {
(void)deterministic; // Unused
(void)deterministic; // Unused
// @@protoc_insertion_point(serialize_to_array_start:google.protobuf.compiler.CodeGeneratorResponse)
// optional string error = 1;
if (has_error()) {
@ -2127,8 +2127,8 @@ void CodeGeneratorResponse::InternalSwap(CodeGeneratorResponse* other) {
}
::google::protobuf::Metadata CodeGeneratorResponse::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
return file_level_metadata[3];
protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::protobuf_AssignDescriptorsOnce();
return protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::file_level_metadata[3];
}
#if PROTOBUF_INLINE_NOT_IN_HEADERS

130
src/google/protobuf/compiler/plugin.pb.h
View File

@ -8,17 +8,18 @@
#include <google/protobuf/stubs/common.h>
#if GOOGLE_PROTOBUF_VERSION < 3001000
#if GOOGLE_PROTOBUF_VERSION < 3002000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3001000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#if 3002000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
@ -127,9 +128,16 @@ namespace google {
namespace protobuf {
namespace compiler {
namespace protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto {
// Internal implementation detail -- do not call these.
void LIBPROTOC_EXPORT protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
void LIBPROTOC_EXPORT protobuf_InitDefaults_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
struct LIBPROTOC_EXPORT TableStruct {
static const ::google::protobuf::uint32 offsets[];
static void InitDefaultsImpl();
static void Shutdown();
};
void LIBPROTOC_EXPORT AddDescriptors();
void LIBPROTOC_EXPORT InitDefaults();
} // namespace protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto
// ===================================================================
@ -184,7 +192,8 @@ class LIBPROTOC_EXPORT Version : public ::google::protobuf::Message /* @@protoc_
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
const PROTOBUF_FINAL {
return InternalSerializeWithCachedSizesToArray(false, output);
return InternalSerializeWithCachedSizesToArray(
::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
}
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
@ -207,6 +216,21 @@ class LIBPROTOC_EXPORT Version : public ::google::protobuf::Message /* @@protoc_
// accessors -------------------------------------------------------
// optional string suffix = 4;
bool has_suffix() const;
void clear_suffix();
static const int kSuffixFieldNumber = 4;
const ::std::string& suffix() const;
void set_suffix(const ::std::string& value);
#if LANG_CXX11
void set_suffix(::std::string&& value);
#endif
void set_suffix(const char* value);
void set_suffix(const char* value, size_t size);
::std::string* mutable_suffix();
::std::string* release_suffix();
void set_allocated_suffix(::std::string* suffix);
// optional int32 major = 1;
bool has_major() const;
void clear_major();
@ -228,21 +252,6 @@ class LIBPROTOC_EXPORT Version : public ::google::protobuf::Message /* @@protoc_
::google::protobuf::int32 patch() const;
void set_patch(::google::protobuf::int32 value);
// optional string suffix = 4;
bool has_suffix() const;
void clear_suffix();
static const int kSuffixFieldNumber = 4;
const ::std::string& suffix() const;
void set_suffix(const ::std::string& value);
#if LANG_CXX11
void set_suffix(::std::string&& value);
#endif
void set_suffix(const char* value);
void set_suffix(const char* value, size_t size);
::std::string* mutable_suffix();
::std::string* release_suffix();
void set_allocated_suffix(::std::string* suffix);
// @@protoc_insertion_point(class_scope:google.protobuf.compiler.Version)
private:
void set_has_major();
@ -261,11 +270,7 @@ class LIBPROTOC_EXPORT Version : public ::google::protobuf::Message /* @@protoc_
::google::protobuf::int32 major_;
::google::protobuf::int32 minor_;
::google::protobuf::int32 patch_;
friend void LIBPROTOC_EXPORT protobuf_InitDefaults_google_2fprotobuf_2fcompiler_2fplugin_2eproto_impl();
friend void LIBPROTOC_EXPORT protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto_impl();
friend const ::google::protobuf::uint32* protobuf_Offsets_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
friend struct LIBPROTOC_EXPORT protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::TableStruct;
};
// -------------------------------------------------------------------
@ -320,7 +325,8 @@ class LIBPROTOC_EXPORT CodeGeneratorRequest : public ::google::protobuf::Message
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
const PROTOBUF_FINAL {
return InternalSerializeWithCachedSizesToArray(false, output);
return InternalSerializeWithCachedSizesToArray(
::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
}
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
@ -359,6 +365,18 @@ class LIBPROTOC_EXPORT CodeGeneratorRequest : public ::google::protobuf::Message
const ::google::protobuf::RepeatedPtrField< ::std::string>& file_to_generate() const;
::google::protobuf::RepeatedPtrField< ::std::string>* mutable_file_to_generate();
// repeated .google.protobuf.FileDescriptorProto proto_file = 15;
int proto_file_size() const;
void clear_proto_file();
static const int kProtoFileFieldNumber = 15;
const ::google::protobuf::FileDescriptorProto& proto_file(int index) const;
::google::protobuf::FileDescriptorProto* mutable_proto_file(int index);
::google::protobuf::FileDescriptorProto* add_proto_file();
::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >*
mutable_proto_file();
const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >&
proto_file() const;
// optional string parameter = 2;
bool has_parameter() const;
void clear_parameter();
@ -374,18 +392,6 @@ class LIBPROTOC_EXPORT CodeGeneratorRequest : public ::google::protobuf::Message
::std::string* release_parameter();
void set_allocated_parameter(::std::string* parameter);
// repeated .google.protobuf.FileDescriptorProto proto_file = 15;
int proto_file_size() const;
void clear_proto_file();
static const int kProtoFileFieldNumber = 15;
const ::google::protobuf::FileDescriptorProto& proto_file(int index) const;
::google::protobuf::FileDescriptorProto* mutable_proto_file(int index);
::google::protobuf::FileDescriptorProto* add_proto_file();
::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >*
mutable_proto_file();
const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >&
proto_file() const;
// optional .google.protobuf.compiler.Version compiler_version = 3;
bool has_compiler_version() const;
void clear_compiler_version();
@ -409,11 +415,7 @@ class LIBPROTOC_EXPORT CodeGeneratorRequest : public ::google::protobuf::Message
::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto > proto_file_;
::google::protobuf::internal::ArenaStringPtr parameter_;
::google::protobuf::compiler::Version* compiler_version_;
friend void LIBPROTOC_EXPORT protobuf_InitDefaults_google_2fprotobuf_2fcompiler_2fplugin_2eproto_impl();
friend void LIBPROTOC_EXPORT protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto_impl();
friend const ::google::protobuf::uint32* protobuf_Offsets_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
friend struct LIBPROTOC_EXPORT protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::TableStruct;
};
// -------------------------------------------------------------------
@ -468,7 +470,8 @@ class LIBPROTOC_EXPORT CodeGeneratorResponse_File : public ::google::protobuf::M
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
const PROTOBUF_FINAL {
return InternalSerializeWithCachedSizesToArray(false, output);
return InternalSerializeWithCachedSizesToArray(
::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
}
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
@ -551,11 +554,7 @@ class LIBPROTOC_EXPORT CodeGeneratorResponse_File : public ::google::protobuf::M
::google::protobuf::internal::ArenaStringPtr name_;
::google::protobuf::internal::ArenaStringPtr insertion_point_;
::google::protobuf::internal::ArenaStringPtr content_;
friend void LIBPROTOC_EXPORT protobuf_InitDefaults_google_2fprotobuf_2fcompiler_2fplugin_2eproto_impl();
friend void LIBPROTOC_EXPORT protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto_impl();
friend const ::google::protobuf::uint32* protobuf_Offsets_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
friend struct LIBPROTOC_EXPORT protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::TableStruct;
};
// -------------------------------------------------------------------
@ -610,7 +609,8 @@ class LIBPROTOC_EXPORT CodeGeneratorResponse : public ::google::protobuf::Messag
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
const PROTOBUF_FINAL {
return InternalSerializeWithCachedSizesToArray(false, output);
return InternalSerializeWithCachedSizesToArray(
::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
}
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
@ -635,6 +635,18 @@ class LIBPROTOC_EXPORT CodeGeneratorResponse : public ::google::protobuf::Messag
// accessors -------------------------------------------------------
// repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
int file_size() const;
void clear_file();
static const int kFileFieldNumber = 15;
const ::google::protobuf::compiler::CodeGeneratorResponse_File& file(int index) const;
::google::protobuf::compiler::CodeGeneratorResponse_File* mutable_file(int index);
::google::protobuf::compiler::CodeGeneratorResponse_File* add_file();
::google::protobuf::RepeatedPtrField< ::google::protobuf::compiler::CodeGeneratorResponse_File >*
mutable_file();
const ::google::protobuf::RepeatedPtrField< ::google::protobuf::compiler::CodeGeneratorResponse_File >&
file() const;
// optional string error = 1;
bool has_error() const;
void clear_error();
@ -650,18 +662,6 @@ class LIBPROTOC_EXPORT CodeGeneratorResponse : public ::google::protobuf::Messag
::std::string* release_error();
void set_allocated_error(::std::string* error);
// repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
int file_size() const;
void clear_file();
static const int kFileFieldNumber = 15;
const ::google::protobuf::compiler::CodeGeneratorResponse_File& file(int index) const;
::google::protobuf::compiler::CodeGeneratorResponse_File* mutable_file(int index);
::google::protobuf::compiler::CodeGeneratorResponse_File* add_file();
::google::protobuf::RepeatedPtrField< ::google::protobuf::compiler::CodeGeneratorResponse_File >*
mutable_file();
const ::google::protobuf::RepeatedPtrField< ::google::protobuf::compiler::CodeGeneratorResponse_File >&
file() const;
// @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorResponse)
private:
void set_has_error();
@ -672,11 +672,7 @@ class LIBPROTOC_EXPORT CodeGeneratorResponse : public ::google::protobuf::Messag
mutable int _cached_size_;
::google::protobuf::RepeatedPtrField< ::google::protobuf::compiler::CodeGeneratorResponse_File > file_;
::google::protobuf::internal::ArenaStringPtr error_;
friend void LIBPROTOC_EXPORT protobuf_InitDefaults_google_2fprotobuf_2fcompiler_2fplugin_2eproto_impl();
friend void LIBPROTOC_EXPORT protobuf_AddDesc_google_2fprotobuf_2fcompiler_2fplugin_2eproto_impl();
friend const ::google::protobuf::uint32* protobuf_Offsets_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
friend void protobuf_ShutdownFile_google_2fprotobuf_2fcompiler_2fplugin_2eproto();
friend struct LIBPROTOC_EXPORT protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::TableStruct;
};
// ===================================================================

8
src/google/protobuf/descriptor.cc
View File

@ -4114,6 +4114,14 @@ const FileDescriptor* DescriptorBuilder::BuildFileImpl(
dependency = pool_->underlay_->FindFileByName(proto.dependency(i));
}
if (dependency == result) {
// Recursive import. dependency/result is not fully initialized, and it's
// dangerous to try to do anything with it. The recursive import error
// will be detected and reported in DescriptorBuilder::BuildFile().
tables_->RollbackToLastCheckpoint();
return NULL;
}
if (dependency == NULL) {
if (pool_->allow_unknown_ ||
(!pool_->enforce_weak_ && weak_deps.find(i) != weak_deps.end())) {

1282
src/google/protobuf/descriptor.pb.cc
View File

File diff suppressed because it is too large Load Diff

857
src/google/protobuf/descriptor.pb.h
View File

File diff suppressed because it is too large Load Diff

6
src/google/protobuf/descriptor.proto
View File

@ -139,7 +139,11 @@ message FieldDescriptorProto {
TYPE_FIXED32 = 7;
TYPE_BOOL = 8;
TYPE_STRING = 9;
TYPE_GROUP = 10; // Tag-delimited aggregate.
// Tag-delimited aggregate.
// Group type is deprecated and not supported in proto3. However, Proto3
// implementations should still be able to parse the group wire format and
// treat group fields as unknown fields.
TYPE_GROUP = 10;
TYPE_MESSAGE = 11; // Length-delimited aggregate.
// New in version 2.

84
src/google/protobuf/duration.pb.cc
View File

@ -19,8 +19,11 @@
namespace google {
namespace protobuf {
class DurationDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Duration> {};
DurationDefaultTypeInternal _Duration_default_instance_;
class DurationDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Duration> {
} _Duration_default_instance_;
namespace protobuf_google_2fprotobuf_2fduration_2eproto {
namespace {
@ -28,35 +31,30 @@ namespace {
} // namespace
const ::google::protobuf::uint32* protobuf_Offsets_google_2fprotobuf_2fduration_2eproto() GOOGLE_ATTRIBUTE_COLD;
const ::google::protobuf::uint32* protobuf_Offsets_google_2fprotobuf_2fduration_2eproto() {
static const ::google::protobuf::uint32 offsets[] = {
~0u, // no _has_bits_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Duration, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Duration, seconds_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Duration, nanos_),
};
return offsets;
}
const ::google::protobuf::uint32 TableStruct::offsets[] = {
~0u, // no _has_bits_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Duration, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Duration, seconds_),
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Duration, nanos_),
};
static const ::google::protobuf::internal::MigrationSchema schemas[] = {
{ 0, -1, sizeof(Duration)},
};
static const ::google::protobuf::internal::DefaultInstanceData file_default_instances[] = {
{reinterpret_cast<const ::google::protobuf::Message*>(&_Duration_default_instance_), NULL},
static ::google::protobuf::Message const * const file_default_instances[] = {
reinterpret_cast<const ::google::protobuf::Message*>(&_Duration_default_instance_),
};
namespace {
void protobuf_AssignDescriptors() {
protobuf_AddDesc_google_2fprotobuf_2fduration_2eproto();
AddDescriptors();
::google::protobuf::MessageFactory* factory = NULL;
AssignDescriptors(
"google/protobuf/duration.proto", schemas, file_default_instances, protobuf_Offsets_google_2fprotobuf_2fduration_2eproto(), factory,
"google/protobuf/duration.proto", schemas, file_default_instances, TableStruct::offsets, factory,
file_level_metadata, NULL, NULL);
}
@ -73,24 +71,24 @@ void protobuf_RegisterTypes(const ::std::string&) {
} // namespace
void protobuf_ShutdownFile_google_2fprotobuf_2fduration_2eproto() {
void TableStruct::Shutdown() {
_Duration_default_instance_.Shutdown();
delete file_level_metadata[0].reflection;
}
void protobuf_InitDefaults_google_2fprotobuf_2fduration_2eproto_impl() {
void TableStruct::InitDefaultsImpl() {
GOOGLE_PROTOBUF_VERIFY_VERSION;
::google::protobuf::internal::InitProtobufDefaults();
_Duration_default_instance_.DefaultConstruct();
}
void protobuf_InitDefaults_google_2fprotobuf_2fduration_2eproto() {
void InitDefaults() {
static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
::google::protobuf::GoogleOnceInit(&once, &protobuf_InitDefaults_google_2fprotobuf_2fduration_2eproto_impl);
::google::protobuf::GoogleOnceInit(&once, &TableStruct::InitDefaultsImpl);
}
void protobuf_AddDesc_google_2fprotobuf_2fduration_2eproto_impl() {
protobuf_InitDefaults_google_2fprotobuf_2fduration_2eproto();
void AddDescriptorsImpl() {
InitDefaults();
static const char descriptor[] = {
"\n\036google/protobuf/duration.proto\022\017google"
".protobuf\"*\n\010Duration\022\017\n\007seconds\030\001 \001(\003\022\r"
@ -103,20 +101,22 @@ void protobuf_AddDesc_google_2fprotobuf_2fduration_2eproto_impl() {
descriptor, 227);
::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
"google/protobuf/duration.proto", &protobuf_RegisterTypes);
::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_google_2fprotobuf_2fduration_2eproto);
::google::protobuf::internal::OnShutdown(&TableStruct::Shutdown);
}
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_google_2fprotobuf_2fduration_2eproto_once_);
void protobuf_AddDesc_google_2fprotobuf_2fduration_2eproto() {
::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_google_2fprotobuf_2fduration_2eproto_once_,
&protobuf_AddDesc_google_2fprotobuf_2fduration_2eproto_impl);
void AddDescriptors() {
static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl);
}
// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_google_2fprotobuf_2fduration_2eproto {
StaticDescriptorInitializer_google_2fprotobuf_2fduration_2eproto() {
protobuf_AddDesc_google_2fprotobuf_2fduration_2eproto();
struct StaticDescriptorInitializer {
StaticDescriptorInitializer() {
AddDescriptors();
}
} static_descriptor_initializer_google_2fprotobuf_2fduration_2eproto_;
} static_descriptor_initializer;
} // namespace protobuf_google_2fprotobuf_2fduration_2eproto
// ===================================================================
@ -128,7 +128,7 @@ const int Duration::kNanosFieldNumber;
Duration::Duration()
: ::google::protobuf::Message(), _internal_metadata_(NULL) {
if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
protobuf_InitDefaults_google_2fprotobuf_2fduration_2eproto();
protobuf_google_2fprotobuf_2fduration_2eproto::InitDefaults();
}
SharedCtor();
// @@protoc_insertion_point(constructor:google.protobuf.Duration)
@ -137,7 +137,7 @@ Duration::Duration(::google::protobuf::Arena* arena)
: ::google::protobuf::Message(),
_internal_metadata_(arena) {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
protobuf_InitDefaults_google_2fprotobuf_2fduration_2eproto();
protobuf_google_2fprotobuf_2fduration_2eproto::InitDefaults();
#endif // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
SharedCtor();
RegisterArenaDtor(arena);
@ -185,12 +185,12 @@ void Duration::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Duration::descriptor() {
protobuf_AssignDescriptorsOnce();
return file_level_metadata[0].descriptor;
protobuf_google_2fprotobuf_2fduration_2eproto::protobuf_AssignDescriptorsOnce();
return protobuf_google_2fprotobuf_2fduration_2eproto::file_level_metadata[0].descriptor;
}
const Duration& Duration::default_instance() {
protobuf_InitDefaults_google_2fprotobuf_2fduration_2eproto();
protobuf_google_2fprotobuf_2fduration_2eproto::InitDefaults();
return *internal_default_instance();
}
@ -279,7 +279,7 @@ void Duration::SerializeWithCachedSizes(
::google::protobuf::uint8* Duration::InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const {
(void)deterministic; // Unused
(void)deterministic; // Unused
// @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Duration)
// int64 seconds = 1;
if (this->seconds() != 0) {
@ -391,8 +391,8 @@ void Duration::InternalSwap(Duration* other) {
}
::google::protobuf::Metadata Duration::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
return file_level_metadata[0];
protobuf_google_2fprotobuf_2fduration_2eproto::protobuf_AssignDescriptorsOnce();
return protobuf_google_2fprotobuf_2fduration_2eproto::file_level_metadata[0];
}
#if PROTOBUF_INLINE_NOT_IN_HEADERS

25
src/google/protobuf/duration.pb.h
View File

@ -8,17 +8,18 @@
#include <google/protobuf/stubs/common.h>
#if GOOGLE_PROTOBUF_VERSION < 3001000
#if GOOGLE_PROTOBUF_VERSION < 3002000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3001000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#if 3002000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
@ -39,9 +40,16 @@ LIBPROTOBUF_EXPORT extern DurationDefaultTypeInternal _Duration_default_instance
namespace google {
namespace protobuf {
namespace protobuf_google_2fprotobuf_2fduration_2eproto {
// Internal implementation detail -- do not call these.
void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fduration_2eproto();
void LIBPROTOBUF_EXPORT protobuf_InitDefaults_google_2fprotobuf_2fduration_2eproto();
struct LIBPROTOBUF_EXPORT TableStruct {
static const ::google::protobuf::uint32 offsets[];
static void InitDefaultsImpl();
static void Shutdown();
};
void LIBPROTOBUF_EXPORT AddDescriptors();
void LIBPROTOBUF_EXPORT InitDefaults();
} // namespace protobuf_google_2fprotobuf_2fduration_2eproto
// ===================================================================
@ -95,7 +103,8 @@ class LIBPROTOBUF_EXPORT Duration : public ::google::protobuf::Message /* @@prot
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
const PROTOBUF_FINAL {
return InternalSerializeWithCachedSizesToArray(false, output);
return InternalSerializeWithCachedSizesToArray(
::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
}
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
@ -145,11 +154,7 @@ class LIBPROTOBUF_EXPORT Duration : public ::google::protobuf::Message /* @@prot
::google::protobuf::int64 seconds_;
::google::protobuf::int32 nanos_;
mutable int _cached_size_;
friend void LIBPROTOBUF_EXPORT protobuf_InitDefaults_google_2fprotobuf_2fduration_2eproto_impl();
friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fduration_2eproto_impl();
friend const ::google::protobuf::uint32* protobuf_Offsets_google_2fprotobuf_2fduration_2eproto();
friend void protobuf_ShutdownFile_google_2fprotobuf_2fduration_2eproto();
friend struct LIBPROTOBUF_EXPORT protobuf_google_2fprotobuf_2fduration_2eproto::TableStruct;
};
// ===================================================================

63
src/google/protobuf/dynamic_message.cc
View File

@ -239,13 +239,11 @@ class DynamicMessage : public Message {
// looking back at this field. This would assume details about the
// implementation of scoped_ptr.
const DynamicMessage* prototype;
void* default_oneof_instance;
TypeInfo() : prototype(NULL), default_oneof_instance(NULL) {}
TypeInfo() : prototype(NULL) {}
~TypeInfo() {
delete prototype;
operator delete(default_oneof_instance);
}
};
@ -448,8 +446,8 @@ DynamicMessage::~DynamicMessage() {
case FieldOptions::STRING: {
const ::std::string* default_value =
&(reinterpret_cast<const ArenaStringPtr*>(
reinterpret_cast<uint8*>(
type_info_->default_oneof_instance) +
reinterpret_cast<const uint8*>(
type_info_->prototype) +
type_info_->offsets[i])
->Get());
reinterpret_cast<ArenaStringPtr*>(field_ptr)->Destroy(
@ -539,10 +537,6 @@ void DynamicMessage::CrossLinkPrototypes() {
for (int i = 0; i < descriptor->field_count(); i++) {
const FieldDescriptor* field = descriptor->field(i);
void* field_ptr = OffsetToPointer(type_info_->offsets[i]);
if (field->containing_oneof()) {
field_ptr = reinterpret_cast<uint8*>(
type_info_->default_oneof_instance) + type_info_->offsets[i];
}
if (field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE &&
!field->is_repeated()) {
@ -614,7 +608,7 @@ DynamicMessageFactory::~DynamicMessageFactory() {
iter != prototypes_->map_.end(); ++iter) {
DeleteDefaultOneofInstance(iter->second->type,
iter->second->offsets.get(),
iter->second->default_oneof_instance);
iter->second->prototype);
delete iter->second;
}
}
@ -725,12 +719,30 @@ const Message* DynamicMessageFactory::GetPrototypeNoLock(
// Align the final size to make sure no clever allocators think that
// alignment is not necessary.
size = AlignOffset(size);
type_info->size = size;
// Allocate the prototype.
// Construct the reflection object.
if (type->oneof_decl_count() > 0) {
// Compute the size of default oneof instance and offsets of default
// oneof fields.
for (int i = 0; i < type->oneof_decl_count(); i++) {
for (int j = 0; j < type->oneof_decl(i)->field_count(); j++) {
const FieldDescriptor* field = type->oneof_decl(i)->field(j);
int field_size = OneofFieldSpaceUsed(field);
size = AlignTo(size, std::min(kSafeAlignment, field_size));
offsets[field->index()] = size;
size += field_size;
}
}
}
size = AlignOffset(size);
// Allocate the prototype + oneof fields.
void* base = operator new(size);
memset(base, 0, size);
// The prototype in type_info has to be set before creating the prototype
// instance on memory. e.g., message Foo { map<int32, Foo> a = 1; }. When
// creating prototype for Foo, prototype of the map entry will also be
@ -740,31 +752,11 @@ const Message* DynamicMessageFactory::GetPrototypeNoLock(
type_info->prototype = static_cast<DynamicMessage*>(base);
DynamicMessage* prototype = new(base) DynamicMessage(type_info);
// Construct the reflection object.
void* default_oneof_instance = NULL;
int oneof_case_offset = -1;
if (type->oneof_decl_count() > 0) {
// Compute the size of default oneof instance and offsets of default
// oneof fields.
int oneof_size = 0;
for (int i = 0; i < type->oneof_decl_count(); i++) {
for (int j = 0; j < type->oneof_decl(i)->field_count(); j++) {
const FieldDescriptor* field = type->oneof_decl(i)->field(j);
int field_size = OneofFieldSpaceUsed(field);
oneof_size = AlignTo(oneof_size, std::min(kSafeAlignment, field_size));
offsets[field->index()] = oneof_size;
oneof_size += field_size;
}
}
// Construct default oneof instance.
type_info->default_oneof_instance = ::operator new(oneof_size);
ConstructDefaultOneofInstance(type_info->type,
type_info->offsets.get(),
type_info->default_oneof_instance);
default_oneof_instance = type_info->default_oneof_instance;
oneof_case_offset = type_info->oneof_case_offset;
prototype);
}
internal::ReflectionSchema schema = {
@ -774,8 +766,7 @@ const Message* DynamicMessageFactory::GetPrototypeNoLock(
type_info->has_bits_offset,
type_info->internal_metadata_offset,
type_info->extensions_offset,
default_oneof_instance,
oneof_case_offset,
type_info->oneof_case_offset,
type_info->size};
type_info->reflection.reset(new GeneratedMessageReflection(
@ -836,7 +827,7 @@ void DynamicMessageFactory::ConstructDefaultOneofInstance(
void DynamicMessageFactory::DeleteDefaultOneofInstance(
const Descriptor* type,
const uint32 offsets[],
void* default_oneof_instance) {
const void* default_oneof_instance) {
for (int i = 0; i < type->oneof_decl_count(); i++) {
for (int j = 0; j < type->oneof_decl(i)->field_count(); j++) {
const FieldDescriptor* field = type->oneof_decl(i)->field(j);

86
src/google/protobuf/dynamic_message.h
View File

@ -38,12 +38,15 @@
#ifndef GOOGLE_PROTOBUF_DYNAMIC_MESSAGE_H__
#define GOOGLE_PROTOBUF_DYNAMIC_MESSAGE_H__
#include <algorithm>
#include <memory>
#ifndef _SHARED_PTR_H
#include <google/protobuf/stubs/shared_ptr.h>
#endif
#include <vector>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/mutex.h>
@ -141,11 +144,92 @@ class LIBPROTOBUF_EXPORT DynamicMessageFactory : public MessageFactory {
// Delete default oneof instance. Called by ~DynamicMessageFactory.
static void DeleteDefaultOneofInstance(const Descriptor* type,
const uint32 offsets[],
void* default_oneof_instance);
const void* default_oneof_instance);
GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DynamicMessageFactory);
};
// Helper for computing a sorted list of map entries via reflection.
class LIBPROTOBUF_EXPORT DynamicMapSorter {
public:
static std::vector<const Message*> Sort(const Message& message,
int map_size,
const Reflection* reflection,
const FieldDescriptor* field) {
std::vector<const Message*> result(map_size);
const RepeatedPtrField<Message>& map_field =
reflection->GetRepeatedPtrField<Message>(message, field);
int i = 0;
for (RepeatedPtrField<Message>::const_pointer_iterator it =
map_field.pointer_begin(); it != map_field.pointer_end(); ) {
result[i++] = *it++;
}
GOOGLE_DCHECK_EQ(result.size(), static_cast<size_t>(i));
MapEntryMessageComparator comparator(field->message_type());
std::sort(result.begin(), result.end(), comparator);
// Complain if the keys aren't in ascending order.
#ifndef NDEBUG
for (int j = 1; j < map_size; j++) {
if (!comparator(result[j - 1], result[j])) {
GOOGLE_LOG(ERROR) << (comparator(result[j], result[j - 1]) ?
"internal error in map key sorting" :
"map keys are not unique");
}
}
#endif
return result;
}
private:
class LIBPROTOBUF_EXPORT MapEntryMessageComparator {
public:
explicit MapEntryMessageComparator(const Descriptor* descriptor)
: field_(descriptor->field(0)) {}
bool operator()(const Message* a, const Message* b) {
const Reflection* reflection = a->GetReflection();
switch (field_->cpp_type()) {
case FieldDescriptor::CPPTYPE_BOOL: {
bool first = reflection->GetBool(*a, field_);
bool second = reflection->GetBool(*b, field_);
return first < second;
}
case FieldDescriptor::CPPTYPE_INT32: {
int32 first = reflection->GetInt32(*a, field_);
int32 second = reflection->GetInt32(*b, field_);
return first < second;
}
case FieldDescriptor::CPPTYPE_INT64: {
int64 first = reflection->GetInt64(*a, field_);
int64 second = reflection->GetInt64(*b, field_);
return first < second;
}
case FieldDescriptor::CPPTYPE_UINT32: {
uint32 first = reflection->GetUInt32(*a, field_);
uint32 second = reflection->GetUInt32(*b, field_);
return first < second;
}
case FieldDescriptor::CPPTYPE_UINT64: {
uint64 first = reflection->GetUInt64(*a, field_);
uint64 second = reflection->GetUInt64(*b, field_);
return first < second;
}
case FieldDescriptor::CPPTYPE_STRING: {
string first = reflection->GetString(*a, field_);
string second = reflection->GetString(*b, field_);
return first < second;
}
default:
GOOGLE_LOG(DFATAL) << "Invalid key for map field.";
return true;
}
}
private:
const FieldDescriptor* field_;
};
};
} // namespace protobuf
} // namespace google

80
src/google/protobuf/empty.pb.cc
View File

@ -19,8 +19,11 @@
namespace google {
namespace protobuf {
class EmptyDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Empty> {};
EmptyDefaultTypeInternal _Empty_default_instance_;
class EmptyDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<Empty> {
} _Empty_default_instance_;
namespace protobuf_google_2fprotobuf_2fempty_2eproto {
namespace {
@ -28,33 +31,28 @@ namespace {
} // namespace
const ::google::protobuf::uint32* protobuf_Offsets_google_2fprotobuf_2fempty_2eproto() GOOGLE_ATTRIBUTE_COLD;
const ::google::protobuf::uint32* protobuf_Offsets_google_2fprotobuf_2fempty_2eproto() {
static const ::google::protobuf::uint32 offsets[] = {
~0u, // no _has_bits_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Empty, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
};
return offsets;
}
const ::google::protobuf::uint32 TableStruct::offsets[] = {
~0u, // no _has_bits_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Empty, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
};
static const ::google::protobuf::internal::MigrationSchema schemas[] = {
{ 0, -1, sizeof(Empty)},
};
static const ::google::protobuf::internal::DefaultInstanceData file_default_instances[] = {
{reinterpret_cast<const ::google::protobuf::Message*>(&_Empty_default_instance_), NULL},
static ::google::protobuf::Message const * const file_default_instances[] = {
reinterpret_cast<const ::google::protobuf::Message*>(&_Empty_default_instance_),
};
namespace {
void protobuf_AssignDescriptors() {
protobuf_AddDesc_google_2fprotobuf_2fempty_2eproto();
AddDescriptors();
::google::protobuf::MessageFactory* factory = NULL;
AssignDescriptors(
"google/protobuf/empty.proto", schemas, file_default_instances, protobuf_Offsets_google_2fprotobuf_2fempty_2eproto(), factory,
"google/protobuf/empty.proto", schemas, file_default_instances, TableStruct::offsets, factory,
file_level_metadata, NULL, NULL);
}
@ -71,24 +69,24 @@ void protobuf_RegisterTypes(const ::std::string&) {
} // namespace
void protobuf_ShutdownFile_google_2fprotobuf_2fempty_2eproto() {
void TableStruct::Shutdown() {
_Empty_default_instance_.Shutdown();
delete file_level_metadata[0].reflection;
}
void protobuf_InitDefaults_google_2fprotobuf_2fempty_2eproto_impl() {
void TableStruct::InitDefaultsImpl() {
GOOGLE_PROTOBUF_VERIFY_VERSION;
::google::protobuf::internal::InitProtobufDefaults();
_Empty_default_instance_.DefaultConstruct();
}
void protobuf_InitDefaults_google_2fprotobuf_2fempty_2eproto() {
void InitDefaults() {
static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
::google::protobuf::GoogleOnceInit(&once, &protobuf_InitDefaults_google_2fprotobuf_2fempty_2eproto_impl);
::google::protobuf::GoogleOnceInit(&once, &TableStruct::InitDefaultsImpl);
}
void protobuf_AddDesc_google_2fprotobuf_2fempty_2eproto_impl() {
protobuf_InitDefaults_google_2fprotobuf_2fempty_2eproto();
void AddDescriptorsImpl() {
InitDefaults();
static const char descriptor[] = {
"\n\033google/protobuf/empty.proto\022\017google.pr"
"otobuf\"\007\n\005EmptyBv\n\023com.google.protobufB\n"
@ -100,20 +98,22 @@ void protobuf_AddDesc_google_2fprotobuf_2fempty_2eproto_impl() {
descriptor, 183);
::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
"google/protobuf/empty.proto", &protobuf_RegisterTypes);
::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_google_2fprotobuf_2fempty_2eproto);
::google::protobuf::internal::OnShutdown(&TableStruct::Shutdown);
}
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_google_2fprotobuf_2fempty_2eproto_once_);
void protobuf_AddDesc_google_2fprotobuf_2fempty_2eproto() {
::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_google_2fprotobuf_2fempty_2eproto_once_,
&protobuf_AddDesc_google_2fprotobuf_2fempty_2eproto_impl);
void AddDescriptors() {
static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl);
}
// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_google_2fprotobuf_2fempty_2eproto {
StaticDescriptorInitializer_google_2fprotobuf_2fempty_2eproto() {
protobuf_AddDesc_google_2fprotobuf_2fempty_2eproto();
struct StaticDescriptorInitializer {
StaticDescriptorInitializer() {
AddDescriptors();
}
} static_descriptor_initializer_google_2fprotobuf_2fempty_2eproto_;
} static_descriptor_initializer;
} // namespace protobuf_google_2fprotobuf_2fempty_2eproto
// ===================================================================
@ -123,7 +123,7 @@ struct StaticDescriptorInitializer_google_2fprotobuf_2fempty_2eproto {
Empty::Empty()
: ::google::protobuf::Message(), _internal_metadata_(NULL) {
if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
protobuf_InitDefaults_google_2fprotobuf_2fempty_2eproto();
protobuf_google_2fprotobuf_2fempty_2eproto::InitDefaults();
}
SharedCtor();
// @@protoc_insertion_point(constructor:google.protobuf.Empty)
@ -132,7 +132,7 @@ Empty::Empty(::google::protobuf::Arena* arena)
: ::google::protobuf::Message(),
_internal_metadata_(arena) {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
protobuf_InitDefaults_google_2fprotobuf_2fempty_2eproto();
protobuf_google_2fprotobuf_2fempty_2eproto::InitDefaults();
#endif // GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
SharedCtor();
RegisterArenaDtor(arena);
@ -175,12 +175,12 @@ void Empty::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* Empty::descriptor() {
protobuf_AssignDescriptorsOnce();
return file_level_metadata[0].descriptor;
protobuf_google_2fprotobuf_2fempty_2eproto::protobuf_AssignDescriptorsOnce();
return protobuf_google_2fprotobuf_2fempty_2eproto::file_level_metadata[0].descriptor;
}
const Empty& Empty::default_instance() {
protobuf_InitDefaults_google_2fprotobuf_2fempty_2eproto();
protobuf_google_2fprotobuf_2fempty_2eproto::InitDefaults();
return *internal_default_instance();
}
@ -226,7 +226,7 @@ void Empty::SerializeWithCachedSizes(
::google::protobuf::uint8* Empty::InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const {
(void)deterministic; // Unused
(void)deterministic; // Unused
// @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Empty)
// @@protoc_insertion_point(serialize_to_array_end:google.protobuf.Empty)
return target;
@ -306,8 +306,8 @@ void Empty::InternalSwap(Empty* other) {
}
::google::protobuf::Metadata Empty::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
return file_level_metadata[0];
protobuf_google_2fprotobuf_2fempty_2eproto::protobuf_AssignDescriptorsOnce();
return protobuf_google_2fprotobuf_2fempty_2eproto::file_level_metadata[0];
}
#if PROTOBUF_INLINE_NOT_IN_HEADERS

25
src/google/protobuf/empty.pb.h
View File

@ -8,17 +8,18 @@
#include <google/protobuf/stubs/common.h>
#if GOOGLE_PROTOBUF_VERSION < 3001000
#if GOOGLE_PROTOBUF_VERSION < 3002000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3001000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#if 3002000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
@ -39,9 +40,16 @@ LIBPROTOBUF_EXPORT extern EmptyDefaultTypeInternal _Empty_default_instance_;
namespace google {
namespace protobuf {
namespace protobuf_google_2fprotobuf_2fempty_2eproto {
// Internal implementation detail -- do not call these.
void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fempty_2eproto();
void LIBPROTOBUF_EXPORT protobuf_InitDefaults_google_2fprotobuf_2fempty_2eproto();
struct LIBPROTOBUF_EXPORT TableStruct {
static const ::google::protobuf::uint32 offsets[];
static void InitDefaultsImpl();
static void Shutdown();
};
void LIBPROTOBUF_EXPORT AddDescriptors();
void LIBPROTOBUF_EXPORT InitDefaults();
} // namespace protobuf_google_2fprotobuf_2fempty_2eproto
// ===================================================================
@ -95,7 +103,8 @@ class LIBPROTOBUF_EXPORT Empty : public ::google::protobuf::Message /* @@protoc_
bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output)
const PROTOBUF_FINAL {
return InternalSerializeWithCachedSizesToArray(false, output);
return InternalSerializeWithCachedSizesToArray(
::google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(), output);
}
int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
private:
@ -131,11 +140,7 @@ class LIBPROTOBUF_EXPORT Empty : public ::google::protobuf::Message /* @@protoc_
typedef void InternalArenaConstructable_;
typedef void DestructorSkippable_;
mutable int _cached_size_;
friend void LIBPROTOBUF_EXPORT protobuf_InitDefaults_google_2fprotobuf_2fempty_2eproto_impl();
friend void LIBPROTOBUF_EXPORT protobuf_AddDesc_google_2fprotobuf_2fempty_2eproto_impl();
friend const ::google::protobuf::uint32* protobuf_Offsets_google_2fprotobuf_2fempty_2eproto();
friend void protobuf_ShutdownFile_google_2fprotobuf_2fempty_2eproto();
friend struct LIBPROTOBUF_EXPORT protobuf_google_2fprotobuf_2fempty_2eproto::TableStruct;
};
// ===================================================================

18
src/google/protobuf/extension_set_heavy.cc
View File

@ -35,6 +35,7 @@
// Contains methods defined in extension_set.h which cannot be part of the
// lite library because they use descriptors or reflection.
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/extension_set.h>
@ -413,12 +414,16 @@ uint8* ExtensionSet::SerializeWithCachedSizesToArray(int start_field_number,
int end_field_number,
uint8* target) const {
return InternalSerializeWithCachedSizesToArray(
start_field_number, end_field_number, false, target);
start_field_number, end_field_number,
google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(),
target);
}
uint8* ExtensionSet::SerializeMessageSetWithCachedSizesToArray(
uint8* target) const {
return InternalSerializeMessageSetWithCachedSizesToArray(false, target);
return InternalSerializeMessageSetWithCachedSizesToArray(
google::protobuf::io::CodedOutputStream::IsDefaultSerializationDeterministic(),
target);
}
uint8* ExtensionSet::InternalSerializeWithCachedSizesToArray(
@ -587,11 +592,12 @@ ExtensionSet::Extension::InternalSerializeMessageSetItemWithCachedSizesToArray(
WireFormatLite::kMessageSetTypeIdNumber, number, target);
// Write message.
if (is_lazy) {
target = lazymessage_value->WriteMessageToArray(
WireFormatLite::kMessageSetMessageNumber, target);
target = lazymessage_value->InternalWriteMessageToArray(
WireFormatLite::kMessageSetMessageNumber, deterministic, target);
} else {
target = WireFormatLite::WriteMessageToArray(
WireFormatLite::kMessageSetMessageNumber, *message_value, target);
target = WireFormatLite::InternalWriteMessageToArray(
WireFormatLite::kMessageSetMessageNumber, *message_value, deterministic,
target);
}
// End group.
target = io::CodedOutputStream::WriteTagToArray(

80
src/google/protobuf/field_mask.pb.cc
View File

@ -19,8 +19,11 @@
namespace google {
namespace protobuf {
class FieldMaskDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<FieldMask> {};
FieldMaskDefaultTypeInternal _FieldMask_default_instance_;
class FieldMaskDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<FieldMask> {
} _FieldMask_default_instance_;
namespace protobuf_google_2fprotobuf_2ffield_5fmask_2eproto {
namespace {
@ -28,34 +31,29 @@ namespace {
} // namespace
const ::google::protobuf::uint32* protobuf_Offsets_google_2fprotobuf_2ffield_5fmask_2eproto() GOOGLE_ATTRIBUTE_COLD;
const ::google::protobuf::uint32* protobuf_Offsets_google_2fprotobuf_2ffield_5fmask_2eproto() {
static const ::google::protobuf::uint32 offsets[] = {
~0u, // no _has_bits_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldMask, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldMask, paths_),
};
return offsets;
}
const ::google::protobuf::uint32 TableStruct::offsets[] = {
~0u, // no _has_bits_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldMask, _internal_metadata_),
~0u, // no _extensions_
~0u, // no _oneof_case_
GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldMask, paths_),
};
static const ::google::protobuf::internal::MigrationSchema schemas[] = {
{ 0, -1, sizeof(FieldMask)},
};
static const ::google::protobuf::internal::DefaultInstanceData file_default_instances[] = {
{reinterpret_cast<const ::google::protobuf::Message*>(&_FieldMask_default_instance_), NULL},
static ::google::protobuf::Message const * const file_default_instances[] = {
reinterpret_cast<const ::google::protobuf::Message*>(&_FieldMask_default_instance_),
};
namespace {
void protobuf_AssignDescriptors() {
protobuf_AddDesc_google_2fprotobuf_2ffield_5fmask_2eproto();
AddDescriptors();
::google::protobuf::MessageFactory* factory = NULL;
AssignDescriptors(
"google/protobuf/field_mask.proto", schemas, file_default_instances, protobuf_Offsets_google_2fprotobuf_2ffield_5fmask_2eproto(), factory,
"google/protobuf/field_mask.proto", schemas, file_default_instances, TableStruct::offsets, factory,
file_level_metadata, NULL, NULL);
}
@ -72,24 +70,24 @@ void protobuf_RegisterTypes(const ::std::string&) {
} // namespace
void protobuf_ShutdownFile_google_2fprotobuf_2ffield_5fmask_2eproto() {
void TableStruct::Shutdown() {
_FieldMask_default_instance_.Shutdown();
delete file_level_metadata[0].reflection;
}
void protobuf_InitDefaults_google_2fprotobuf_2ffield_5fmask_2eproto_impl() {
void TableStruct::InitDefaultsImpl() {
GOOGLE_PROTOBUF_VERIFY_VERSION;
::google::protobuf::internal::InitProtobufDefaults();
_FieldMask_default_instance_.DefaultConstruct();
}
void protobuf_InitDefaults_google_2fprotobuf_2ffield_5fmask_2eproto() {
void InitDefaults() {
static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
::google::protobuf::GoogleOnceInit(&once, &protobuf_InitDefaults_google_2fprotobuf_2ffield_5fmask_2eproto_impl);
::google::protobuf::GoogleOnceInit(&once, &TableStruct::InitDefaultsImpl);
}
void protobuf_AddDesc_google_2fprotobuf_2ffield_5fmask_2eproto_impl() {
protobuf_InitDefaults_google_2fprotobuf_2ffield_5fmask_2eproto();
void AddDescriptorsImpl() {
InitDefaults();
static const char descriptor[] = {
"\n google/protobuf/field_mask.proto\022\017goog"
"le.protobuf\"\032\n\tFieldMask\022\r\n\005paths\030\001 \003(\tB"
@ -102,20 +100,22 @@ void protobuf_AddDesc_google_2fprotobuf_2ffield_5fmask_2eproto_impl() {
descriptor, 227);
::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
"google/protobuf/field_mask.proto", &protobuf_RegisterTypes);
::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_google_2fprotobuf_2ffield_5fmask_2eproto);
::google::protobuf::internal::OnShutdown(&TableStruct::Shutdown);
}
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_google_2fprotobuf_2ffield_5fmask_2eproto_once_);
void protobuf_AddDesc_google_2fprotobuf_2ffield_5fmask_2eproto() {
::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_google_2fprotobuf_2ffield_5fmask_2eproto_once_,
&protobuf_AddDesc_google_2fprotobuf_2ffield_5fmask_2eproto_impl);
void AddDescriptors() {
static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl);
}
// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_google_2fprotobuf_2ffield_5fmask_2eproto {
StaticDescriptorInitializer_google_2fprotobuf_2ffield_5fmask_2eproto() {
protobuf_AddDesc_google_2fprotobuf_2ffield_5fmask_2eproto();
struct StaticDescriptorInitializer {
StaticDescriptorInitializer() {
AddDescriptors();
}
} static_descriptor_initializer_google_2fprotobuf_2ffield_5fmask_2eproto_;
} static_descriptor_initializer;
} // namespace protobuf_google_2fprotobuf_2ffield_5fmask_2eproto
// ===================================================================
@ -126,7 +126,7 @@ const int FieldMask::kPathsFieldNumber;
FieldMask::FieldMask()
: ::google::protobuf::Message(), _internal_metadata_(NULL) {
if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
protobuf_InitDefaults_google_2fprotobuf_2ffield_5fmask_2eproto();
protobuf_google_2fprotobuf_2ffield_5fmask_2eproto::InitDefaults();
}
SharedCtor();
// @@protoc_insertion_point(constructor:google.protobuf.FieldMask)
@ -158,12 +158,12 @@ void FieldMask::SetCachedSize(int size) const {
GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* FieldMask::descriptor() {
protobuf_AssignDescriptorsOnce();
return file_level_metadata[0].descriptor;
protobuf_google_2fprotobuf_2ffield_5fmask_2eproto::protobuf_AssignDescriptorsOnce();
return protobuf_google_2fprotobuf_2ffield_5fmask_2eproto::file_level_metadata[0].descriptor;
}
const FieldMask& FieldMask::default_instance() {
protobuf_InitDefaults_google_2fprotobuf_2ffield_5fmask_2eproto();
protobuf_google_2fprotobuf_2ffield_5fmask_2eproto::InitDefaults();
return *internal_default_instance();
}
@ -245,7 +245,7 @@ void FieldMask::SerializeWithCachedSizes(
::google::protobuf::uint8* FieldMask::InternalSerializeWithCachedSizesToArray(
bool deterministic, ::google::protobuf::uint8* target) const {
(void)deterministic; // Unused
(void)deterministic; // Unused
// @@protoc_insertion_point(serialize_to_array_start:google.protobuf.FieldMask)
// repeated string paths = 1;
for (int i = 0; i < this->paths_size(); i++) {
@ -330,8 +330,8 @@ void FieldMask::InternalSwap(FieldMask* other) {
}
::google::protobuf::Metadata FieldMask::GetMetadata() const {
protobuf_AssignDescriptorsOnce();
return file_level_metadata[0];
protobuf_google_2fprotobuf_2ffield_5fmask_2eproto::protobuf_AssignDescriptorsOnce();
return protobuf_google_2fprotobuf_2ffield_5fmask_2eproto::file_level_metadata[0];
}
#if PROTOBUF_INLINE_NOT_IN_HEADERS

Some files were not shown because too many files have changed in this diff Show More