diff --git a/protobuf-api/src/main/java/com/google/protobuf/DescriptorProtos.java b/protobuf-api/src/main/java/com/google/protobuf/DescriptorProtos.java index bc20823..64e9fae 100644 --- a/protobuf-api/src/main/java/com/google/protobuf/DescriptorProtos.java +++ b/protobuf-api/src/main/java/com/google/protobuf/DescriptorProtos.java @@ -4,6 +4,16 @@ // Protobuf Java Version: 3.25.5 package com.google.protobuf; +import java.io.IOException; +import java.io.OutputStream; +import java.io.Serializable; +import java.util.Collections; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.TreeMap; + public final class DescriptorProtos { private DescriptorProtos() {} public static void registerAllExtensions( @@ -315,7 +325,7 @@ public static final class FileDescriptorSet extends FileDescriptorSetOrBuilder { private static final long serialVersionUID = 0L; // Use FileDescriptorSet.newBuilder() to construct. - private FileDescriptorSet(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { + private FileDescriptorSet(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { super(builder); } private FileDescriptorSet() { @@ -570,7 +580,7 @@ protected Builder newBuilderForType( */ public static final class Builder extends com.google.protobuf.GeneratedMessageV3.ExtendableBuilder< - com.google.protobuf.DescriptorProtos.FileDescriptorSet, Builder> implements + FileDescriptorSet, Builder> implements // @@protoc_insertion_point(builder_implements:google.protobuf.FileDescriptorSet) com.google.protobuf.DescriptorProtos.FileDescriptorSetOrBuilder { public static final com.google.protobuf.Descriptors.Descriptor @@ -10927,7 +10937,7 @@ public static final class ExtensionRangeOptions extends ExtensionRangeOptionsOrBuilder { private static final long serialVersionUID = 0L; // Use ExtensionRangeOptions.newBuilder() to construct. - private ExtensionRangeOptions(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { + private ExtensionRangeOptions(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { super(builder); } private ExtensionRangeOptions() { @@ -12809,7 +12819,7 @@ protected Builder newBuilderForType( */ public static final class Builder extends com.google.protobuf.GeneratedMessageV3.ExtendableBuilder< - com.google.protobuf.DescriptorProtos.ExtensionRangeOptions, Builder> implements + ExtensionRangeOptions, Builder> implements // @@protoc_insertion_point(builder_implements:google.protobuf.ExtensionRangeOptions) com.google.protobuf.DescriptorProtos.ExtensionRangeOptionsOrBuilder { public static final com.google.protobuf.Descriptors.Descriptor @@ -14428,14 +14438,181 @@ public interface FieldDescriptorProtoOrBuilder extends * * Protobuf type {@code google.protobuf.FieldDescriptorProto} */ - public static final class FieldDescriptorProto extends - com.google.protobuf.GeneratedMessageV3 implements + public static final class FieldDescriptorProto // @@protoc_insertion_point(message_implements:google.protobuf.FieldDescriptorProto) - FieldDescriptorProtoOrBuilder { + implements Message, FieldDescriptorProtoOrBuilder, Serializable { + + protected UnknownFieldSet unknownFields = UnknownFieldSet.getDefaultInstance(); + + protected int memoizedHashCode = 0; + + @Override + public UnknownFieldSet getUnknownFields() { + return unknownFields; + } + + @Override + public int getRepeatedFieldCount(final Descriptors.FieldDescriptor field) { + return internalGetFieldAccessorTable().getField(field).getRepeatedCount(this); + } + + @Override + public Object getRepeatedField(final Descriptors.FieldDescriptor field, final int index) { + return internalGetFieldAccessorTable().getField(field).getRepeated(this, index); + } + + @Override + public boolean hasOneof(final Descriptors.OneofDescriptor oneof) { + return internalGetFieldAccessorTable().getOneof(oneof).has(this); + } + + @Override + public Descriptors.FieldDescriptor getOneofFieldDescriptor(final Descriptors.OneofDescriptor oneof) { + return internalGetFieldAccessorTable().getOneof(oneof).get(this); + } + + @Override + public boolean hasField(final Descriptors.FieldDescriptor field) { + return internalGetFieldAccessorTable().getField(field).has(this); + } + + @Override + public Object getField(final Descriptors.FieldDescriptor field) { + return internalGetFieldAccessorTable().getField(field).get(this); + } + + @Override + public Map getAllFields() { + return Collections.unmodifiableMap(getAllFieldsMutable(/* getBytesForString= */ false)); + } + + private Map getAllFieldsMutable(boolean getBytesForString) { + final TreeMap result = new TreeMap<>(); + final Descriptors.Descriptor descriptor = internalGetFieldAccessorTable().descriptor; + final List fields = descriptor.getFields(); + + for (int i = 0; i < fields.size(); i++) { + Descriptors.FieldDescriptor field = fields.get(i); + final Descriptors.OneofDescriptor oneofDescriptor = field.getContainingOneof(); + + /* + * If the field is part of a Oneof, then at maximum one field in the Oneof is set + * and it is not repeated. There is no need to iterate through the others. + */ + if (oneofDescriptor != null) { + // Skip other fields in the Oneof we know are not set + i += oneofDescriptor.getFieldCount() - 1; + if (!hasOneof(oneofDescriptor)) { + // If no field is set in the Oneof, skip all the fields in the Oneof + continue; + } + // Get the pointer to the only field which is set in the Oneof + field = getOneofFieldDescriptor(oneofDescriptor); + } else { + // If we are not in a Oneof, we need to check if the field is set and if it is repeated + if (field.isRepeated()) { + final List value = (List) getField(field); + if (!value.isEmpty()) { + result.put(field, value); + } + continue; + } + if (!hasField(field)) { + continue; + } + } + // Add the field to the map + if (getBytesForString && field.getJavaType() == Descriptors.FieldDescriptor.JavaType.STRING) { + result.put(field, getFieldRaw(field)); + } else { + result.put(field, getField(field)); + } + } + return result; + } + + Object getFieldRaw(final Descriptors.FieldDescriptor field) { + return internalGetFieldAccessorTable().getField(field).getRaw(this); + } + + @Override + public Descriptors.Descriptor getDescriptorForType() { + return internalGetFieldAccessorTable().descriptor; + } + + @Override + public ByteString toByteString() { + try { + final ByteString.CodedBuilder out = ByteString.newCodedBuilder(getSerializedSize()); + writeTo(out.getCodedOutput()); + return out.build(); + } catch (IOException e) { + throw new RuntimeException(getSerializingExceptionMessage("ByteString"), e); + } + } + + @Override + public byte[] toByteArray() { + try { + final byte[] result = new byte[getSerializedSize()]; + final CodedOutputStream output = CodedOutputStream.newInstance(result); + writeTo(output); + output.checkNoSpaceLeft(); + return result; + } catch (IOException e) { + throw new RuntimeException(getSerializingExceptionMessage("byte array"), e); + } + } + + @Override + public void writeTo(final OutputStream output) throws IOException { + final int bufferSize = CodedOutputStream.computePreferredBufferSize(getSerializedSize()); + final CodedOutputStream codedOutput = CodedOutputStream.newInstance(output, bufferSize); + writeTo(codedOutput); + codedOutput.flush(); + } + + @Override + public void writeDelimitedTo(final OutputStream output) throws IOException { + final int serialized = getSerializedSize(); + final int bufferSize = + CodedOutputStream.computePreferredBufferSize( + CodedOutputStream.computeUInt32SizeNoTag(serialized) + serialized); + final CodedOutputStream codedOutput = CodedOutputStream.newInstance(output, bufferSize); + codedOutput.writeUInt32NoTag(serialized); + writeTo(codedOutput); + codedOutput.flush(); + } + + private String getSerializingExceptionMessage(String target) { + return "Serializing " + + getClass().getName() + + " to a " + + target + + " threw an IOException (should never happen)."; + } + + protected int memoizedSize = -1; + + @Override + public List findInitializationErrors() { + return MessageReflection.findMissingFields(this); + } + + @Override + public String getInitializationErrorString() { + return MessageReflection.delimitWithCommas(findInitializationErrors()); + } + + @Override + public final String toString() { + return TextFormat.printer().printToString(this); + } + private static final long serialVersionUID = 0L; // Use FieldDescriptorProto.newBuilder() to construct. private FieldDescriptorProto(com.google.protobuf.GeneratedMessageV3.Builder builder) { - super(builder); +// super(builder); } private FieldDescriptorProto() { name_ = ""; @@ -14447,10 +14624,10 @@ private FieldDescriptorProto() { jsonName_ = ""; } - @java.lang.Override +// @java.lang.Override @SuppressWarnings({"unused"}) protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { + GeneratedMessageV3.UnusedPrivateParameter unused) { return new FieldDescriptorProto(); } @@ -14459,7 +14636,7 @@ protected java.lang.Object newInstance( return com.google.protobuf.DescriptorProtos.internal_static_google_protobuf_FieldDescriptorProto_descriptor; } - @java.lang.Override +// @java.lang.Override protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable() { return com.google.protobuf.DescriptorProtos.internal_static_google_protobuf_FieldDescriptorProto_fieldAccessorTable @@ -15740,7 +15917,7 @@ public Builder toBuilder() { ? new Builder() : new Builder().mergeFrom(this); } - @java.lang.Override +// @java.lang.Override protected Builder newBuilderForType( com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { Builder builder = new Builder(parent); @@ -24966,7 +25143,7 @@ public static final class FileOptions extends FileOptionsOrBuilder { private static final long serialVersionUID = 0L; // Use FileOptions.newBuilder() to construct. - private FileOptions(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { + private FileOptions(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { super(builder); } private FileOptions() { @@ -26709,7 +26886,7 @@ protected Builder newBuilderForType( */ public static final class Builder extends com.google.protobuf.GeneratedMessageV3.ExtendableBuilder< - com.google.protobuf.DescriptorProtos.FileOptions, Builder> implements + FileOptions, Builder> implements // @@protoc_insertion_point(builder_implements:google.protobuf.FileOptions) com.google.protobuf.DescriptorProtos.FileOptionsOrBuilder { public static final com.google.protobuf.Descriptors.Descriptor @@ -29884,7 +30061,7 @@ public static final class MessageOptions extends MessageOptionsOrBuilder { private static final long serialVersionUID = 0L; // Use MessageOptions.newBuilder() to construct. - private MessageOptions(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { + private MessageOptions(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { super(builder); } private MessageOptions() { @@ -30550,7 +30727,7 @@ protected Builder newBuilderForType( */ public static final class Builder extends com.google.protobuf.GeneratedMessageV3.ExtendableBuilder< - com.google.protobuf.DescriptorProtos.MessageOptions, Builder> implements + MessageOptions, Builder> implements // @@protoc_insertion_point(builder_implements:google.protobuf.MessageOptions) com.google.protobuf.DescriptorProtos.MessageOptionsOrBuilder { public static final com.google.protobuf.Descriptors.Descriptor @@ -31950,7 +32127,7 @@ public com.google.protobuf.DescriptorProtos.MessageOptions getDefaultInstanceFor public interface FieldOptionsOrBuilder extends // @@protoc_insertion_point(interface_extends:google.protobuf.FieldOptions) - com.google.protobuf.GeneratedMessageV3. + com.google.protobuf.DescriptorProtos. ExtendableMessageOrBuilder { /** @@ -32350,18 +32527,1284 @@ com.google.protobuf.DescriptorProtos.FieldOptions.EditionDefaultOrBuilder getEdi com.google.protobuf.DescriptorProtos.UninterpretedOptionOrBuilder getUninterpretedOptionOrBuilder( int index); } + + /** + * Checks that the {@link Extension} is non-Lite and returns it as a {@link GeneratedMessage.GeneratedExtension}. + */ + private static , T> + Extension checkNotLite(ExtensionLite extension) { + if (extension.isLite()) { + throw new IllegalArgumentException("Expected non-lite extension."); + } + + return (Extension) extension; + } + + /** Extends {@link MessageOrBuilder} with extension-related functions. */ + public interface ExtendableMessageOrBuilder> + extends MessageOrBuilder { + // Re-define for return type covariance. + @Override + Message getDefaultInstanceForType(); + + /** Check if a singular extension is present. */ + boolean hasExtension(ExtensionLite extension); + + /** Get the number of elements in a repeated extension. */ + int getExtensionCount(ExtensionLite> extension); + + /** Get the value of an extension. */ + T getExtension(ExtensionLite extension); + + /** Get one element of a repeated extension. */ + T getExtension(ExtensionLite> extension, int index); + + /** + * Check if a singular extension is present. + *

TODO: handled by ExtensionLite version + */ + boolean hasExtension( + Extension extension); + /** + * Check if a singular extension is present. + *

TODO: handled by ExtensionLite version + */ + boolean hasExtension( + GeneratedMessage.GeneratedExtension extension); + /** + * Get the number of elements in a repeated extension. + *

TODO: handled by ExtensionLite version + */ + int getExtensionCount( + Extension> extension); + /** + * Get the number of elements in a repeated extension. + *

TODO: handled by ExtensionLite version + */ + int getExtensionCount( + GeneratedMessage.GeneratedExtension> extension); + /** + * Get the value of an extension. + *

TODO: handled by ExtensionLite version + */ + T getExtension( + Extension extension); + /** + * Get the value of an extension. + *

TODO: handled by ExtensionLite version + */ + T getExtension( + GeneratedMessage.GeneratedExtension extension); + /** + * Get one element of a repeated extension. + *

TODO: handled by ExtensionLite version + */ + T getExtension( + Extension> extension, + int index); + /** + * Get one element of a repeated extension. + *

TODO: handled by ExtensionLite version + */ + T getExtension( + GeneratedMessage.GeneratedExtension> extension, + int index); + } + + protected interface BuilderParent { + void markDirty(); + } + + /** + * Generated message builders for message types that contain extension ranges subclass this. + * + *

This class implements type-safe accessors for extensions. They implement all the same + * operations that you can do with normal fields -- e.g. "get", "set", and "add" -- but for + * extensions. The extensions are identified using instances of the class {@link + * GeneratedMessage.GeneratedExtension}; the protocol compiler generates a static instance of this class for every + * extension in its input. Through the magic of generics, all is made type-safe. + * + *

For example, imagine you have the {@code .proto} file: + * + * 

+     * option java_class = "MyProto";
+     *
+     * message Foo {
+     *   extensions 1000 to max;
+     * }
+     *
+     * extend Foo {
+     *   optional int32 bar;
+     * }
+     *
+ * + *

Then you might write code like: + * + * 

+     * MyProto.Foo foo =
+     *   MyProto.Foo.newBuilder()
+     *     .setExtension(MyProto.bar, 123)
+     *     .build();
+     *
+ * + *

See also {@link GeneratedMessageV3.ExtendableMessage}. + */ + @SuppressWarnings("unchecked") + public abstract static class ExtendableBuilder< + MessageT extends ExtendableMessage, + BuilderT extends ExtendableBuilder> +// extends Builder + implements ExtendableMessageOrBuilder { + + private FieldSet.Builder extensions; + + private BuilderParent builderParent; + + // Indicates that we've built a message and so we are now obligated + // to dispatch dirty invalidations. See GeneratedMessageV3.BuilderListener. + private boolean isClean; + + /** + * Implementation of {@link GeneratedMessageV3.BuilderParent} for giving to our children. This small inner class + * makes it so we don't publicly expose the BuilderParent methods. + */ + private class BuilderParentImpl implements BuilderParent { + + @Override + public void markDirty() { + onChanged(); + } + } + +// @Override + void dispose() { + builderParent = null; + } + + /** Called by the subclass when a message is built. */ + protected void onBuilt() { + if (builderParent != null) { + markClean(); + } + } + + /** + * Called by the subclass or a builder to notify us that a message was built and may be cached + * and therefore invalidations are needed. + */ +// @Override + protected void markClean() { + this.isClean = true; + } + + /** + * Gets whether invalidations are needed + * + * @return whether invalidations are needed + */ + protected boolean isClean() { + return isClean; + } + + protected ExtendableBuilder() {} + + protected ExtendableBuilder(BuilderParent parent) { + this.builderParent = parent; +// super(parent); + } + + // For immutable message conversion. + void internalSetExtensionSet(FieldSet extensions) { + this.extensions = FieldSet.Builder.fromFieldSet(extensions); + } + +// @Override + public BuilderT clear() { + extensions = null; + return (BuilderT) this; + } + + private void ensureExtensionsIsMutable() { + if (extensions == null) { + extensions = FieldSet.newBuilder(); + } + } + + private void verifyExtensionContainingType(final Extension extension) { + if (extension.getDescriptor().getContainingType() != getDescriptorForType()) { + // This can only happen if someone uses unchecked operations. + throw new IllegalArgumentException( + "Extension is for type \"" + + extension.getDescriptor().getContainingType().getFullName() + + "\" which does not match message type \"" + + getDescriptorForType().getFullName() + + "\"."); + } + } + + /** Check if a singular extension is present. */ + @Override + public final boolean hasExtension(final ExtensionLite extensionLite) { + Extension extension = checkNotLite(extensionLite); + + verifyExtensionContainingType(extension); + return extensions != null && extensions.hasField(extension.getDescriptor()); + } + + /** Get the number of elements in a repeated extension. */ + @Override + public final int getExtensionCount(final ExtensionLite> extensionLite) { + Extension> extension = checkNotLite(extensionLite); + + verifyExtensionContainingType(extension); + final Descriptors.FieldDescriptor descriptor = extension.getDescriptor(); + return extensions == null ? 0 : extensions.getRepeatedFieldCount(descriptor); + } + + /** Get the value of an extension. */ + @Override + public final T getExtension(final ExtensionLite extensionLite) { + Extension extension = checkNotLite(extensionLite); + + verifyExtensionContainingType(extension); + Descriptors.FieldDescriptor descriptor = extension.getDescriptor(); + final Object value = extensions == null ? null : extensions.getField(descriptor); + if (value == null) { + if (descriptor.isRepeated()) { + return (T) Collections.emptyList(); + } else if (descriptor.getJavaType() == Descriptors.FieldDescriptor.JavaType.MESSAGE) { + return (T) extension.getMessageDefaultInstance(); + } else { + return (T) extension.fromReflectionType(descriptor.getDefaultValue()); + } + } else { + return (T) extension.fromReflectionType(value); + } + } + + /** Get one element of a repeated extension. */ + @Override + public final T getExtension( + final ExtensionLite> extensionLite, final int index) { + Extension> extension = checkNotLite(extensionLite); + + verifyExtensionContainingType(extension); + Descriptors.FieldDescriptor descriptor = extension.getDescriptor(); + if (extensions == null) { + throw new IndexOutOfBoundsException(); + } + return (T) + extension.singularFromReflectionType(extensions.getRepeatedField(descriptor, index)); + } + + /** + * Called when a builder or one of its nested children has changed and any parent should be + * notified of its invalidation. + */ + protected final void onChanged() { + if (isClean && builderParent != null) { + builderParent.markDirty(); + + // Don't keep dispatching invalidations until build is called again. + isClean = false; + } + } + + /** Set the value of an extension. */ + public final BuilderT setExtension( + final ExtensionLite extensionLite, final T value) { + Extension extension = checkNotLite(extensionLite); + + verifyExtensionContainingType(extension); + ensureExtensionsIsMutable(); + final Descriptors.FieldDescriptor descriptor = extension.getDescriptor(); + extensions.setField(descriptor, extension.toReflectionType(value)); + onChanged(); + return (BuilderT) this; + } + + /** Set the value of one element of a repeated extension. */ + public final BuilderT setExtension( + final ExtensionLite> extensionLite, final int index, final T value) { + Extension> extension = checkNotLite(extensionLite); + + verifyExtensionContainingType(extension); + ensureExtensionsIsMutable(); + final Descriptors.FieldDescriptor descriptor = extension.getDescriptor(); + extensions.setRepeatedField(descriptor, index, extension.singularToReflectionType(value)); + onChanged(); + return (BuilderT) this; + } + + /** Append a value to a repeated extension. */ + public final BuilderT addExtension( + final ExtensionLite> extensionLite, final T value) { + Extension> extension = checkNotLite(extensionLite); + + verifyExtensionContainingType(extension); + ensureExtensionsIsMutable(); + final Descriptors.FieldDescriptor descriptor = extension.getDescriptor(); + extensions.addRepeatedField(descriptor, extension.singularToReflectionType(value)); + onChanged(); + return (BuilderT) this; + } + + /** Clear an extension. */ + public final BuilderT clearExtension(final ExtensionLite extensionLite) { + Extension extension = checkNotLite(extensionLite); + + verifyExtensionContainingType(extension); + ensureExtensionsIsMutable(); + extensions.clearField(extension.getDescriptor()); + onChanged(); + return (BuilderT) this; + } + + /** + * Check if a singular extension is present. + *

TODO: handled by ExtensionLite version + */ + @Override + public final boolean hasExtension(final Extension extension) { + return hasExtension((ExtensionLite) extension); + } + /** + * Check if a singular extension is present. + *

TODO: handled by ExtensionLite version + */ + @Override + public final boolean hasExtension( + final GeneratedMessage.GeneratedExtension extension) { + return hasExtension((ExtensionLite) extension); + } + /** + * Get the number of elements in a repeated extension. + *

TODO: handled by ExtensionLite version + */ + @Override + public final int getExtensionCount( + final Extension> extension) { + return getExtensionCount((ExtensionLite>) extension); + } + /** + * Get the number of elements in a repeated extension. + *

TODO: handled by ExtensionLite version + */ + @Override + public final int getExtensionCount( + final GeneratedMessage.GeneratedExtension> extension) { + return getExtensionCount((ExtensionLite>) extension); + } + /** + * Get the value of an extension. + *

TODO: handled by ExtensionLite version + */ + @Override + public final T getExtension(final Extension extension) { + return getExtension((ExtensionLite) extension); + } + /** Get the value of an extension. + *

TODO: handled by ExtensionLite version + */ + @Override + public final T getExtension( + final GeneratedMessage.GeneratedExtension extension) { + return getExtension((ExtensionLite) extension); + } + /** + * Get the value of an extension. + *

TODO: handled by ExtensionLite version + */ + @Override + public final T getExtension( + final Extension> extension, final int index) { + return getExtension((ExtensionLite>) extension, index); + } + /** + * Get the value of an extension. + *

TODO: handled by ExtensionLite version + */ + @Override + public final T getExtension( + final GeneratedMessage.GeneratedExtension> extension, final int index) { + return getExtension((ExtensionLite>) extension, index); + } + /** + * Set the value of an extension. + *

TODO: handled by ExtensionLite version + */ + public final BuilderT setExtension( + final Extension extension, final T value) { + return setExtension((ExtensionLite) extension, value); + } + /** + * Set the value of an extension. + *

TODO: handled by ExtensionLite version + */ + public BuilderT setExtension( + final GeneratedMessage.GeneratedExtension extension, final T value) { + return setExtension((ExtensionLite) extension, value); + } + /** + * Set the value of one element of a repeated extension. + *

TODO: handled by ExtensionLite version + */ + public final BuilderT setExtension( + final Extension> extension, + final int index, final T value) { + return setExtension((ExtensionLite>) extension, index, value); + } + /** + * Set the value of one element of a repeated extension. + *

TODO: handled by ExtensionLite version + */ + public BuilderT setExtension( + final GeneratedMessage.GeneratedExtension> extension, + final int index, final T value) { + return setExtension((ExtensionLite>) extension, index, value); + } + /** + * Append a value to a repeated extension. + *

TODO: handled by ExtensionLite version + */ + public final BuilderT addExtension( + final Extension> extension, final T value) { + return addExtension((ExtensionLite>) extension, value); + } + /** + * Append a value to a repeated extension. + *

TODO: handled by ExtensionLite version + */ + public BuilderT addExtension( + final GeneratedMessage.GeneratedExtension> extension, final T value) { + return addExtension((ExtensionLite>) extension, value); + } + /** + * Clear an extension. + *

TODO: handled by ExtensionLite version + */ + public final BuilderT clearExtension( + final Extension extension) { + return clearExtension((ExtensionLite) extension); + } + /** + * Clears an extension. + *

TODO: handled by ExtensionLite version + */ + public BuilderT clearExtension( + final GeneratedMessage.GeneratedExtension extension) { + return clearExtension((ExtensionLite) extension); + } + + /** Called by subclasses to check if all extensions are initialized. */ + protected boolean extensionsAreInitialized() { + return extensions == null || extensions.isInitialized(); + } + + /** + * Called by the build code path to create a copy of the extensions for building the message. + */ + private FieldSet buildExtensions() { + return extensions == null + ? (FieldSet) FieldSet.emptySet() + : extensions.buildPartial(); + } + + @Override + public boolean isInitialized() { + return +// super.isInitialized() && + extensionsAreInitialized(); + } + + // --------------------------------------------------------------- + // Reflection + + @Override + public Map getAllFields() { + final Map result = getAllFieldsMutable(); + if (extensions != null) { + result.putAll(extensions.getAllFields()); + } + return Collections.unmodifiableMap(result); + } + + /** + * Get the FieldAccessorTable for this type. We can't have the message class pass this in to the + * constructor because of bootstrapping trouble with DescriptorProtos. + */ + protected abstract GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable(); + + /** Internal helper which returns a mutable map. */ + private Map getAllFieldsMutable() { + final TreeMap result = new TreeMap<>(); + final Descriptors.Descriptor descriptor = internalGetFieldAccessorTable().descriptor; + final List fields = descriptor.getFields(); + + for (int i = 0; i < fields.size(); i++) { + Descriptors.FieldDescriptor field = fields.get(i); + final Descriptors.OneofDescriptor oneofDescriptor = field.getContainingOneof(); + + /* + * If the field is part of a Oneof, then at maximum one field in the Oneof is set + * and it is not repeated. There is no need to iterate through the others. + */ + if (oneofDescriptor != null) { + // Skip other fields in the Oneof we know are not set + i += oneofDescriptor.getFieldCount() - 1; + if (!hasOneof(oneofDescriptor)) { + // If no field is set in the Oneof, skip all the fields in the Oneof + continue; + } + // Get the pointer to the only field which is set in the Oneof + field = getOneofFieldDescriptor(oneofDescriptor); + } else { + // If we are not in a Oneof, we need to check if the field is set and if it is repeated + if (field.isRepeated()) { + final List value = (List) getField(field); + if (!value.isEmpty()) { + result.put(field, value); + } + continue; + } + if (!hasField(field)) { + continue; + } + } + // Add the field to the map + result.put(field, getField(field)); + } + return result; + } + + @Override + public Object getField(final Descriptors.FieldDescriptor field) { +// if (field.isExtension()) { + verifyContainingType(field); + final Object value = extensions == null ? null : extensions.getField(field); + if (value == null) { + if (field.getJavaType() == Descriptors.FieldDescriptor.JavaType.MESSAGE) { + // Lacking an ExtensionRegistry, we have no way to determine the + // extension's real type, so we return a DynamicMessage. + return DynamicMessage.getDefaultInstance(field.getMessageType()); + } else { + return field.getDefaultValue(); + } + } else { + return value; + } +// } +// else { +// return super.getField(field); +// } + } + +// @Override + public Message.Builder getFieldBuilder(final Descriptors.FieldDescriptor field) { +// if (field.isExtension()) { + verifyContainingType(field); + if (field.getJavaType() != Descriptors.FieldDescriptor.JavaType.MESSAGE) { + throw new UnsupportedOperationException( + "getFieldBuilder() called on a non-Message type."); + } + ensureExtensionsIsMutable(); + final Object value = extensions.getFieldAllowBuilders(field); + if (value == null) { + Message.Builder builder = DynamicMessage.newBuilder(field.getMessageType()); + extensions.setField(field, builder); + onChanged(); + return builder; + } else { + if (value instanceof Message.Builder) { + return (Message.Builder) value; + } else if (value instanceof Message) { + Message.Builder builder = ((Message) value).toBuilder(); + extensions.setField(field, builder); + onChanged(); + return builder; + } else { + throw new UnsupportedOperationException( + "getRepeatedFieldBuilder() called on a non-Message type."); + } + } +// } else { +// return super.getFieldBuilder(field); +// } + } + + @Override + public int getRepeatedFieldCount(final Descriptors.FieldDescriptor field) { +// if (field.isExtension()) { + verifyContainingType(field); + return extensions == null ? 0 : extensions.getRepeatedFieldCount(field); +// } else { +// return super.getRepeatedFieldCount(field); +// } + } + + @Override + public Object getRepeatedField(final Descriptors.FieldDescriptor field, final int index) { +// if (field.isExtension()) { + verifyContainingType(field); + if (extensions == null) { + throw new IndexOutOfBoundsException(); + } + return extensions.getRepeatedField(field, index); +// } else { +// return super.getRepeatedField(field, index); +// } + } + +// @Override + public Message.Builder getRepeatedFieldBuilder(final Descriptors.FieldDescriptor field, final int index) { +// if (field.isExtension()) { + verifyContainingType(field); + ensureExtensionsIsMutable(); + if (field.getJavaType() != Descriptors.FieldDescriptor.JavaType.MESSAGE) { + throw new UnsupportedOperationException( + "getRepeatedFieldBuilder() called on a non-Message type."); + } + final Object value = extensions.getRepeatedFieldAllowBuilders(field, index); + if (value instanceof Message.Builder) { + return (Message.Builder) value; + } else if (value instanceof Message) { + Message.Builder builder = ((Message) value).toBuilder(); + extensions.setRepeatedField(field, index, builder); + onChanged(); + return builder; + } else { + throw new UnsupportedOperationException( + "getRepeatedFieldBuilder() called on a non-Message type."); + } +// } else { +// return super.getRepeatedFieldBuilder(field, index); +// } + } + + @Override + public boolean hasField(final Descriptors.FieldDescriptor field) { +// if (field.isExtension()) { + verifyContainingType(field); + return extensions != null && extensions.hasField(field); +// } else { +// return super.hasField(field); +// } + } + +// @Override + public BuilderT setField(final Descriptors.FieldDescriptor field, final Object value) { +// if (field.isExtension()) { + verifyContainingType(field); + ensureExtensionsIsMutable(); + extensions.setField(field, value); + onChanged(); + return (BuilderT) this; +// } else { +// return super.setField(field, value); +// } + } + +// @Override + public BuilderT clearField(final Descriptors.FieldDescriptor field) { +// if (field.isExtension()) { + verifyContainingType(field); + ensureExtensionsIsMutable(); + extensions.clearField(field); + onChanged(); + return (BuilderT) this; +// } else { +// return super.clearField(field); +// } + } + +// @Override + public BuilderT setRepeatedField( + final Descriptors.FieldDescriptor field, final int index, final Object value) { +// if (field.isExtension()) { + verifyContainingType(field); + ensureExtensionsIsMutable(); + extensions.setRepeatedField(field, index, value); + onChanged(); + return (BuilderT) this; +// } else { +// return super.setRepeatedField(field, index, value); +// } + } + +// @Override + public BuilderT addRepeatedField(final Descriptors.FieldDescriptor field, final Object value) { +// if (field.isExtension()) { + verifyContainingType(field); + ensureExtensionsIsMutable(); + extensions.addRepeatedField(field, value); + onChanged(); + return (BuilderT) this; +// } else { +// return super.addRepeatedField(field, value); +// } + } + +// @Override + public Message.Builder newBuilderForField(final Descriptors.FieldDescriptor field) { +// if (field.isExtension()) { + return DynamicMessage.newBuilder(field.getMessageType()); +// } else { +// return super.newBuilderForField(field); +// } + } + + protected final void mergeExtensionFields(final ExtendableMessage other) { + if (other.extensions != null) { + ensureExtensionsIsMutable(); + extensions.mergeFrom(other.extensions); + onChanged(); + } + } + +// @Override + protected boolean parseUnknownField( + CodedInputStream input, ExtensionRegistryLite extensionRegistry, int tag) + throws IOException { + ensureExtensionsIsMutable(); + return MessageReflection.mergeFieldFrom( + input, +// input.shouldDiscardUnknownFields() ? null : getUnknownFieldSetBuilder(), + null, + extensionRegistry, + getDescriptorForType(), + new MessageReflection.ExtensionBuilderAdapter(extensions), + tag); + } + + private void verifyContainingType(final Descriptors.FieldDescriptor field) { + if (field.getContainingType() != getDescriptorForType()) { + throw new IllegalArgumentException("FieldDescriptor does not match message type."); + } + } + } + /** + * Generated message classes for message types that contain extension ranges subclass this. + * + *

This class implements type-safe accessors for extensions. They implement all the same + * operations that you can do with normal fields -- e.g. "has", "get", and "getCount" -- but for + * extensions. The extensions are identified using instances of the class {@link + * GeneratedMessage.GeneratedExtension}; the protocol compiler generates a static instance of this class for every + * extension in its input. Through the magic of generics, all is made type-safe. + * + *

For example, imagine you have the {@code .proto} file: + * + * 

+     * option java_class = "MyProto";
+     *
+     * message Foo {
+     *   extensions 1000 to max;
+     * }
+     *
+     * extend Foo {
+     *   optional int32 bar;
+     * }
+     *
+ * + *

Then you might write code like: + * + * 

+     * MyProto.Foo foo = getFoo();
+     * int i = foo.getExtension(MyProto.bar);
+     *
+ * + *

See also {@link ExtendableBuilder}. + */ + public abstract static class ExtendableMessage> + implements Message, Serializable, ExtendableMessageOrBuilder { + + private static final long serialVersionUID = 1L; + + private final FieldSet extensions; + + protected ExtendableMessage() { + this.extensions = FieldSet.newFieldSet(); + } + + protected ExtendableMessage(DescriptorProtos.ExtendableBuilder builder) { + this.extensions = builder.buildExtensions(); + } + + private void verifyExtensionContainingType(final Extension extension) { + if (extension.getDescriptor().getContainingType() != getDescriptorForType()) { + // This can only happen if someone uses unchecked operations. + throw new IllegalArgumentException( + "Extension is for type \"" + + extension.getDescriptor().getContainingType().getFullName() + + "\" which does not match message type \"" + + getDescriptorForType().getFullName() + + "\"."); + } + } + + /** Check if a singular extension is present. */ + @Override + public final boolean hasExtension(final ExtensionLite extensionLite) { + Extension extension = checkNotLite(extensionLite); + + verifyExtensionContainingType(extension); + return extensions.hasField(extension.getDescriptor()); + } + + /** Get the number of elements in a repeated extension. */ + @Override + public final int getExtensionCount(final ExtensionLite> extensionLite) { + Extension> extension = checkNotLite(extensionLite); + + verifyExtensionContainingType(extension); + final Descriptors.FieldDescriptor descriptor = extension.getDescriptor(); + return extensions.getRepeatedFieldCount(descriptor); + } + + /** Get the value of an extension. */ + @Override + @SuppressWarnings("unchecked") + public final T getExtension(final ExtensionLite extensionLite) { + Extension extension = checkNotLite(extensionLite); + + verifyExtensionContainingType(extension); + Descriptors.FieldDescriptor descriptor = extension.getDescriptor(); + final Object value = extensions.getField(descriptor); + if (value == null) { + if (descriptor.isRepeated()) { + return (T) Collections.emptyList(); + } else if (descriptor.getJavaType() == Descriptors.FieldDescriptor.JavaType.MESSAGE) { + return (T) extension.getMessageDefaultInstance(); + } else { + return (T) extension.fromReflectionType(descriptor.getDefaultValue()); + } + } else { + return (T) extension.fromReflectionType(value); + } + } + + /** Get one element of a repeated extension. */ + @Override + @SuppressWarnings("unchecked") + public final T getExtension( + final ExtensionLite> extensionLite, final int index) { + Extension> extension = checkNotLite(extensionLite); + + verifyExtensionContainingType(extension); + Descriptors.FieldDescriptor descriptor = extension.getDescriptor(); + return (T) + extension.singularFromReflectionType(extensions.getRepeatedField(descriptor, index)); + } + + /** + * Check if a singular extension is present. + *

TODO: handled by ExtensionLite version + */ + @Override + public final boolean hasExtension(final Extension extension) { + return hasExtension((ExtensionLite) extension); + } + /** + * Check if a singular extension is present. + *

TODO: handled by ExtensionLite version + */ + @Override + public final boolean hasExtension( + final GeneratedMessage.GeneratedExtension extension) { + return hasExtension((ExtensionLite) extension); + } + /** + * Get the number of elements in a repeated extension. + *

TODO: handled by ExtensionLite version + */ + @Override + public final int getExtensionCount( + final Extension> extension) { + return getExtensionCount((ExtensionLite>) extension); + } + /** + * Get the number of elements in a repeated extension. + *

TODO: handled by ExtensionLite version + */ + @Override + public final int getExtensionCount( + final GeneratedMessage.GeneratedExtension> extension) { + return getExtensionCount((ExtensionLite>) extension); + } + /** + * Get the value of an extension. + *

TODO: handled by ExtensionLite version + */ + @Override + public final T getExtension(final Extension extension) { + return getExtension((ExtensionLite) extension); + } + /** + * Get the value of an extension. + *

TODO: handled by ExtensionLite version + */ + @Override + public final T getExtension( + final GeneratedMessage.GeneratedExtension extension) { + return getExtension((ExtensionLite) extension); + } + /** + * Get one element of a repeated extension. + *

TODO: handled by ExtensionLite version + */ + @Override + public final T getExtension( + final Extension> extension, final int index) { + return getExtension((ExtensionLite>) extension, index); + } + /** + * Get one element of a repeated extension. + *

TODO: handled by ExtensionLite version + */ + @Override + public final T getExtension( + final GeneratedMessage.GeneratedExtension> extension, final int index) { + return getExtension((ExtensionLite>) extension, index); + } + + /** Called by subclasses to check if all extensions are initialized. */ + protected boolean extensionsAreInitialized() { + return extensions.isInitialized(); + } + + // TODO: compute this in the builder at {@code build()} time. + @Override + public boolean isInitialized() { + return +// super.isInitialized() && + extensionsAreInitialized(); + } + + // TODO: remove mutating method from immutable type +// @Override + protected boolean parseUnknownField( + CodedInputStream input, + UnknownFieldSet.Builder unknownFields, + ExtensionRegistryLite extensionRegistry, + int tag) + throws IOException { + return MessageReflection.mergeFieldFrom( + input, + input.shouldDiscardUnknownFields() ? null : unknownFields, + extensionRegistry, + getDescriptorForType(), + new MessageReflection.ExtensionAdapter(extensions), + tag); + } + + /** + * Delegates to parseUnknownField. This method is obsolete, but we must retain it for + * compatibility with older generated code. + * + *

TODO: remove mutating method from immutable type + */ +// @Override + protected boolean parseUnknownFieldProto3( + CodedInputStream input, + UnknownFieldSet.Builder unknownFields, + ExtensionRegistryLite extensionRegistry, + int tag) + throws IOException { + return parseUnknownField(input, unknownFields, extensionRegistry, tag); + } + + /** + * Used by parsing constructors in generated classes. + * + *

TODO: remove unused method (extensions should be immutable after build) + */ +// @Override + protected void makeExtensionsImmutable() { + extensions.makeImmutable(); + } + + /** + * Used by subclasses to serialize extensions. Extension ranges may be interleaved with field + * numbers, but we must write them in canonical (sorted by field number) order. ExtensionWriter + * helps us write individual ranges of extensions at once. + */ + protected class ExtensionWriter { + // Imagine how much simpler this code would be if Java iterators had + // a way to get the next element without advancing the iterator. + + private final Iterator> iter = extensions.iterator(); + private Map.Entry next; + private final boolean messageSetWireFormat; + + private ExtensionWriter(final boolean messageSetWireFormat) { + if (iter.hasNext()) { + next = iter.next(); + } + this.messageSetWireFormat = messageSetWireFormat; + } + + public void writeUntil(final int end, final CodedOutputStream output) throws IOException { + while (next != null && next.getKey().getNumber() < end) { + Descriptors.FieldDescriptor descriptor = next.getKey(); + if (messageSetWireFormat + && descriptor.getLiteJavaType() == WireFormat.JavaType.MESSAGE + && !descriptor.isRepeated()) { + if (next instanceof LazyField.LazyEntry) { + output.writeRawMessageSetExtension( + descriptor.getNumber(), + ((LazyField.LazyEntry) next).getField().toByteString()); + } else { + output.writeMessageSetExtension(descriptor.getNumber(), (Message) next.getValue()); + } + } else { + // TODO: Taken care of following code, it may cause + // problem when we use LazyField for normal fields/extensions. + // Due to the optional field can be duplicated at the end of + // serialized bytes, which will make the serialized size change + // after lazy field parsed. So when we use LazyField globally, + // we need to change the following write method to write cached + // bytes directly rather than write the parsed message. + FieldSet.writeField(descriptor, next.getValue(), output); + } + if (iter.hasNext()) { + next = iter.next(); + } else { + next = null; + } + } + } + } + + protected ExtensionWriter newExtensionWriter() { + return new ExtensionWriter(false); + } + + protected ExtensionWriter newMessageSetExtensionWriter() { + return new ExtensionWriter(true); + } + + /** Called by subclasses to compute the size of extensions. */ + protected int extensionsSerializedSize() { + return extensions.getSerializedSize(); + } + + protected int extensionsSerializedSizeAsMessageSet() { + return extensions.getMessageSetSerializedSize(); + } + + // --------------------------------------------------------------- + // Reflection + + protected Map getExtensionFields() { + return extensions.getAllFields(); + } + + protected abstract GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable(); + + /** + * Internal helper to return a modifiable map containing all the fields. The returned Map is + * modifiable so that the caller can add additional extension fields to implement {@link + * #getAllFields()}. + * + * @param getBytesForString whether to generate ByteString for string fields + */ + private Map getAllFieldsMutable(boolean getBytesForString) { + final TreeMap result = new TreeMap<>(); + final Descriptors.Descriptor descriptor = internalGetFieldAccessorTable().descriptor; + final List fields = descriptor.getFields(); + + for (int i = 0; i < fields.size(); i++) { + Descriptors.FieldDescriptor field = fields.get(i); + final Descriptors.OneofDescriptor oneofDescriptor = field.getContainingOneof(); + + /* + * If the field is part of a Oneof, then at maximum one field in the Oneof is set + * and it is not repeated. There is no need to iterate through the others. + */ + if (oneofDescriptor != null) { + // Skip other fields in the Oneof we know are not set + i += oneofDescriptor.getFieldCount() - 1; + if (!hasOneof(oneofDescriptor)) { + // If no field is set in the Oneof, skip all the fields in the Oneof + continue; + } + // Get the pointer to the only field which is set in the Oneof + field = getOneofFieldDescriptor(oneofDescriptor); + } else { + // If we are not in a Oneof, we need to check if the field is set and if it is repeated + if (field.isRepeated()) { + final List value = (List) getField(field); + if (!value.isEmpty()) { + result.put(field, value); + } + continue; + } + if (!hasField(field)) { + continue; + } + } + // Add the field to the map + if (getBytesForString && field.getJavaType() == Descriptors.FieldDescriptor.JavaType.STRING) { + result.put(field, getFieldRaw(field)); + } else { + result.put(field, getField(field)); + } + } + return result; + } + + Object getFieldRaw(final Descriptors.FieldDescriptor field) { + return internalGetFieldAccessorTable().getField(field).getRaw(this); + } + + @Override + public Map getAllFields() { + final Map result = + getAllFieldsMutable(/* getBytesForString= */ false); + result.putAll(getExtensionFields()); + return Collections.unmodifiableMap(result); + } + +// @Override + public Map getAllFieldsRaw() { + final Map result = + getAllFieldsMutable(/* getBytesForString= */ false); + result.putAll(getExtensionFields()); + return Collections.unmodifiableMap(result); + } + + @Override + public boolean hasField(final Descriptors.FieldDescriptor field) { +// if (field.isExtension()) { + verifyContainingType(field); + return extensions.hasField(field); +// } else { +// return super.hasField(field); +// } + } + + @Override + public Object getField(final Descriptors.FieldDescriptor field) { +// if (field.isExtension()) { + verifyContainingType(field); + final Object value = extensions.getField(field); + if (value == null) { + if (field.isRepeated()) { + return Collections.emptyList(); + } else if (field.getJavaType() == Descriptors.FieldDescriptor.JavaType.MESSAGE) { + // Lacking an ExtensionRegistry, we have no way to determine the + // extension's real type, so we return a DynamicMessage. + return DynamicMessage.getDefaultInstance(field.getMessageType()); + } else { + return field.getDefaultValue(); + } + } else { + return value; + } +// } else { +// return super.getField(field); +// } + } + + @Override + public int getRepeatedFieldCount(final Descriptors.FieldDescriptor field) { +// if (field.isExtension()) { + verifyContainingType(field); + return extensions.getRepeatedFieldCount(field); +// } else { +// return super.getRepeatedFieldCount(field); +// } + } + + @Override + public Object getRepeatedField(final Descriptors.FieldDescriptor field, final int index) { +// if (field.isExtension()) { + verifyContainingType(field); + return extensions.getRepeatedField(field, index); +// } else { +// return super.getRepeatedField(field, index); +// } + } + + private void verifyContainingType(final Descriptors.FieldDescriptor field) { + if (field.getContainingType() != getDescriptorForType()) { + throw new IllegalArgumentException("FieldDescriptor does not match message type."); + } + } + } + + /** Construct an UninitializedMessageException reporting missing fields in the given message. */ + protected static UninitializedMessageException newUninitializedMessageException( + Message message) { + return new UninitializedMessageException(MessageReflection.findMissingFields(message)); + } + + /** Converts a list of MapEntry messages into a Map used for equals() and hashCode(). */ + @SuppressWarnings({"rawtypes", "unchecked"}) + private static Map convertMapEntryListToMap(List list) { + if (list.isEmpty()) { + return Collections.emptyMap(); + } + Map result = new HashMap<>(); + Iterator iterator = list.iterator(); + Message entry = (Message) iterator.next(); + Descriptors.Descriptor descriptor = entry.getDescriptorForType(); + Descriptors.FieldDescriptor key = descriptor.findFieldByName("key"); + Descriptors.FieldDescriptor value = descriptor.findFieldByName("value"); + Object fieldValue = entry.getField(value); + if (fieldValue instanceof Descriptors.EnumValueDescriptor) { + fieldValue = ((Descriptors.EnumValueDescriptor) fieldValue).getNumber(); + } + result.put(entry.getField(key), fieldValue); + while (iterator.hasNext()) { + entry = (Message) iterator.next(); + fieldValue = entry.getField(value); + if (fieldValue instanceof Descriptors.EnumValueDescriptor) { + fieldValue = ((Descriptors.EnumValueDescriptor) fieldValue).getNumber(); + } + result.put(entry.getField(key), fieldValue); + } + return result; + } + + /** Calculates the hash code of a map field. {@code value} must be a list of MapEntry messages. */ + @SuppressWarnings("unchecked") + private static int hashMapField(Object value) { + return MapFieldLite.calculateHashCodeForMap(convertMapEntryListToMap((List) value)); + } + + /** Get a hash code for given fields and values, using the given seed. */ + @SuppressWarnings("unchecked") + private static int hashFields(int hash, Map map) { + for (Map.Entry entry : map.entrySet()) { + Descriptors.FieldDescriptor field = entry.getKey(); + Object value = entry.getValue(); + hash = (37 * hash) + field.getNumber(); + if (field.isMapField()) { + hash = (53 * hash) + hashMapField(value); + } else if (field.getType() != Descriptors.FieldDescriptor.Type.ENUM) { + hash = (53 * hash) + value.hashCode(); + } else if (field.isRepeated()) { + List list = (List) value; + hash = (53 * hash) + Internal.hashEnumList(list); + } else { + hash = (53 * hash) + Internal.hashEnum((Internal.EnumLite) value); + } + } + return hash; + } + /** * Protobuf type {@code google.protobuf.FieldOptions} */ public static final class FieldOptions extends - com.google.protobuf.GeneratedMessageV3.ExtendableMessage< + com.google.protobuf.DescriptorProtos.ExtendableMessage< FieldOptions> implements // @@protoc_insertion_point(message_implements:google.protobuf.FieldOptions) FieldOptionsOrBuilder { private static final long serialVersionUID = 0L; // Use FieldOptions.newBuilder() to construct. - private FieldOptions(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { - super(builder); + private FieldOptions(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { +// super(builder); } private FieldOptions() { ctype_ = 0; @@ -32372,10 +33815,11 @@ private FieldOptions() { uninterpretedOption_ = java.util.Collections.emptyList(); } - @java.lang.Override +// @java.lang.Override @SuppressWarnings({"unused"}) protected java.lang.Object newInstance( - UnusedPrivateParameter unused) { +// UnusedPrivateParameter unused + ) { return new FieldOptions(); } @@ -32384,7 +33828,7 @@ protected java.lang.Object newInstance( return com.google.protobuf.DescriptorProtos.internal_static_google_protobuf_FieldOptions_descriptor; } - @java.lang.Override +// @java.lang.Override protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable() { return com.google.protobuf.DescriptorProtos.internal_static_google_protobuf_FieldOptions_fieldAccessorTable @@ -32392,6 +33836,119 @@ protected java.lang.Object newInstance( com.google.protobuf.DescriptorProtos.FieldOptions.class, com.google.protobuf.DescriptorProtos.FieldOptions.Builder.class); } + protected UnknownFieldSet unknownFields = UnknownFieldSet.getDefaultInstance(); + + protected int memoizedHashCode = 0; + + @Override + public UnknownFieldSet getUnknownFields() { + return unknownFields; + } + + @Override + public int getRepeatedFieldCount(final Descriptors.FieldDescriptor field) { + return internalGetFieldAccessorTable().getField(field).getRepeatedCount(this); + } + + @Override + public Object getRepeatedField(final Descriptors.FieldDescriptor field, final int index) { + return internalGetFieldAccessorTable().getField(field).getRepeated(this, index); + } + + @Override + public boolean hasOneof(final Descriptors.OneofDescriptor oneof) { + return internalGetFieldAccessorTable().getOneof(oneof).has(this); + } + + @Override + public Descriptors.FieldDescriptor getOneofFieldDescriptor(final Descriptors.OneofDescriptor oneof) { + return internalGetFieldAccessorTable().getOneof(oneof).get(this); + } + + @Override + public boolean hasField(final Descriptors.FieldDescriptor field) { + return internalGetFieldAccessorTable().getField(field).has(this); + } + + @Override + public Object getField(final Descriptors.FieldDescriptor field) { + return internalGetFieldAccessorTable().getField(field).get(this); + } + + @Override + public Descriptors.Descriptor getDescriptorForType() { + return internalGetFieldAccessorTable().descriptor; + } + + @Override + public ByteString toByteString() { + try { + final ByteString.CodedBuilder out = ByteString.newCodedBuilder(getSerializedSize()); + writeTo(out.getCodedOutput()); + return out.build(); + } catch (IOException e) { + throw new RuntimeException(getSerializingExceptionMessage("ByteString"), e); + } + } + + @Override + public byte[] toByteArray() { + try { + final byte[] result = new byte[getSerializedSize()]; + final CodedOutputStream output = CodedOutputStream.newInstance(result); + writeTo(output); + output.checkNoSpaceLeft(); + return result; + } catch (IOException e) { + throw new RuntimeException(getSerializingExceptionMessage("byte array"), e); + } + } + + @Override + public void writeTo(final OutputStream output) throws IOException { + final int bufferSize = CodedOutputStream.computePreferredBufferSize(getSerializedSize()); + final CodedOutputStream codedOutput = CodedOutputStream.newInstance(output, bufferSize); + writeTo(codedOutput); + codedOutput.flush(); + } + + @Override + public void writeDelimitedTo(final OutputStream output) throws IOException { + final int serialized = getSerializedSize(); + final int bufferSize = + CodedOutputStream.computePreferredBufferSize( + CodedOutputStream.computeUInt32SizeNoTag(serialized) + serialized); + final CodedOutputStream codedOutput = CodedOutputStream.newInstance(output, bufferSize); + codedOutput.writeUInt32NoTag(serialized); + writeTo(codedOutput); + codedOutput.flush(); + } + + private String getSerializingExceptionMessage(String target) { + return "Serializing " + + getClass().getName() + + " to a " + + target + + " threw an IOException (should never happen)."; + } + + protected int memoizedSize = -1; + + @Override + public List findInitializationErrors() { + return MessageReflection.findMissingFields(this); + } + + @Override + public String getInitializationErrorString() { + return MessageReflection.delimitWithCommas(findInitializationErrors()); + } + + @Override + public final String toString() { + return TextFormat.printer().printToString(this); + } + /** * Protobuf enum {@code google.protobuf.FieldOptions.CType} */ @@ -35358,7 +36915,7 @@ public final boolean isInitialized() { @java.lang.Override public void writeTo(com.google.protobuf.CodedOutputStream output) throws java.io.IOException { - com.google.protobuf.GeneratedMessageV3 + com.google.protobuf.DescriptorProtos .ExtendableMessage.ExtensionWriter extensionWriter = newExtensionWriter(); if (((bitField0_ & 0x00000001) != 0)) { @@ -35714,7 +37271,7 @@ public Builder toBuilder() { ? new Builder() : new Builder().mergeFrom(this); } - @java.lang.Override +// @java.lang.Override protected Builder newBuilderForType( com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { Builder builder = new Builder(parent); @@ -35725,7 +37282,7 @@ protected Builder newBuilderForType( */ public static final class Builder extends com.google.protobuf.GeneratedMessageV3.ExtendableBuilder< - com.google.protobuf.DescriptorProtos.FieldOptions, Builder> implements + FieldOptions, Builder> implements // @@protoc_insertion_point(builder_implements:google.protobuf.FieldOptions) com.google.protobuf.DescriptorProtos.FieldOptionsOrBuilder { public static final com.google.protobuf.Descriptors.Descriptor @@ -35813,7 +37370,7 @@ public com.google.protobuf.DescriptorProtos.FieldOptions getDefaultInstanceForTy return com.google.protobuf.DescriptorProtos.FieldOptions.getDefaultInstance(); } - @java.lang.Override +// @java.lang.Override public com.google.protobuf.DescriptorProtos.FieldOptions build() { com.google.protobuf.DescriptorProtos.FieldOptions result = buildPartial(); if (!result.isInitialized()) { @@ -35822,7 +37379,7 @@ public com.google.protobuf.DescriptorProtos.FieldOptions build() { return result; } - @java.lang.Override +// @java.lang.Override public com.google.protobuf.DescriptorProtos.FieldOptions buildPartial() { com.google.protobuf.DescriptorProtos.FieldOptions result = new com.google.protobuf.DescriptorProtos.FieldOptions(this); buildPartialRepeatedFields(result); @@ -36077,7 +37634,7 @@ public Builder mergeFrom(com.google.protobuf.DescriptorProtos.FieldOptions other } } } - this.mergeExtensionFields(other); +// this.mergeExtensionFields(other); this.mergeUnknownFields(other.getUnknownFields()); onChanged(); return this; @@ -38060,7 +39617,7 @@ public static final class OneofOptions extends OneofOptionsOrBuilder { private static final long serialVersionUID = 0L; // Use OneofOptions.newBuilder() to construct. - private OneofOptions(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { + private OneofOptions(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { super(builder); } private OneofOptions() { @@ -38400,7 +39957,7 @@ protected Builder newBuilderForType( */ public static final class Builder extends com.google.protobuf.GeneratedMessageV3.ExtendableBuilder< - com.google.protobuf.DescriptorProtos.OneofOptions, Builder> implements + OneofOptions, Builder> implements // @@protoc_insertion_point(builder_implements:google.protobuf.OneofOptions) com.google.protobuf.DescriptorProtos.OneofOptionsOrBuilder { public static final com.google.protobuf.Descriptors.Descriptor @@ -39415,7 +40972,7 @@ public static final class EnumOptions extends EnumOptionsOrBuilder { private static final long serialVersionUID = 0L; // Use EnumOptions.newBuilder() to construct. - private EnumOptions(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { + private EnumOptions(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { super(builder); } private EnumOptions() { @@ -39909,7 +41466,7 @@ protected Builder newBuilderForType( */ public static final class Builder extends com.google.protobuf.GeneratedMessageV3.ExtendableBuilder< - com.google.protobuf.DescriptorProtos.EnumOptions, Builder> implements + EnumOptions, Builder> implements // @@protoc_insertion_point(builder_implements:google.protobuf.EnumOptions) com.google.protobuf.DescriptorProtos.EnumOptionsOrBuilder { public static final com.google.protobuf.Descriptors.Descriptor @@ -41171,7 +42728,7 @@ public static final class EnumValueOptions extends EnumValueOptionsOrBuilder { private static final long serialVersionUID = 0L; // Use EnumValueOptions.newBuilder() to construct. - private EnumValueOptions(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { + private EnumValueOptions(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { super(builder); } private EnumValueOptions() { @@ -41663,7 +43220,7 @@ protected Builder newBuilderForType( */ public static final class Builder extends com.google.protobuf.GeneratedMessageV3.ExtendableBuilder< - com.google.protobuf.DescriptorProtos.EnumValueOptions, Builder> implements + EnumValueOptions, Builder> implements // @@protoc_insertion_point(builder_implements:google.protobuf.EnumValueOptions) com.google.protobuf.DescriptorProtos.EnumValueOptionsOrBuilder { public static final com.google.protobuf.Descriptors.Descriptor @@ -42961,7 +44518,7 @@ public static final class ServiceOptions extends ServiceOptionsOrBuilder { private static final long serialVersionUID = 0L; // Use ServiceOptions.newBuilder() to construct. - private ServiceOptions(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { + private ServiceOptions(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { super(builder); } private ServiceOptions() { @@ -43351,7 +44908,7 @@ protected Builder newBuilderForType( */ public static final class Builder extends com.google.protobuf.GeneratedMessageV3.ExtendableBuilder< - com.google.protobuf.DescriptorProtos.ServiceOptions, Builder> implements + ServiceOptions, Builder> implements // @@protoc_insertion_point(builder_implements:google.protobuf.ServiceOptions) com.google.protobuf.DescriptorProtos.ServiceOptionsOrBuilder { public static final com.google.protobuf.Descriptors.Descriptor @@ -44404,7 +45961,7 @@ public static final class MethodOptions extends MethodOptionsOrBuilder { private static final long serialVersionUID = 0L; // Use MethodOptions.newBuilder() to construct. - private MethodOptions(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { + private MethodOptions(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { super(builder); } private MethodOptions() { @@ -44955,7 +46512,7 @@ protected Builder newBuilderForType( */ public static final class Builder extends com.google.protobuf.GeneratedMessageV3.ExtendableBuilder< - com.google.protobuf.DescriptorProtos.MethodOptions, Builder> implements + MethodOptions, Builder> implements // @@protoc_insertion_point(builder_implements:google.protobuf.MethodOptions) com.google.protobuf.DescriptorProtos.MethodOptionsOrBuilder { public static final com.google.protobuf.Descriptors.Descriptor @@ -48372,7 +49929,7 @@ public static final class FeatureSet extends FeatureSetOrBuilder { private static final long serialVersionUID = 0L; // Use FeatureSet.newBuilder() to construct. - private FeatureSet(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { + private FeatureSet(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { super(builder); } private FeatureSet() { @@ -49414,7 +50971,7 @@ protected Builder newBuilderForType( */ public static final class Builder extends com.google.protobuf.GeneratedMessageV3.ExtendableBuilder< - com.google.protobuf.DescriptorProtos.FeatureSet, Builder> implements + FeatureSet, Builder> implements // @@protoc_insertion_point(builder_implements:google.protobuf.FeatureSet) com.google.protobuf.DescriptorProtos.FeatureSetOrBuilder { public static final com.google.protobuf.Descriptors.Descriptor @@ -52487,7 +54044,7 @@ public static final class SourceCodeInfo extends SourceCodeInfoOrBuilder { private static final long serialVersionUID = 0L; // Use SourceCodeInfo.newBuilder() to construct. - private SourceCodeInfo(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { + private SourceCodeInfo(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder builder) { super(builder); } private SourceCodeInfo() { @@ -55365,7 +56922,7 @@ protected Builder newBuilderForType( */ public static final class Builder extends com.google.protobuf.GeneratedMessageV3.ExtendableBuilder< - com.google.protobuf.DescriptorProtos.SourceCodeInfo, Builder> implements + SourceCodeInfo, Builder> implements // @@protoc_insertion_point(builder_implements:google.protobuf.SourceCodeInfo) com.google.protobuf.DescriptorProtos.SourceCodeInfoOrBuilder { public static final com.google.protobuf.Descriptors.Descriptor diff --git a/protobuf-api/src/main/java/com/google/protobuf/GeneratedMessageV3.java b/protobuf-api/src/main/java/com/google/protobuf/GeneratedMessageV3.java index 9c4980f..a0e7097 100644 --- a/protobuf-api/src/main/java/com/google/protobuf/GeneratedMessageV3.java +++ b/protobuf-api/src/main/java/com/google/protobuf/GeneratedMessageV3.java @@ -969,7 +969,7 @@ protected MapField internalGetMutableMapField(int fieldNumber) { // Extensions-related stuff /** Extends {@link MessageOrBuilder} with extension-related functions. */ - public interface ExtendableMessageOrBuilder> + public interface ExtendableMessageOrBuilder extends MessageOrBuilder { // Re-define for return type covariance. @Override @@ -1466,7 +1466,7 @@ private void verifyContainingType(final FieldDescriptor field) { */ @SuppressWarnings("unchecked") public abstract static class ExtendableBuilder< - MessageT extends ExtendableMessage, + MessageT extends Message, BuilderT extends ExtendableBuilder> extends Builder implements ExtendableMessageOrBuilder { @@ -2097,7 +2097,7 @@ public FieldAccessorTable(final Descriptor descriptor, final String[] camelCaseN * @return this */ public FieldAccessorTable ensureFieldAccessorsInitialized( - Class messageClass, Class> builderClass) { + Class messageClass, Class> builderClass) { if (initialized) { return this; } @@ -2185,14 +2185,14 @@ public FieldAccessorTable ensureFieldAccessorsInitialized( } } - private final Descriptor descriptor; + public final Descriptor descriptor; private final FieldAccessor[] fields; private String[] camelCaseNames; private final OneofAccessor[] oneofs; private volatile boolean initialized; /** Get the FieldAccessor for a particular field. */ - private FieldAccessor getField(final FieldDescriptor field) { + public FieldAccessor getField(final FieldDescriptor field) { if (field.getContainingType() != descriptor) { throw new IllegalArgumentException("FieldDescriptor does not match message type."); } else if (field.isExtension()) { @@ -2204,7 +2204,7 @@ private FieldAccessor getField(final FieldDescriptor field) { } /** Get the OneofAccessor for a particular oneof. */ - private OneofAccessor getOneof(final OneofDescriptor oneof) { + public OneofAccessor getOneof(final OneofDescriptor oneof) { if (oneof.getContainingType() != descriptor) { throw new IllegalArgumentException("OneofDescriptor does not match message type."); } @@ -2215,16 +2215,16 @@ private OneofAccessor getOneof(final OneofDescriptor oneof) { * Abstract interface that provides access to a single field. This is implemented differently * depending on the field type and cardinality. */ - private interface FieldAccessor { - Object get(GeneratedMessageV3 message); + public interface FieldAccessor { + Object get(Message message); Object get(GeneratedMessageV3.Builder builder); - Object getRaw(GeneratedMessageV3 message); + Object getRaw(Message message); void set(Builder builder, Object value); - Object getRepeated(GeneratedMessageV3 message, int index); + Object getRepeated(Message message, int index); Object getRepeated(GeneratedMessageV3.Builder builder, int index); @@ -2232,11 +2232,11 @@ private interface FieldAccessor { void addRepeated(Builder builder, Object value); - boolean has(GeneratedMessageV3 message); + boolean has(Message message); boolean has(GeneratedMessageV3.Builder builder); - int getRepeatedCount(GeneratedMessageV3 message); + int getRepeatedCount(Message message); int getRepeatedCount(GeneratedMessageV3.Builder builder); @@ -2250,12 +2250,12 @@ private interface FieldAccessor { } /** OneofAccessor provides access to a single oneof. */ - private static interface OneofAccessor { - public boolean has(final GeneratedMessageV3 message); + public static interface OneofAccessor { + public boolean has(final Message message); public boolean has(GeneratedMessageV3.Builder builder); - public FieldDescriptor get(final GeneratedMessageV3 message); + public FieldDescriptor get(final Message message); public FieldDescriptor get(GeneratedMessageV3.Builder builder); @@ -2268,7 +2268,7 @@ private static class RealOneofAccessor implements OneofAccessor { final Descriptor descriptor, final int oneofIndex, final String camelCaseName, - final Class messageClass, + final Class messageClass, final Class> builderClass) { this.descriptor = descriptor; caseMethod = getMethodOrDie(messageClass, "get" + camelCaseName + "Case"); @@ -2282,7 +2282,7 @@ private static class RealOneofAccessor implements OneofAccessor { private final Method clearMethod; @Override - public boolean has(final GeneratedMessageV3 message) { + public boolean has(final Message message) { return ((Internal.EnumLite) invokeOrDie(caseMethod, message)).getNumber() != 0; } @@ -2292,7 +2292,7 @@ public boolean has(GeneratedMessageV3.Builder builder) { } @Override - public FieldDescriptor get(final GeneratedMessageV3 message) { + public FieldDescriptor get(final Message message) { int fieldNumber = ((Internal.EnumLite) invokeOrDie(caseMethod, message)).getNumber(); if (fieldNumber > 0) { return descriptor.findFieldByNumber(fieldNumber); @@ -2326,7 +2326,7 @@ private static class SyntheticOneofAccessor implements OneofAccessor { private final FieldDescriptor fieldDescriptor; @Override - public boolean has(final GeneratedMessageV3 message) { + public boolean has(final Message message) { return message.hasField(fieldDescriptor); } @@ -2336,7 +2336,7 @@ public boolean has(GeneratedMessageV3.Builder builder) { } @Override - public FieldDescriptor get(final GeneratedMessageV3 message) { + public FieldDescriptor get(final Message message) { return message.hasField(fieldDescriptor) ? fieldDescriptor : null; } @@ -2355,17 +2355,17 @@ public void clear(final Builder builder) { @SuppressWarnings("SameNameButDifferent") private static class SingularFieldAccessor implements FieldAccessor { private interface MethodInvoker { - Object get(final GeneratedMessageV3 message); + Object get(final Message message); Object get(GeneratedMessageV3.Builder builder); - int getOneofFieldNumber(final GeneratedMessageV3 message); + int getOneofFieldNumber(final Message message); int getOneofFieldNumber(final GeneratedMessageV3.Builder builder); void set(final GeneratedMessageV3.Builder builder, final Object value); - boolean has(final GeneratedMessageV3 message); + boolean has(final Message message); boolean has(GeneratedMessageV3.Builder builder); @@ -2385,7 +2385,7 @@ private static final class ReflectionInvoker implements MethodInvoker { ReflectionInvoker( final FieldDescriptor descriptor, final String camelCaseName, - final Class messageClass, + final Class messageClass, final Class> builderClass, final String containingOneofCamelCaseName, boolean isOneofField, @@ -2409,7 +2409,7 @@ private static final class ReflectionInvoker implements MethodInvoker { } @Override - public Object get(final GeneratedMessageV3 message) { + public Object get(final Message message) { return invokeOrDie(getMethod, message); } @@ -2419,7 +2419,7 @@ public Object get(GeneratedMessageV3.Builder builder) { } @Override - public int getOneofFieldNumber(final GeneratedMessageV3 message) { + public int getOneofFieldNumber(final Message message) { return ((Internal.EnumLite) invokeOrDie(caseMethod, message)).getNumber(); } @@ -2435,7 +2435,7 @@ public void set(final GeneratedMessageV3.Builder builder, final Object value) } @Override - public boolean has(final GeneratedMessageV3 message) { + public boolean has(final Message message) { return (Boolean) invokeOrDie(hasMethod, message); } @@ -2454,7 +2454,7 @@ public void clear(final GeneratedMessageV3.Builder builder) { SingularFieldAccessor( final FieldDescriptor descriptor, final String camelCaseName, - final Class messageClass, + final Class messageClass, final Class> builderClass, final String containingOneofCamelCaseName) { isOneofField = @@ -2492,7 +2492,7 @@ static MethodInvoker getMethodInvoker(ReflectionInvoker accessor) { protected final MethodInvoker invoker; @Override - public Object get(final GeneratedMessageV3 message) { + public Object get(final Message message) { return invoker.get(message); } @@ -2502,7 +2502,7 @@ public Object get(GeneratedMessageV3.Builder builder) { } @Override - public Object getRaw(final GeneratedMessageV3 message) { + public Object getRaw(final Message message) { return get(message); } @@ -2512,7 +2512,7 @@ public void set(final Builder builder, final Object value) { } @Override - public Object getRepeated(final GeneratedMessageV3 message, final int index) { + public Object getRepeated(final Message message, final int index) { throw new UnsupportedOperationException("getRepeatedField() called on a singular field."); } @@ -2532,7 +2532,7 @@ public void addRepeated(final Builder builder, final Object value) { } @Override - public boolean has(final GeneratedMessageV3 message) { + public boolean has(final Message message) { if (!hasHasMethod) { if (isOneofField) { return invoker.getOneofFieldNumber(message) == field.getNumber(); @@ -2554,7 +2554,7 @@ public boolean has(GeneratedMessageV3.Builder builder) { } @Override - public int getRepeatedCount(final GeneratedMessageV3 message) { + public int getRepeatedCount(final Message message) { throw new UnsupportedOperationException( "getRepeatedFieldSize() called on a singular field."); } @@ -2591,11 +2591,11 @@ public Message.Builder getRepeatedBuilder(GeneratedMessageV3.Builder builder, @SuppressWarnings("SameNameButDifferent") private static class RepeatedFieldAccessor implements FieldAccessor { interface MethodInvoker { - Object get(final GeneratedMessageV3 message); + Object get(final Message message); Object get(GeneratedMessageV3.Builder builder); - Object getRepeated(final GeneratedMessageV3 message, final int index); + Object getRepeated(final Message message, final int index); Object getRepeated(GeneratedMessageV3.Builder builder, int index); @@ -2604,7 +2604,7 @@ void setRepeated( void addRepeated(final GeneratedMessageV3.Builder builder, final Object value); - int getRepeatedCount(final GeneratedMessageV3 message); + int getRepeatedCount(final Message message); int getRepeatedCount(GeneratedMessageV3.Builder builder); @@ -2625,7 +2625,7 @@ private static final class ReflectionInvoker implements MethodInvoker { ReflectionInvoker( final FieldDescriptor descriptor, final String camelCaseName, - final Class messageClass, + final Class messageClass, final Class> builderClass) { getMethod = getMethodOrDie(messageClass, "get" + camelCaseName + "List"); getMethodBuilder = getMethodOrDie(builderClass, "get" + camelCaseName + "List"); @@ -2642,7 +2642,7 @@ private static final class ReflectionInvoker implements MethodInvoker { } @Override - public Object get(final GeneratedMessageV3 message) { + public Object get(final Message message) { return invokeOrDie(getMethod, message); } @@ -2652,7 +2652,7 @@ public Object get(GeneratedMessageV3.Builder builder) { } @Override - public Object getRepeated(final GeneratedMessageV3 message, final int index) { + public Object getRepeated(final Message message, final int index) { return invokeOrDie(getRepeatedMethod, message, index); } @@ -2675,7 +2675,7 @@ public void addRepeated(final GeneratedMessageV3.Builder builder, final Objec } @Override - public int getRepeatedCount(final GeneratedMessageV3 message) { + public int getRepeatedCount(final Message message) { return (Integer) invokeOrDie(getCountMethod, message); } @@ -2697,7 +2697,7 @@ public void clear(final GeneratedMessageV3.Builder builder) { RepeatedFieldAccessor( final FieldDescriptor descriptor, final String camelCaseName, - final Class messageClass, + final Class messageClass, final Class> builderClass) { ReflectionInvoker reflectionInvoker = new ReflectionInvoker(descriptor, camelCaseName, messageClass, builderClass); @@ -2710,7 +2710,7 @@ static MethodInvoker getMethodInvoker(ReflectionInvoker accessor) { } @Override - public Object get(final GeneratedMessageV3 message) { + public Object get(final Message message) { return invoker.get(message); } @@ -2720,7 +2720,7 @@ public Object get(GeneratedMessageV3.Builder builder) { } @Override - public Object getRaw(final GeneratedMessageV3 message) { + public Object getRaw(final Message message) { return get(message); } @@ -2737,7 +2737,7 @@ public void set(final Builder builder, final Object value) { } @Override - public Object getRepeated(final GeneratedMessageV3 message, final int index) { + public Object getRepeated(final Message message, final int index) { return invoker.getRepeated(message, index); } @@ -2757,7 +2757,7 @@ public void addRepeated(final Builder builder, final Object value) { } @Override - public boolean has(final GeneratedMessageV3 message) { + public boolean has(final Message message) { throw new UnsupportedOperationException("hasField() called on a repeated field."); } @@ -2767,7 +2767,7 @@ public boolean has(GeneratedMessageV3.Builder builder) { } @Override - public int getRepeatedCount(final GeneratedMessageV3 message) { + public int getRepeatedCount(final Message message) { return invoker.getRepeatedCount(message); } @@ -2801,7 +2801,7 @@ public Message.Builder getRepeatedBuilder(GeneratedMessageV3.Builder builder, private static class MapFieldAccessor implements FieldAccessor { MapFieldAccessor( - final FieldDescriptor descriptor, final Class messageClass) { + final FieldDescriptor descriptor, final Class messageClass) { field = descriptor; Method getDefaultInstanceMethod = getMethodOrDie(messageClass, "getDefaultInstance"); MapFieldReflectionAccessor defaultMapField = @@ -2812,8 +2812,8 @@ private static class MapFieldAccessor implements FieldAccessor { private final FieldDescriptor field; private final Message mapEntryMessageDefaultInstance; - private MapFieldReflectionAccessor getMapField(GeneratedMessageV3 message) { - return message.internalGetMapFieldReflection(field.getNumber()); + private MapFieldReflectionAccessor getMapField(Message message) { + return ((GeneratedMessageV3) message).internalGetMapFieldReflection(field.getNumber()); } private MapFieldReflectionAccessor getMapField(GeneratedMessageV3.Builder builder) { @@ -2839,7 +2839,7 @@ private Message coerceType(Message value) { } @Override - public Object get(GeneratedMessageV3 message) { + public Object get(Message message) { List result = new ArrayList<>(); for (int i = 0; i < getRepeatedCount(message); i++) { result.add(getRepeated(message, i)); @@ -2857,7 +2857,7 @@ public Object get(Builder builder) { } @Override - public Object getRaw(GeneratedMessageV3 message) { + public Object getRaw(Message message) { return get(message); } @@ -2870,7 +2870,7 @@ public void set(Builder builder, Object value) { } @Override - public Object getRepeated(GeneratedMessageV3 message, int index) { + public Object getRepeated(Message message, int index) { return getMapField(message).getList().get(index); } @@ -2890,7 +2890,7 @@ public void addRepeated(Builder builder, Object value) { } @Override - public boolean has(GeneratedMessageV3 message) { + public boolean has(Message message) { throw new UnsupportedOperationException("hasField() is not supported for repeated fields."); } @@ -2900,7 +2900,7 @@ public boolean has(Builder builder) { } @Override - public int getRepeatedCount(GeneratedMessageV3 message) { + public int getRepeatedCount(Message message) { return getMapField(message).getList().size(); } @@ -2936,7 +2936,7 @@ private static final class SingularEnumFieldAccessor extends SingularFieldAccess SingularEnumFieldAccessor( final FieldDescriptor descriptor, final String camelCaseName, - final Class messageClass, + final Class messageClass, final Class> builderClass, final String containingOneofCamelCaseName) { super(descriptor, camelCaseName, messageClass, builderClass, containingOneofCamelCaseName); @@ -2965,7 +2965,7 @@ private static final class SingularEnumFieldAccessor extends SingularFieldAccess private Method setValueMethod; @Override - public Object get(final GeneratedMessageV3 message) { + public Object get(final Message message) { if (supportUnknownEnumValue) { int value = (Integer) invokeOrDie(getValueMethod, message); return enumDescriptor.findValueByNumberCreatingIfUnknown(value); @@ -2998,7 +2998,7 @@ private static final class RepeatedEnumFieldAccessor extends RepeatedFieldAccess RepeatedEnumFieldAccessor( final FieldDescriptor descriptor, final String camelCaseName, - final Class messageClass, + final Class messageClass, final Class> builderClass) { super(descriptor, camelCaseName, messageClass, builderClass); @@ -3033,7 +3033,7 @@ private static final class RepeatedEnumFieldAccessor extends RepeatedFieldAccess private Method addRepeatedValueMethod; @Override - public Object get(final GeneratedMessageV3 message) { + public Object get(final Message message) { final List newList = new ArrayList<>(); final int size = getRepeatedCount(message); for (int i = 0; i < size; i++) { @@ -3053,7 +3053,7 @@ public Object get(final GeneratedMessageV3.Builder builder) { } @Override - public Object getRepeated(final GeneratedMessageV3 message, final int index) { + public Object getRepeated(final Message message, final int index) { if (supportUnknownEnumValue) { int value = (Integer) invokeOrDie(getRepeatedValueMethod, message, index); return enumDescriptor.findValueByNumberCreatingIfUnknown(value); @@ -3114,7 +3114,7 @@ private static final class SingularStringFieldAccessor extends SingularFieldAcce SingularStringFieldAccessor( final FieldDescriptor descriptor, final String camelCaseName, - final Class messageClass, + final Class messageClass, final Class> builderClass, final String containingOneofCamelCaseName) { super(descriptor, camelCaseName, messageClass, builderClass, containingOneofCamelCaseName); @@ -3127,7 +3127,7 @@ private static final class SingularStringFieldAccessor extends SingularFieldAcce private final Method setBytesMethodBuilder; @Override - public Object getRaw(final GeneratedMessageV3 message) { + public Object getRaw(final Message message) { return invokeOrDie(getBytesMethod, message); } @@ -3148,7 +3148,7 @@ private static final class SingularMessageFieldAccessor extends SingularFieldAcc SingularMessageFieldAccessor( final FieldDescriptor descriptor, final String camelCaseName, - final Class messageClass, + final Class messageClass, final Class> builderClass, final String containingOneofCamelCaseName) { super(descriptor, camelCaseName, messageClass, builderClass, containingOneofCamelCaseName); @@ -3194,7 +3194,7 @@ private static final class RepeatedMessageFieldAccessor extends RepeatedFieldAcc RepeatedMessageFieldAccessor( final FieldDescriptor descriptor, final String camelCaseName, - final Class messageClass, + final Class messageClass, final Class> builderClass) { super(descriptor, camelCaseName, messageClass, builderClass); @@ -3257,7 +3257,7 @@ protected Object writeReplace() throws ObjectStreamException { /** * Checks that the {@link Extension} is non-Lite and returns it as a {@link GeneratedExtension}. */ - private static , T> + private static Extension checkNotLite(ExtensionLite extension) { if (extension.isLite()) { throw new IllegalArgumentException("Expected non-lite extension."); diff --git a/protobuf-api/src/main/java/com/google/protobuf/RepeatedFieldBuilderV3.java b/protobuf-api/src/main/java/com/google/protobuf/RepeatedFieldBuilderV3.java index b36794f..191799f 100644 --- a/protobuf-api/src/main/java/com/google/protobuf/RepeatedFieldBuilderV3.java +++ b/protobuf-api/src/main/java/com/google/protobuf/RepeatedFieldBuilderV3.java @@ -37,7 +37,7 @@ * @author jonp@google.com (Jon Perlow) */ public class RepeatedFieldBuilderV3< - MType extends AbstractMessage, + MType extends Message, BType extends AbstractMessage.Builder, IType extends MessageOrBuilder> implements AbstractMessage.BuilderParent { @@ -551,7 +551,7 @@ private void incrementModCounts() { * @param the common interface for the message and the builder */ private static class MessageExternalList< - MType extends AbstractMessage, + MType extends Message, BType extends AbstractMessage.Builder, IType extends MessageOrBuilder> extends AbstractList implements List, RandomAccess { @@ -585,7 +585,7 @@ void incrementModCount() { * @param the common interface for the message and the builder */ private static class BuilderExternalList< - MType extends AbstractMessage, + MType extends Message, BType extends AbstractMessage.Builder, IType extends MessageOrBuilder> extends AbstractList implements List, RandomAccess { @@ -619,7 +619,7 @@ void incrementModCount() { * @param the common interface for the message and the builder */ private static class MessageOrBuilderExternalList< - MType extends AbstractMessage, + MType extends Message, BType extends AbstractMessage.Builder, IType extends MessageOrBuilder> extends AbstractList implements List, RandomAccess { diff --git a/protobuf-api/src/main/java/com/google/protobuf/SingleFieldBuilderV3.java b/protobuf-api/src/main/java/com/google/protobuf/SingleFieldBuilderV3.java index 0aff2b8..5ee8b45 100644 --- a/protobuf-api/src/main/java/com/google/protobuf/SingleFieldBuilderV3.java +++ b/protobuf-api/src/main/java/com/google/protobuf/SingleFieldBuilderV3.java @@ -30,7 +30,7 @@ * @author jonp@google.com (Jon Perlow) */ public class SingleFieldBuilderV3< - MType extends AbstractMessage, + MType extends Message, BType extends AbstractMessage.Builder, IType extends MessageOrBuilder> implements AbstractMessage.BuilderParent { @@ -105,7 +105,7 @@ public BType getBuilder() { // does not create any sub-objects with independent clean/dirty states, // therefore setting the builder itself to clean without actually calling // build() cannot break any invariants. - builder = (BType) message.newBuilderForType(this); + builder = (BType) message.newBuilderForType(); builder.mergeFrom(message); // no-op if message is the default message builder.markClean(); }