diff options
Diffstat (limited to 'java/src/main/java/com/google/protobuf/GeneratedMessageLite.java')
| -rw-r--r-- | java/src/main/java/com/google/protobuf/GeneratedMessageLite.java | 319 |
1 files changed, 189 insertions, 130 deletions
diff --git a/java/src/main/java/com/google/protobuf/GeneratedMessageLite.java b/java/src/main/java/com/google/protobuf/GeneratedMessageLite.java index 6c5136fd..8fe33bc6 100644 --- a/java/src/main/java/com/google/protobuf/GeneratedMessageLite.java +++ b/java/src/main/java/com/google/protobuf/GeneratedMessageLite.java @@ -30,6 +30,8 @@ package com.google.protobuf; +import com.google.protobuf.WireFormat.FieldType; + import java.io.IOException; import java.io.ObjectStreamException; import java.io.Serializable; @@ -50,10 +52,15 @@ public abstract class GeneratedMessageLite extends AbstractMessageLite implements Serializable { private static final long serialVersionUID = 1L; + /** For use by generated code only. */ + protected UnknownFieldSetLite unknownFields; + protected GeneratedMessageLite() { + unknownFields = UnknownFieldSetLite.getDefaultInstance(); } protected GeneratedMessageLite(Builder builder) { + unknownFields = builder.unknownFields; } public Parser<? extends MessageLite> getParserForType() { @@ -62,15 +69,16 @@ public abstract class GeneratedMessageLite extends AbstractMessageLite } /** - * Called by subclasses to parse an unknown field. + * Called by subclasses to parse an unknown field. For use by generated code + * only. * @return {@code true} unless the tag is an end-group tag. */ - protected boolean parseUnknownField( + protected static boolean parseUnknownField( CodedInputStream input, - CodedOutputStream unknownFieldsCodedOutput, + UnknownFieldSetLite.Builder unknownFields, ExtensionRegistryLite extensionRegistry, int tag) throws IOException { - return input.skipField(tag, unknownFieldsCodedOutput); + return unknownFields.mergeFieldFrom(tag, input); } /** @@ -84,22 +92,28 @@ public abstract class GeneratedMessageLite extends AbstractMessageLite public abstract static class Builder<MessageType extends GeneratedMessageLite, BuilderType extends Builder> extends AbstractMessageLite.Builder<BuilderType> { + + private UnknownFieldSetLite unknownFields = + UnknownFieldSetLite.getDefaultInstance(); + protected Builder() {} //@Override (Java 1.6 override semantics, but we must support 1.5) public BuilderType clear() { - unknownFields = ByteString.EMPTY; + unknownFields = UnknownFieldSetLite.getDefaultInstance(); return (BuilderType) this; } - // This is implemented here only to work around an apparent bug in the - // Java compiler and/or build system. See bug #1898463. The mere presence - // of this dummy clone() implementation makes it go away. - @Override + //@Override (Java 1.6 override semantics, but we must support 1.5) public BuilderType clone() { - throw new UnsupportedOperationException( - "This is supposed to be overridden by subclasses."); + BuilderType builder = + (BuilderType) getDefaultInstanceForType().newBuilderForType(); + builder.mergeFrom(buildPartial()); + return builder; } + + /** All subclasses implement this. */ + public abstract MessageType buildPartial(); /** All subclasses implement this. */ public abstract BuilderType mergeFrom(MessageType message); @@ -113,22 +127,43 @@ public abstract class GeneratedMessageLite extends AbstractMessageLite */ protected boolean parseUnknownField( CodedInputStream input, - CodedOutputStream unknownFieldsCodedOutput, + UnknownFieldSetLite.Builder unknownFields, ExtensionRegistryLite extensionRegistry, int tag) throws IOException { - return input.skipField(tag, unknownFieldsCodedOutput); + return unknownFields.mergeFieldFrom(tag, input); } - public final ByteString getUnknownFields() { - return unknownFields; + /** + * Merge some unknown fields into the {@link UnknownFieldSetLite} for this + * message. + * + * <p>For use by generated code only. + */ + protected final BuilderType mergeUnknownFields( + final UnknownFieldSetLite unknownFields) { + this.unknownFields = UnknownFieldSetLite.concat(this.unknownFields, unknownFields); + return (BuilderType) this; } - - public final BuilderType setUnknownFields(final ByteString unknownFields) { - this.unknownFields = unknownFields; + + public BuilderType mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + MessageType parsedMessage = null; + try { + parsedMessage = + (MessageType) getDefaultInstanceForType().getParserForType().parsePartialFrom( + input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (MessageType) e.getUnfinishedMessage(); + throw e; + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } return (BuilderType) this; } - - private ByteString unknownFields = ByteString.EMPTY; } @@ -143,18 +178,18 @@ public abstract class GeneratedMessageLite extends AbstractMessageLite /** Check if a singular extension is present. */ <Type> boolean hasExtension( - GeneratedExtension<MessageType, Type> extension); + ExtensionLite<MessageType, Type> extension); /** Get the number of elements in a repeated extension. */ <Type> int getExtensionCount( - GeneratedExtension<MessageType, List<Type>> extension); + ExtensionLite<MessageType, List<Type>> extension); /** Get the value of an extension. */ - <Type> Type getExtension(GeneratedExtension<MessageType, Type> extension); + <Type> Type getExtension(ExtensionLite<MessageType, Type> extension); /** Get one element of a repeated extension. */ <Type> Type getExtension( - GeneratedExtension<MessageType, List<Type>> extension, + ExtensionLite<MessageType, List<Type>> extension, int index); } @@ -166,7 +201,11 @@ public abstract class GeneratedMessageLite extends AbstractMessageLite extends GeneratedMessageLite implements ExtendableMessageOrBuilder<MessageType> { - private final FieldSet<ExtensionDescriptor> extensions; + /** + * Represents the set of extensions on this message. For use by generated + * code only. + */ + protected final FieldSet<ExtensionDescriptor> extensions; protected ExtendableMessage() { this.extensions = FieldSet.newFieldSet(); @@ -190,30 +229,39 @@ public abstract class GeneratedMessageLite extends AbstractMessageLite /** Check if a singular extension is present. */ //@Override (Java 1.6 override semantics, but we must support 1.5) public final <Type> boolean hasExtension( - final GeneratedExtension<MessageType, Type> extension) { - verifyExtensionContainingType(extension); - return extensions.hasField(extension.descriptor); + final ExtensionLite<MessageType, Type> extension) { + GeneratedExtension<MessageType, Type> extensionLite = + checkIsLite(extension); + + verifyExtensionContainingType(extensionLite); + return extensions.hasField(extensionLite.descriptor); } /** Get the number of elements in a repeated extension. */ //@Override (Java 1.6 override semantics, but we must support 1.5) public final <Type> int getExtensionCount( - final GeneratedExtension<MessageType, List<Type>> extension) { - verifyExtensionContainingType(extension); - return extensions.getRepeatedFieldCount(extension.descriptor); + final ExtensionLite<MessageType, List<Type>> extension) { + GeneratedExtension<MessageType, List<Type>> extensionLite = + checkIsLite(extension); + + verifyExtensionContainingType(extensionLite); + return extensions.getRepeatedFieldCount(extensionLite.descriptor); } /** Get the value of an extension. */ //@Override (Java 1.6 override semantics, but we must support 1.5) @SuppressWarnings("unchecked") public final <Type> Type getExtension( - final GeneratedExtension<MessageType, Type> extension) { - verifyExtensionContainingType(extension); - final Object value = extensions.getField(extension.descriptor); + final ExtensionLite<MessageType, Type> extension) { + GeneratedExtension<MessageType, Type> extensionLite = + checkIsLite(extension); + + verifyExtensionContainingType(extensionLite); + final Object value = extensions.getField(extensionLite.descriptor); if (value == null) { - return extension.defaultValue; + return extensionLite.defaultValue; } else { - return (Type) extension.fromFieldSetType(value); + return (Type) extensionLite.fromFieldSetType(value); } } @@ -221,11 +269,14 @@ public abstract class GeneratedMessageLite extends AbstractMessageLite //@Override (Java 1.6 override semantics, but we must support 1.5) @SuppressWarnings("unchecked") public final <Type> Type getExtension( - final GeneratedExtension<MessageType, List<Type>> extension, + final ExtensionLite<MessageType, List<Type>> extension, final int index) { - verifyExtensionContainingType(extension); - return (Type) extension.singularFromFieldSetType( - extensions.getRepeatedField(extension.descriptor, index)); + GeneratedExtension<MessageType, List<Type>> extensionLite = + checkIsLite(extension); + + verifyExtensionContainingType(extensionLite); + return (Type) extensionLite.singularFromFieldSetType( + extensions.getRepeatedField(extensionLite.descriptor, index)); } /** Called by subclasses to check if all extensions are initialized. */ @@ -233,25 +284,6 @@ public abstract class GeneratedMessageLite extends AbstractMessageLite return extensions.isInitialized(); } - /** - * Called by subclasses to parse an unknown field or an extension. - * @return {@code true} unless the tag is an end-group tag. - */ - @Override - protected boolean parseUnknownField( - CodedInputStream input, - CodedOutputStream unknownFieldsCodedOutput, - ExtensionRegistryLite extensionRegistry, - int tag) throws IOException { - return GeneratedMessageLite.parseUnknownField( - extensions, - getDefaultInstanceForType(), - input, - unknownFieldsCodedOutput, - extensionRegistry, - tag); - } - /** * Used by parsing constructors in generated classes. @@ -377,30 +409,39 @@ public abstract class GeneratedMessageLite extends AbstractMessageLite /** Check if a singular extension is present. */ //@Override (Java 1.6 override semantics, but we must support 1.5) public final <Type> boolean hasExtension( - final GeneratedExtension<MessageType, Type> extension) { - verifyExtensionContainingType(extension); - return extensions.hasField(extension.descriptor); + final ExtensionLite<MessageType, Type> extension) { + GeneratedExtension<MessageType, Type> extensionLite = + checkIsLite(extension); + + verifyExtensionContainingType(extensionLite); + return extensions.hasField(extensionLite.descriptor); } /** Get the number of elements in a repeated extension. */ //@Override (Java 1.6 override semantics, but we must support 1.5) public final <Type> int getExtensionCount( - final GeneratedExtension<MessageType, List<Type>> extension) { - verifyExtensionContainingType(extension); - return extensions.getRepeatedFieldCount(extension.descriptor); + final ExtensionLite<MessageType, List<Type>> extension) { + GeneratedExtension<MessageType, List<Type>> extensionLite = + checkIsLite(extension); + + verifyExtensionContainingType(extensionLite); + return extensions.getRepeatedFieldCount(extensionLite.descriptor); } /** Get the value of an extension. */ //@Override (Java 1.6 override semantics, but we must support 1.5) @SuppressWarnings("unchecked") public final <Type> Type getExtension( - final GeneratedExtension<MessageType, Type> extension) { - verifyExtensionContainingType(extension); - final Object value = extensions.getField(extension.descriptor); + final ExtensionLite<MessageType, Type> extension) { + GeneratedExtension<MessageType, Type> extensionLite = + checkIsLite(extension); + + verifyExtensionContainingType(extensionLite); + final Object value = extensions.getField(extensionLite.descriptor); if (value == null) { - return extension.defaultValue; + return extensionLite.defaultValue; } else { - return (Type) extension.fromFieldSetType(value); + return (Type) extensionLite.fromFieldSetType(value); } } @@ -408,11 +449,14 @@ public abstract class GeneratedMessageLite extends AbstractMessageLite @SuppressWarnings("unchecked") //@Override (Java 1.6 override semantics, but we must support 1.5) public final <Type> Type getExtension( - final GeneratedExtension<MessageType, List<Type>> extension, + final ExtensionLite<MessageType, List<Type>> extension, final int index) { - verifyExtensionContainingType(extension); - return (Type) extension.singularFromFieldSetType( - extensions.getRepeatedField(extension.descriptor, index)); + GeneratedExtension<MessageType, List<Type>> extensionLite = + checkIsLite(extension); + + verifyExtensionContainingType(extensionLite); + return (Type) extensionLite.singularFromFieldSetType( + extensions.getRepeatedField(extensionLite.descriptor, index)); } // This is implemented here only to work around an apparent bug in the @@ -423,46 +467,57 @@ public abstract class GeneratedMessageLite extends AbstractMessageLite throw new UnsupportedOperationException( "This is supposed to be overridden by subclasses."); } - + /** Set the value of an extension. */ public final <Type> BuilderType setExtension( - final GeneratedExtension<MessageType, Type> extension, + final ExtensionLite<MessageType, Type> extension, final Type value) { - verifyExtensionContainingType(extension); + GeneratedExtension<MessageType, Type> extensionLite = + checkIsLite(extension); + + verifyExtensionContainingType(extensionLite); ensureExtensionsIsMutable(); - extensions.setField(extension.descriptor, - extension.toFieldSetType(value)); + extensions.setField(extensionLite.descriptor, + extensionLite.toFieldSetType(value)); return (BuilderType) this; } /** Set the value of one element of a repeated extension. */ public final <Type> BuilderType setExtension( - final GeneratedExtension<MessageType, List<Type>> extension, + final ExtensionLite<MessageType, List<Type>> extension, final int index, final Type value) { - verifyExtensionContainingType(extension); + GeneratedExtension<MessageType, List<Type>> extensionLite = + checkIsLite(extension); + + verifyExtensionContainingType(extensionLite); ensureExtensionsIsMutable(); - extensions.setRepeatedField(extension.descriptor, index, - extension.singularToFieldSetType(value)); + extensions.setRepeatedField(extensionLite.descriptor, index, + extensionLite.singularToFieldSetType(value)); return (BuilderType) this; } /** Append a value to a repeated extension. */ public final <Type> BuilderType addExtension( - final GeneratedExtension<MessageType, List<Type>> extension, + final ExtensionLite<MessageType, List<Type>> extension, final Type value) { - verifyExtensionContainingType(extension); + GeneratedExtension<MessageType, List<Type>> extensionLite = + checkIsLite(extension); + + verifyExtensionContainingType(extensionLite); ensureExtensionsIsMutable(); - extensions.addRepeatedField(extension.descriptor, - extension.singularToFieldSetType(value)); + extensions.addRepeatedField(extensionLite.descriptor, + extensionLite.singularToFieldSetType(value)); return (BuilderType) this; } /** Clear an extension. */ public final <Type> BuilderType clearExtension( - final GeneratedExtension<MessageType, ?> extension) { - verifyExtensionContainingType(extension); + final ExtensionLite<MessageType, ?> extension) { + GeneratedExtension<MessageType, ?> extensionLite = checkIsLite(extension); + + verifyExtensionContainingType(extensionLite); ensureExtensionsIsMutable(); - extensions.clearField(extension.descriptor); + extensions.clearField(extensionLite.descriptor); return (BuilderType) this; } @@ -471,44 +526,24 @@ public abstract class GeneratedMessageLite extends AbstractMessageLite return extensions.isInitialized(); } - /** - * Called by subclasses to parse an unknown field or an extension. - * @return {@code true} unless the tag is an end-group tag. - */ - @Override - protected boolean parseUnknownField( - CodedInputStream input, - CodedOutputStream unknownFieldsCodedOutput, - ExtensionRegistryLite extensionRegistry, - int tag) throws IOException { - ensureExtensionsIsMutable(); - return GeneratedMessageLite.parseUnknownField( - extensions, - getDefaultInstanceForType(), - input, - unknownFieldsCodedOutput, - extensionRegistry, - tag); - } - protected final void mergeExtensionFields(final MessageType other) { ensureExtensionsIsMutable(); extensions.mergeFrom(((ExtendableMessage) other).extensions); } } - // ----------------------------------------------------------------- + //----------------------------------------------------------------- /** - * Parse an unknown field or an extension. + * Parse an unknown field or an extension. For use by generated code only. * @return {@code true} unless the tag is an end-group tag. */ - private static <MessageType extends MessageLite> + protected static <MessageType extends MessageLite> boolean parseUnknownField( FieldSet<ExtensionDescriptor> extensions, MessageType defaultInstance, CodedInputStream input, - CodedOutputStream unknownFieldsCodedOutput, + UnknownFieldSetLite.Builder unknownFields, ExtensionRegistryLite extensionRegistry, int tag) throws IOException { int wireType = WireFormat.getTagWireType(tag); @@ -537,7 +572,7 @@ public abstract class GeneratedMessageLite extends AbstractMessageLite } if (unknown) { // Unknown field or wrong wire type. Skip. - return input.skipField(tag, unknownFieldsCodedOutput); + return unknownFields.mergeFieldFrom(tag, input); } if (packed) { @@ -599,8 +634,7 @@ public abstract class GeneratedMessageLite extends AbstractMessageLite // If the number isn't recognized as a valid value for this enum, // write it to unknown fields object. if (value == null) { - unknownFieldsCodedOutput.writeRawVarint32(tag); - unknownFieldsCodedOutput.writeUInt32NoTag(rawValue); + unknownFields.mergeVarintField(fieldNumber, rawValue); return true; } break; @@ -768,7 +802,8 @@ public abstract class GeneratedMessageLite extends AbstractMessageLite * this type as parameters to extension accessors and ExtensionRegistry.add(). */ public static class GeneratedExtension< - ContainingType extends MessageLite, Type> { + ContainingType extends MessageLite, Type> + extends ExtensionLite<ContainingType, Type> { /** * Create a new isntance with the given parameters. @@ -888,6 +923,18 @@ public abstract class GeneratedMessageLite extends AbstractMessageLite return value; } } + + public FieldType getLiteType() { + return descriptor.getLiteType(); + } + + public boolean isRepeated() { + return descriptor.isRepeated; + } + + public Type getDefaultValue() { + return defaultValue; + } } /** @@ -897,8 +944,8 @@ public abstract class GeneratedMessageLite extends AbstractMessageLite static final class SerializedForm implements Serializable { private static final long serialVersionUID = 0L; - private String messageClassName; - private byte[] asBytes; + private final String messageClassName; + private final byte[] asBytes; /** * Creates the serialized form by calling {@link com.google.protobuf.MessageLite#toByteArray}. @@ -918,19 +965,17 @@ public abstract class GeneratedMessageLite extends AbstractMessageLite protected Object readResolve() throws ObjectStreamException { try { Class messageClass = Class.forName(messageClassName); - Method newBuilder = messageClass.getMethod("newBuilder"); - MessageLite.Builder builder = - (MessageLite.Builder) newBuilder.invoke(null); - builder.mergeFrom(asBytes); - return builder.buildPartial(); + Parser<?> parser = + (Parser<?>) messageClass.getField("PARSER").get(null); + return parser.parsePartialFrom(asBytes); } catch (ClassNotFoundException e) { throw new RuntimeException("Unable to find proto buffer class", e); - } catch (NoSuchMethodException e) { - throw new RuntimeException("Unable to find newBuilder method", e); + } catch (NoSuchFieldException e) { + throw new RuntimeException("Unable to find PARSER", e); + } catch (SecurityException e) { + throw new RuntimeException("Unable to call PARSER", e); } catch (IllegalAccessException e) { - throw new RuntimeException("Unable to call newBuilder method", e); - } catch (InvocationTargetException e) { - throw new RuntimeException("Error calling newBuilder", e.getCause()); + throw new RuntimeException("Unable to call parseFrom method", e); } catch (InvalidProtocolBufferException e) { throw new RuntimeException("Unable to understand proto buffer", e); } @@ -946,4 +991,18 @@ public abstract class GeneratedMessageLite extends AbstractMessageLite protected Object writeReplace() throws ObjectStreamException { return new SerializedForm(this); } + + /** + * Checks that the {@link Extension} is Lite and returns it as a + * {@link GeneratedExtension}. + */ + private static <MessageType extends ExtendableMessage<MessageType>, T> + GeneratedExtension<MessageType, T> checkIsLite( + ExtensionLite<MessageType, T> extension) { + if (!extension.isLite()) { + throw new IllegalArgumentException("Expected a lite extension."); + } + + return (GeneratedExtension<MessageType, T>) extension; + } } |