| // Protocol Buffers - Google's data interchange format |
| // Copyright 2008 Google Inc. All rights reserved. |
| // http://code.google.com/p/protobuf/ |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following disclaimer |
| // in the documentation and/or other materials provided with the |
| // distribution. |
| // * Neither the name of Google Inc. nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| package com.google.protobuf; |
| |
| import java.io.IOException; |
| import java.io.ObjectStreamException; |
| import java.io.Serializable; |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.util.Collections; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| |
| /** |
| * Lite version of {@link GeneratedMessage}. |
| * |
| * @author kenton@google.com Kenton Varda |
| */ |
| public abstract class GeneratedMessageLite extends AbstractMessageLite |
| implements Serializable { |
| private static final long serialVersionUID = 1L; |
| |
| protected GeneratedMessageLite() { |
| } |
| |
| protected GeneratedMessageLite(Builder builder) { |
| } |
| |
| @SuppressWarnings("unchecked") |
| public abstract static class Builder<MessageType extends GeneratedMessageLite, |
| BuilderType extends Builder> |
| extends AbstractMessageLite.Builder<BuilderType> { |
| protected Builder() {} |
| |
| //@Override (Java 1.6 override semantics, but we must support 1.5) |
| public BuilderType clear() { |
| 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 |
| public BuilderType clone() { |
| throw new UnsupportedOperationException( |
| "This is supposed to be overridden by subclasses."); |
| } |
| |
| /** All subclasses implement this. */ |
| public abstract BuilderType mergeFrom(MessageType message); |
| |
| // Defined here for return type covariance. |
| public abstract MessageType getDefaultInstanceForType(); |
| |
| /** |
| * Called by subclasses to parse an unknown field. |
| * @return {@code true} unless the tag is an end-group tag. |
| */ |
| protected boolean parseUnknownField( |
| final CodedInputStream input, |
| final ExtensionRegistryLite extensionRegistry, |
| final int tag) throws IOException { |
| return input.skipField(tag); |
| } |
| } |
| |
| // ================================================================= |
| // Extensions-related stuff |
| |
| /** |
| * Lite equivalent of {@link com.google.protobuf.GeneratedMessage.ExtendableMessageOrBuilder}. |
| */ |
| public interface ExtendableMessageOrBuilder< |
| MessageType extends ExtendableMessage> extends MessageLiteOrBuilder { |
| |
| /** Check if a singular extension is present. */ |
| <Type> boolean hasExtension( |
| GeneratedExtension<MessageType, Type> extension); |
| |
| /** Get the number of elements in a repeated extension. */ |
| <Type> int getExtensionCount( |
| GeneratedExtension<MessageType, List<Type>> extension); |
| |
| /** Get the value of an extension. */ |
| <Type> Type getExtension(GeneratedExtension<MessageType, Type> extension); |
| |
| /** Get one element of a repeated extension. */ |
| <Type> Type getExtension( |
| GeneratedExtension<MessageType, List<Type>> extension, |
| int index); |
| } |
| |
| /** |
| * Lite equivalent of {@link GeneratedMessage.ExtendableMessage}. |
| */ |
| public abstract static class ExtendableMessage< |
| MessageType extends ExtendableMessage<MessageType>> |
| extends GeneratedMessageLite |
| implements ExtendableMessageOrBuilder<MessageType> { |
| |
| private final FieldSet<ExtensionDescriptor> extensions; |
| |
| protected ExtendableMessage() { |
| this.extensions = FieldSet.newFieldSet(); |
| } |
| |
| protected ExtendableMessage(ExtendableBuilder<MessageType, ?> builder) { |
| this.extensions = builder.buildExtensions(); |
| } |
| |
| private void verifyExtensionContainingType( |
| final GeneratedExtension<MessageType, ?> extension) { |
| if (extension.getContainingTypeDefaultInstance() != |
| getDefaultInstanceForType()) { |
| // This can only happen if someone uses unchecked operations. |
| throw new IllegalArgumentException( |
| "This extension is for a different message type. Please make " + |
| "sure that you are not suppressing any generics type warnings."); |
| } |
| } |
| |
| /** 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); |
| } |
| |
| /** 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); |
| } |
| |
| /** 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); |
| if (value == null) { |
| return extension.defaultValue; |
| } else { |
| return (Type) value; |
| } |
| } |
| |
| /** Get one element of a repeated extension. */ |
| //@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 int index) { |
| verifyExtensionContainingType(extension); |
| return (Type) extensions.getRepeatedField(extension.descriptor, index); |
| } |
| |
| /** Called by subclasses to check if all extensions are initialized. */ |
| protected boolean extensionsAreInitialized() { |
| return extensions.isInitialized(); |
| } |
| |
| /** |
| * 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<Map.Entry<ExtensionDescriptor, Object>> iter = |
| extensions.iterator(); |
| private Map.Entry<ExtensionDescriptor, Object> next; |
| private final boolean messageSetWireFormat; |
| |
| private ExtensionWriter(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) { |
| ExtensionDescriptor extension = next.getKey(); |
| if (messageSetWireFormat && extension.getLiteJavaType() == |
| WireFormat.JavaType.MESSAGE && |
| !extension.isRepeated()) { |
| output.writeMessageSetExtension(extension.getNumber(), |
| (MessageLite) next.getValue()); |
| } else { |
| FieldSet.writeField(extension, 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(); |
| } |
| } |
| |
| /** |
| * Lite equivalent of {@link GeneratedMessage.ExtendableBuilder}. |
| */ |
| @SuppressWarnings("unchecked") |
| public abstract static class ExtendableBuilder< |
| MessageType extends ExtendableMessage<MessageType>, |
| BuilderType extends ExtendableBuilder<MessageType, BuilderType>> |
| extends Builder<MessageType, BuilderType> |
| implements ExtendableMessageOrBuilder<MessageType> { |
| protected ExtendableBuilder() {} |
| |
| private FieldSet<ExtensionDescriptor> extensions = FieldSet.emptySet(); |
| private boolean extensionsIsMutable; |
| |
| @Override |
| public BuilderType clear() { |
| extensions.clear(); |
| extensionsIsMutable = false; |
| return super.clear(); |
| } |
| |
| private void ensureExtensionsIsMutable() { |
| if (!extensionsIsMutable) { |
| extensions = extensions.clone(); |
| extensionsIsMutable = true; |
| } |
| } |
| |
| /** |
| * Called by the build code path to create a copy of the extensions for |
| * building the message. |
| */ |
| private FieldSet<ExtensionDescriptor> buildExtensions() { |
| extensions.makeImmutable(); |
| extensionsIsMutable = false; |
| return extensions; |
| } |
| |
| private void verifyExtensionContainingType( |
| final GeneratedExtension<MessageType, ?> extension) { |
| if (extension.getContainingTypeDefaultInstance() != |
| getDefaultInstanceForType()) { |
| // This can only happen if someone uses unchecked operations. |
| throw new IllegalArgumentException( |
| "This extension is for a different message type. Please make " + |
| "sure that you are not suppressing any generics type warnings."); |
| } |
| } |
| |
| /** 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); |
| } |
| |
| /** 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); |
| } |
| |
| /** 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); |
| if (value == null) { |
| return extension.defaultValue; |
| } else { |
| return (Type) value; |
| } |
| } |
| |
| /** Get one element of a repeated extension. */ |
| @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 int index) { |
| verifyExtensionContainingType(extension); |
| return (Type) extensions.getRepeatedField(extension.descriptor, index); |
| } |
| |
| // 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 |
| public BuilderType clone() { |
| 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 Type value) { |
| verifyExtensionContainingType(extension); |
| ensureExtensionsIsMutable(); |
| extensions.setField(extension.descriptor, 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 int index, final Type value) { |
| verifyExtensionContainingType(extension); |
| ensureExtensionsIsMutable(); |
| extensions.setRepeatedField(extension.descriptor, index, value); |
| return (BuilderType) this; |
| } |
| |
| /** Append a value to a repeated extension. */ |
| public final <Type> BuilderType addExtension( |
| final GeneratedExtension<MessageType, List<Type>> extension, |
| final Type value) { |
| verifyExtensionContainingType(extension); |
| ensureExtensionsIsMutable(); |
| extensions.addRepeatedField(extension.descriptor, value); |
| return (BuilderType) this; |
| } |
| |
| /** Clear an extension. */ |
| public final <Type> BuilderType clearExtension( |
| final GeneratedExtension<MessageType, ?> extension) { |
| verifyExtensionContainingType(extension); |
| ensureExtensionsIsMutable(); |
| extensions.clearField(extension.descriptor); |
| return (BuilderType) this; |
| } |
| |
| /** Called by subclasses to check if all extensions are initialized. */ |
| protected boolean extensionsAreInitialized() { |
| 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( |
| final CodedInputStream input, |
| final ExtensionRegistryLite extensionRegistry, |
| final int tag) throws IOException { |
| final int wireType = WireFormat.getTagWireType(tag); |
| final int fieldNumber = WireFormat.getTagFieldNumber(tag); |
| |
| final GeneratedExtension<MessageType, ?> extension = |
| extensionRegistry.findLiteExtensionByNumber( |
| getDefaultInstanceForType(), fieldNumber); |
| |
| boolean unknown = false; |
| boolean packed = false; |
| if (extension == null) { |
| unknown = true; // Unknown field. |
| } else if (wireType == FieldSet.getWireFormatForFieldType( |
| extension.descriptor.getLiteType(), |
| false /* isPacked */)) { |
| packed = false; // Normal, unpacked value. |
| } else if (extension.descriptor.isRepeated && |
| extension.descriptor.type.isPackable() && |
| wireType == FieldSet.getWireFormatForFieldType( |
| extension.descriptor.getLiteType(), |
| true /* isPacked */)) { |
| packed = true; // Packed value. |
| } else { |
| unknown = true; // Wrong wire type. |
| } |
| |
| if (unknown) { // Unknown field or wrong wire type. Skip. |
| return input.skipField(tag); |
| } |
| |
| if (packed) { |
| final int length = input.readRawVarint32(); |
| final int limit = input.pushLimit(length); |
| if (extension.descriptor.getLiteType() == WireFormat.FieldType.ENUM) { |
| while (input.getBytesUntilLimit() > 0) { |
| final int rawValue = input.readEnum(); |
| final Object value = |
| extension.descriptor.getEnumType().findValueByNumber(rawValue); |
| if (value == null) { |
| // If the number isn't recognized as a valid value for this |
| // enum, drop it (don't even add it to unknownFields). |
| return true; |
| } |
| ensureExtensionsIsMutable(); |
| extensions.addRepeatedField(extension.descriptor, value); |
| } |
| } else { |
| while (input.getBytesUntilLimit() > 0) { |
| final Object value = |
| FieldSet.readPrimitiveField(input, |
| extension.descriptor.getLiteType()); |
| ensureExtensionsIsMutable(); |
| extensions.addRepeatedField(extension.descriptor, value); |
| } |
| } |
| input.popLimit(limit); |
| } else { |
| final Object value; |
| switch (extension.descriptor.getLiteJavaType()) { |
| case MESSAGE: { |
| MessageLite.Builder subBuilder = null; |
| if (!extension.descriptor.isRepeated()) { |
| MessageLite existingValue = |
| (MessageLite) extensions.getField(extension.descriptor); |
| if (existingValue != null) { |
| subBuilder = existingValue.toBuilder(); |
| } |
| } |
| if (subBuilder == null) { |
| subBuilder = extension.messageDefaultInstance.newBuilderForType(); |
| } |
| if (extension.descriptor.getLiteType() == |
| WireFormat.FieldType.GROUP) { |
| input.readGroup(extension.getNumber(), |
| subBuilder, extensionRegistry); |
| } else { |
| input.readMessage(subBuilder, extensionRegistry); |
| } |
| value = subBuilder.build(); |
| break; |
| } |
| case ENUM: |
| final int rawValue = input.readEnum(); |
| value = extension.descriptor.getEnumType() |
| .findValueByNumber(rawValue); |
| // If the number isn't recognized as a valid value for this enum, |
| // drop it. |
| if (value == null) { |
| return true; |
| } |
| break; |
| default: |
| value = FieldSet.readPrimitiveField(input, |
| extension.descriptor.getLiteType()); |
| break; |
| } |
| |
| if (extension.descriptor.isRepeated()) { |
| ensureExtensionsIsMutable(); |
| extensions.addRepeatedField(extension.descriptor, value); |
| } else { |
| ensureExtensionsIsMutable(); |
| extensions.setField(extension.descriptor, value); |
| } |
| } |
| |
| return true; |
| } |
| |
| protected final void mergeExtensionFields(final MessageType other) { |
| ensureExtensionsIsMutable(); |
| extensions.mergeFrom(((ExtendableMessage) other).extensions); |
| } |
| } |
| |
| // ----------------------------------------------------------------- |
| |
| /** For use by generated code only. */ |
| public static <ContainingType extends MessageLite, Type> |
| GeneratedExtension<ContainingType, Type> |
| newSingularGeneratedExtension( |
| final ContainingType containingTypeDefaultInstance, |
| final Type defaultValue, |
| final MessageLite messageDefaultInstance, |
| final Internal.EnumLiteMap<?> enumTypeMap, |
| final int number, |
| final WireFormat.FieldType type) { |
| return new GeneratedExtension<ContainingType, Type>( |
| containingTypeDefaultInstance, |
| defaultValue, |
| messageDefaultInstance, |
| new ExtensionDescriptor(enumTypeMap, number, type, |
| false /* isRepeated */, |
| false /* isPacked */)); |
| } |
| |
| /** For use by generated code only. */ |
| public static <ContainingType extends MessageLite, Type> |
| GeneratedExtension<ContainingType, Type> |
| newRepeatedGeneratedExtension( |
| final ContainingType containingTypeDefaultInstance, |
| final MessageLite messageDefaultInstance, |
| final Internal.EnumLiteMap<?> enumTypeMap, |
| final int number, |
| final WireFormat.FieldType type, |
| final boolean isPacked) { |
| @SuppressWarnings("unchecked") // Subclasses ensure Type is a List |
| Type emptyList = (Type) Collections.emptyList(); |
| return new GeneratedExtension<ContainingType, Type>( |
| containingTypeDefaultInstance, |
| emptyList, |
| messageDefaultInstance, |
| new ExtensionDescriptor( |
| enumTypeMap, number, type, true /* isRepeated */, isPacked)); |
| } |
| |
| private static final class ExtensionDescriptor |
| implements FieldSet.FieldDescriptorLite< |
| ExtensionDescriptor> { |
| private ExtensionDescriptor( |
| final Internal.EnumLiteMap<?> enumTypeMap, |
| final int number, |
| final WireFormat.FieldType type, |
| final boolean isRepeated, |
| final boolean isPacked) { |
| this.enumTypeMap = enumTypeMap; |
| this.number = number; |
| this.type = type; |
| this.isRepeated = isRepeated; |
| this.isPacked = isPacked; |
| } |
| |
| private final Internal.EnumLiteMap<?> enumTypeMap; |
| private final int number; |
| private final WireFormat.FieldType type; |
| private final boolean isRepeated; |
| private final boolean isPacked; |
| |
| public int getNumber() { |
| return number; |
| } |
| |
| public WireFormat.FieldType getLiteType() { |
| return type; |
| } |
| |
| public WireFormat.JavaType getLiteJavaType() { |
| return type.getJavaType(); |
| } |
| |
| public boolean isRepeated() { |
| return isRepeated; |
| } |
| |
| public boolean isPacked() { |
| return isPacked; |
| } |
| |
| public Internal.EnumLiteMap<?> getEnumType() { |
| return enumTypeMap; |
| } |
| |
| @SuppressWarnings("unchecked") |
| public MessageLite.Builder internalMergeFrom( |
| MessageLite.Builder to, MessageLite from) { |
| return ((Builder) to).mergeFrom((GeneratedMessageLite) from); |
| } |
| |
| public int compareTo(ExtensionDescriptor other) { |
| return number - other.number; |
| } |
| } |
| |
| /** |
| * Lite equivalent to {@link GeneratedMessage.GeneratedExtension}. |
| * |
| * Users should ignore the contents of this class and only use objects of |
| * this type as parameters to extension accessors and ExtensionRegistry.add(). |
| */ |
| public static final class GeneratedExtension< |
| ContainingType extends MessageLite, Type> { |
| |
| private GeneratedExtension( |
| final ContainingType containingTypeDefaultInstance, |
| final Type defaultValue, |
| final MessageLite messageDefaultInstance, |
| final ExtensionDescriptor descriptor) { |
| // Defensive checks to verify the correct initialization order of |
| // GeneratedExtensions and their related GeneratedMessages. |
| if (containingTypeDefaultInstance == null) { |
| throw new IllegalArgumentException( |
| "Null containingTypeDefaultInstance"); |
| } |
| if (descriptor.getLiteType() == WireFormat.FieldType.MESSAGE && |
| messageDefaultInstance == null) { |
| throw new IllegalArgumentException( |
| "Null messageDefaultInstance"); |
| } |
| this.containingTypeDefaultInstance = containingTypeDefaultInstance; |
| this.defaultValue = defaultValue; |
| this.messageDefaultInstance = messageDefaultInstance; |
| this.descriptor = descriptor; |
| } |
| |
| private final ContainingType containingTypeDefaultInstance; |
| private final Type defaultValue; |
| private final MessageLite messageDefaultInstance; |
| private final ExtensionDescriptor descriptor; |
| |
| /** |
| * Default instance of the type being extended, used to identify that type. |
| */ |
| public ContainingType getContainingTypeDefaultInstance() { |
| return containingTypeDefaultInstance; |
| } |
| |
| /** Get the field number. */ |
| public int getNumber() { |
| return descriptor.getNumber(); |
| } |
| |
| /** |
| * If the extension is an embedded message, this is the default instance of |
| * that type. |
| */ |
| public MessageLite getMessageDefaultInstance() { |
| return messageDefaultInstance; |
| } |
| } |
| |
| /** |
| * A serialized (serializable) form of the generated message. Stores the |
| * message as a class name and a byte array. |
| */ |
| static final class SerializedForm implements Serializable { |
| private static final long serialVersionUID = 0L; |
| |
| private String messageClassName; |
| private byte[] asBytes; |
| |
| /** |
| * Creates the serialized form by calling {@link com.google.protobuf.MessageLite#toByteArray}. |
| * @param regularForm the message to serialize |
| */ |
| SerializedForm(MessageLite regularForm) { |
| messageClassName = regularForm.getClass().getName(); |
| asBytes = regularForm.toByteArray(); |
| } |
| |
| /** |
| * When read from an ObjectInputStream, this method converts this object |
| * back to the regular form. Part of Java's serialization magic. |
| * @return a GeneratedMessage of the type that was serialized |
| */ |
| @SuppressWarnings("unchecked") |
| 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(); |
| } 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 (IllegalAccessException e) { |
| throw new RuntimeException("Unable to call newBuilder method", e); |
| } catch (InvocationTargetException e) { |
| throw new RuntimeException("Error calling newBuilder", e.getCause()); |
| } catch (InvalidProtocolBufferException e) { |
| throw new RuntimeException("Unable to understand proto buffer", e); |
| } |
| } |
| } |
| |
| /** |
| * Replaces this object in the output stream with a serialized form. |
| * Part of Java's serialization magic. Generated sub-classes must override |
| * this method by calling <code>return super.writeReplace();</code> |
| * @return a SerializedForm of this message |
| */ |
| protected Object writeReplace() throws ObjectStreamException { |
| return new SerializedForm(this); |
| } |
| } |
