java/src/main/java/com/google/protobuf/FieldSet.java - platform/external/protobuf-javalite - Gitiles

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.
 // http://code.google.com/p/protobuf/
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 package com.google.protobuf;

 import com.google.protobuf.Descriptors.Descriptor;
 import com.google.protobuf.Descriptors.FieldDescriptor;
 import com.google.protobuf.Descriptors.EnumValueDescriptor;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.TreeMap;
 import java.util.List;
 import java.util.Map;

 /**
  * A class which represents an arbitrary set of fields of some message type.
  * This is used to implement {@link DynamicMessage}, and also to represent
  * extensions in {@link GeneratedMessage}.  This class is package-private,
  * since outside users should probably be using {@link DynamicMessage}.
  *
  * @author kenton@google.com Kenton Varda
  */
 final class FieldSet {
   private Map<FieldDescriptor, Object> fields;

   /** Construct a new FieldSet. */
   private FieldSet() {
     // Use a TreeMap because fields need to be in canonical order when
     // serializing.
     this.fields = new TreeMap<FieldDescriptor, Object>();
   }

   /**
    * Construct a new FieldSet with the given map.  This is only used by
    * DEFAULT_INSTANCE, to pass in an immutable empty map.
    */
   private FieldSet(Map<FieldDescriptor, Object> fields) {
     this.fields = fields;
   }

   /** Construct a new FieldSet. */
   public static FieldSet newFieldSet() {
     return new FieldSet();
   }

   /** Get an immutable empty FieldSet. */
   public static FieldSet emptySet() {
     return DEFAULT_INSTANCE;
   }
   private static final FieldSet DEFAULT_INSTANCE =
     new FieldSet(Collections.<FieldDescriptor, Object>emptyMap());

   /** Make this FieldSet immutable from this point forward. */
   @SuppressWarnings("unchecked")
   public void makeImmutable() {
     for (Map.Entry<FieldDescriptor, Object> entry: fields.entrySet()) {
       if (entry.getKey().isRepeated()) {
         List value = (List)entry.getValue();
         entry.setValue(Collections.unmodifiableList(value));
       }
     }
     fields = Collections.unmodifiableMap(fields);
   }

   // =================================================================

   /** See {@link Message.Builder#clear()}. */
   public void clear() {
     fields.clear();
   }

   /** See {@link Message#getAllFields()}. */
   public Map<Descriptors.FieldDescriptor, Object> getAllFields() {
     return Collections.unmodifiableMap(fields);
   }

   /**
    * Get an interator to the field map.  This iterator should not be leaked
    * out of the protobuf library as it is not protected from mutation.
    */
   public Iterator<Map.Entry<Descriptors.FieldDescriptor, Object>> iterator() {
     return fields.entrySet().iterator();
   }

   /** See {@link Message#hasField(Descriptors.FieldDescriptor)}. */
   public boolean hasField(Descriptors.FieldDescriptor field) {
     if (field.isRepeated()) {
       throw new IllegalArgumentException(
         "hasField() can only be called on non-repeated fields.");
     }

     return fields.containsKey(field);
   }

   /**
    * See {@link Message#getField(Descriptors.FieldDescriptor)}.  This method
    * returns {@code null} if the field is a singular message type and is not
    * set; in this case it is up to the caller to fetch the message's default
    * instance.
    */
   public Object getField(Descriptors.FieldDescriptor field) {
     Object result = fields.get(field);
     if (result == null) {
       if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
         if (field.isRepeated()) {
           return Collections.emptyList();
         } else {
           return null;
         }
       } else {
         return field.getDefaultValue();
       }
     } else {
       return result;
     }
   }

   /** See {@link Message.Builder#setField(Descriptors.FieldDescriptor,Object)}. */
   @SuppressWarnings("unchecked")
   public void setField(Descriptors.FieldDescriptor field, Object value) {
     if (field.isRepeated()) {
       if (!(value instanceof List)) {
         throw new IllegalArgumentException(
           "Wrong object type used with protocol message reflection.");
       }

       // Wrap the contents in a new list so that the caller cannot change
       // the list's contents after setting it.
       List newList = new ArrayList();
       newList.addAll((List)value);
       for (Object element : newList) {
         verifyType(field, element);
       }
       value = newList;
     } else {
       verifyType(field, value);
     }

     fields.put(field, value);
   }

   /** See {@link Message.Builder#clearField(Descriptors.FieldDescriptor)}. */
   public void clearField(Descriptors.FieldDescriptor field) {
     fields.remove(field);
   }

   /** See {@link Message#getRepeatedFieldCount(Descriptors.FieldDescriptor)}. */
   public int getRepeatedFieldCount(Descriptors.FieldDescriptor field) {
     if (!field.isRepeated()) {
       throw new IllegalArgumentException(
         "getRepeatedFieldCount() can only be called on repeated fields.");
     }

     return ((List)getField(field)).size();
   }

   /** See {@link Message#getRepeatedField(Descriptors.FieldDescriptor,int)}. */
   public Object getRepeatedField(Descriptors.FieldDescriptor field, int index) {
     if (!field.isRepeated()) {
       throw new IllegalArgumentException(
         "getRepeatedField() can only be called on repeated fields.");
     }

     return ((List)getField(field)).get(index);
   }

   /** See {@link Message.Builder#setRepeatedField(Descriptors.FieldDescriptor,int,Object)}. */
   @SuppressWarnings("unchecked")
   public void setRepeatedField(Descriptors.FieldDescriptor field, int index,
                                Object value) {
     if (!field.isRepeated()) {
       throw new IllegalArgumentException(
         "setRepeatedField() can only be called on repeated fields.");
     }

     verifyType(field, value);

     List list = (List)fields.get(field);
     if (list == null) {
       throw new IndexOutOfBoundsException();
     }

     list.set(index, value);
   }

   /** See {@link Message.Builder#addRepeatedField(Descriptors.FieldDescriptor,Object)}. */
   @SuppressWarnings("unchecked")
   public void addRepeatedField(Descriptors.FieldDescriptor field,
                                Object value) {
     if (!field.isRepeated()) {
       throw new IllegalArgumentException(
         "setRepeatedField() can only be called on repeated fields.");
     }

     verifyType(field, value);

     List list = (List)fields.get(field);
     if (list == null) {
       list = new ArrayList();
       fields.put(field, list);
     }

     list.add(value);
   }

   /**
    * Verifies that the given object is of the correct type to be a valid
    * value for the given field.  (For repeated fields, this checks if the
    * object is the right type to be one element of the field.)
    *
    * @throws IllegalArgumentException The value is not of the right type.
    */
   private void verifyType(FieldDescriptor field, Object value) {
     boolean isValid = false;
     switch (field.getJavaType()) {
       case INT:          isValid = value instanceof Integer   ; break;
       case LONG:         isValid = value instanceof Long      ; break;
       case FLOAT:        isValid = value instanceof Float     ; break;
       case DOUBLE:       isValid = value instanceof Double    ; break;
       case BOOLEAN:      isValid = value instanceof Boolean   ; break;
       case STRING:       isValid = value instanceof String    ; break;
       case BYTE_STRING:  isValid = value instanceof ByteString; break;
       case ENUM:
         isValid = value instanceof EnumValueDescriptor &&
           ((EnumValueDescriptor)value).getType() == field.getEnumType();
         break;
       case MESSAGE:
         isValid = value instanceof Message &&
           ((Message)value).getDescriptorForType() == field.getMessageType();
         break;
     }

     if (!isValid) {
       // When chaining calls to setField(), it can be hard to tell from
       // the stack trace which exact call failed, since the whole chain is
       // considered one line of code.  So, let's make sure to include the
       // field name and other useful info in the exception.
       throw new IllegalArgumentException(
         "Wrong object type used with protocol message reflection.  " +
         "Message type \"" + field.getContainingType().getFullName() +
         "\", field \"" +
         (field.isExtension() ? field.getFullName() : field.getName()) +
         "\", value was type \"" + value.getClass().getName() + "\".");
     }
   }

   // =================================================================
   // Parsing and serialization

   /**
    * See {@link Message#isInitialized()}.  Note:  Since {@code FieldSet}
    * itself does not have any way of knowing about required fields that
    * aren't actually present in the set, it is up to the caller to check
    * that all required fields are present.
    */
   @SuppressWarnings("unchecked")
   public boolean isInitialized() {
     for (Map.Entry<FieldDescriptor, Object> entry : fields.entrySet()) {
       FieldDescriptor field = entry.getKey();
       if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
         if (field.isRepeated()) {
           for (Message element : (List<Message>) entry.getValue()) {
             if (!element.isInitialized()) {
               return false;
             }
           }
         } else {
           if (!((Message) entry.getValue()).isInitialized()) {
             return false;
           }
         }
       }
     }

     return true;
   }

   /**
    * Like {@link #isInitialized()}, but also checks for the presence of
    * all required fields in the given type.
    */
   @SuppressWarnings("unchecked")
   public boolean isInitialized(Descriptor type) {
     // Check that all required fields are present.
     for (FieldDescriptor field : type.getFields()) {
       if (field.isRequired()) {
         if (!hasField(field)) {
           return false;
         }
       }
     }

     // Check that embedded messages are initialized.
     return isInitialized();
   }

   /** See {@link Message.Builder#mergeFrom(Message)}. */
   @SuppressWarnings("unchecked")
   public void mergeFrom(Message other) {
     // Note:  We don't attempt to verify that other's fields have valid
     //   types.  Doing so would be a losing battle.  We'd have to verify
     //   all sub-messages as well, and we'd have to make copies of all of
     //   them to insure that they don't change after verification (since
     //   the Message interface itself cannot enforce immutability of
     //   implementations).
     // TODO(kenton):  Provide a function somewhere called makeDeepCopy()
     //   which allows people to make secure deep copies of messages.

     for (Map.Entry<FieldDescriptor, Object> entry :
          other.getAllFields().entrySet()) {
       FieldDescriptor field = entry.getKey();
       if (field.isRepeated()) {
         List existingValue = (List)fields.get(field);
         if (existingValue == null) {
           existingValue = new ArrayList();
           fields.put(field, existingValue);
         }
         existingValue.addAll((List)entry.getValue());
       } else if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
         Message existingValue = (Message)fields.get(field);
         if (existingValue == null) {
           setField(field, entry.getValue());
         } else {
           setField(field,
             existingValue.newBuilderForType()
               .mergeFrom(existingValue)
               .mergeFrom((Message)entry.getValue())
               .build());
         }
       } else {
         setField(field, entry.getValue());
       }
     }
   }

   /**
    * Like {@link #mergeFrom(Message)}, but merges from another {@link FieldSet}.
    */
   @SuppressWarnings("unchecked")
   public void mergeFrom(FieldSet other) {
     for (Map.Entry<FieldDescriptor, Object> entry : other.fields.entrySet()) {
       FieldDescriptor field = entry.getKey();
       Object value = entry.getValue();

       if (field.isRepeated()) {
         List existingValue = (List)fields.get(field);
         if (existingValue == null) {
           existingValue = new ArrayList();
           fields.put(field, existingValue);
         }
         existingValue.addAll((List)value);
       } else if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
         Message existingValue = (Message)fields.get(field);
         if (existingValue == null) {
           setField(field, value);
         } else {
           setField(field,
             existingValue.newBuilderForType()
               .mergeFrom(existingValue)
               .mergeFrom((Message)value)
               .build());
         }
       } else {
         setField(field, value);
       }
     }
   }

   // TODO(kenton):  Move parsing code into AbstractMessage, since it no longer
   //   uses any special knowledge from FieldSet.

   /**
    * See {@link Message.Builder#mergeFrom(CodedInputStream)}.
    * @param builder The {@code Builder} for the target message.
    */
   public static void mergeFrom(CodedInputStream input,
                                UnknownFieldSet.Builder unknownFields,
                                ExtensionRegistry extensionRegistry,
                                Message.Builder builder)
                                throws java.io.IOException {
     while (true) {
       int tag = input.readTag();
       if (tag == 0) {
         break;
       }

       if (!mergeFieldFrom(input, unknownFields, extensionRegistry,
                           builder, tag)) {
         // end group tag
         break;
       }
     }
   }

   /**
    * Like {@link #mergeFrom(CodedInputStream, UnknownFieldSet.Builder,
    * ExtensionRegistry, Message.Builder)}, but parses a single field.
    * @param tag The tag, which should have already been read.
    * @return {@code true} unless the tag is an end-group tag.
    */
   @SuppressWarnings("unchecked")
   public static boolean mergeFieldFrom(
       CodedInputStream input,
       UnknownFieldSet.Builder unknownFields,
       ExtensionRegistry extensionRegistry,
       Message.Builder builder,
       int tag) throws java.io.IOException {
     Descriptor type = builder.getDescriptorForType();

     if (type.getOptions().getMessageSetWireFormat() &&
         tag == WireFormat.MESSAGE_SET_ITEM_TAG) {
       mergeMessageSetExtensionFromCodedStream(
         input, unknownFields, extensionRegistry, builder);
       return true;
     }

     int wireType = WireFormat.getTagWireType(tag);
     int fieldNumber = WireFormat.getTagFieldNumber(tag);

     FieldDescriptor field;
     Message defaultInstance = null;

     if (type.isExtensionNumber(fieldNumber)) {
       ExtensionRegistry.ExtensionInfo extension =
         extensionRegistry.findExtensionByNumber(type, fieldNumber);
       if (extension == null) {
         field = null;
       } else {
         field = extension.descriptor;
         defaultInstance = extension.defaultInstance;
       }
     } else {
       field = type.findFieldByNumber(fieldNumber);
     }

     if (field == null ||
         wireType != WireFormat.getWireFormatForFieldType(field.getType())) {
       // Unknown field or wrong wire type.  Skip.
       return unknownFields.mergeFieldFrom(tag, input);
     } else {
       Object value;
       switch (field.getType()) {
         case GROUP: {
           Message.Builder subBuilder;
           if (defaultInstance != null) {
             subBuilder = defaultInstance.newBuilderForType();
           } else {
             subBuilder = builder.newBuilderForField(field);
           }
           if (!field.isRepeated()) {
             subBuilder.mergeFrom((Message) builder.getField(field));
           }
           input.readGroup(field.getNumber(), subBuilder, extensionRegistry);
           value = subBuilder.build();
           break;
         }
         case MESSAGE: {
           Message.Builder subBuilder;
           if (defaultInstance != null) {
             subBuilder = defaultInstance.newBuilderForType();
           } else {
             subBuilder = builder.newBuilderForField(field);
           }
           if (!field.isRepeated()) {
             subBuilder.mergeFrom((Message) builder.getField(field));
           }
           input.readMessage(subBuilder, extensionRegistry);
           value = subBuilder.build();
           break;
         }
         case ENUM: {
           int rawValue = input.readEnum();
           value = field.getEnumType().findValueByNumber(rawValue);
           // If the number isn't recognized as a valid value for this enum,
           // drop it.
           if (value == null) {
             unknownFields.mergeVarintField(fieldNumber, rawValue);
             return true;
           }
           break;
         }
         default:
           value = input.readPrimitiveField(field.getType());
           break;
       }

       if (field.isRepeated()) {
         builder.addRepeatedField(field, value);
       } else {
         builder.setField(field, value);
       }
     }

     return true;
   }

   /** Called by {@code #mergeFieldFrom()} to parse a MessageSet extension. */
   private static void mergeMessageSetExtensionFromCodedStream(
       CodedInputStream input,
       UnknownFieldSet.Builder unknownFields,
       ExtensionRegistry extensionRegistry,
       Message.Builder builder) throws java.io.IOException {
     Descriptor type = builder.getDescriptorForType();

     // The wire format for MessageSet is:
     //   message MessageSet {
     //     repeated group Item = 1 {
     //       required int32 typeId = 2;
     //       required bytes message = 3;
     //     }
     //   }
     // "typeId" is the extension's field number.  The extension can only be
     // a message type, where "message" contains the encoded bytes of that
     // message.
     //
     // In practice, we will probably never see a MessageSet item in which
     // the message appears before the type ID, or where either field does not
     // appear exactly once.  However, in theory such cases are valid, so we
     // should be prepared to accept them.

     int typeId = 0;
     ByteString rawBytes = null;  // If we encounter "message" before "typeId"
     Message.Builder subBuilder = null;
     FieldDescriptor field = null;

     while (true) {
       int tag = input.readTag();
       if (tag == 0) {
         break;
       }

       if (tag == WireFormat.MESSAGE_SET_TYPE_ID_TAG) {
         typeId = input.readUInt32();
         // Zero is not a valid type ID.
         if (typeId != 0) {
           ExtensionRegistry.ExtensionInfo extension =
             extensionRegistry.findExtensionByNumber(type, typeId);
           if (extension != null) {
             field = extension.descriptor;
             subBuilder = extension.defaultInstance.newBuilderForType();
             Message originalMessage = (Message)builder.getField(field);
             if (originalMessage != null) {
               subBuilder.mergeFrom(originalMessage);
             }
             if (rawBytes != null) {
               // We already encountered the message.  Parse it now.
               subBuilder.mergeFrom(
                 CodedInputStream.newInstance(rawBytes.newInput()));
               rawBytes = null;
             }
           } else {
             // Unknown extension number.  If we already saw data, put it
             // in rawBytes.
             if (rawBytes != null) {
               unknownFields.mergeField(typeId,
                 UnknownFieldSet.Field.newBuilder()
                   .addLengthDelimited(rawBytes)
                   .build());
               rawBytes = null;
             }
           }
         }
       } else if (tag == WireFormat.MESSAGE_SET_MESSAGE_TAG) {
         if (typeId == 0) {
           // We haven't seen a type ID yet, so we have to store the raw bytes
           // for now.
           rawBytes = input.readBytes();
         } else if (subBuilder == null) {
           // We don't know how to parse this.  Ignore it.
           unknownFields.mergeField(typeId,
             UnknownFieldSet.Field.newBuilder()
               .addLengthDelimited(input.readBytes())
               .build());
         } else {
           // We already know the type, so we can parse directly from the input
           // with no copying.  Hooray!
           input.readMessage(subBuilder, extensionRegistry);
         }
       } else {
         // Unknown tag.  Skip it.
         if (!input.skipField(tag)) {
           break;  // end of group
         }
       }
     }

     input.checkLastTagWas(WireFormat.MESSAGE_SET_ITEM_END_TAG);

     if (subBuilder != null) {
       builder.setField(field, subBuilder.build());
     }
   }

   /** See {@link Message#writeTo(CodedOutputStream)}. */
   public void writeTo(CodedOutputStream output)
                       throws java.io.IOException {
     for (Map.Entry<FieldDescriptor, Object> entry : fields.entrySet()) {
       writeField(entry.getKey(), entry.getValue(), output);
     }
   }

   /** Write a single field. */
   public void writeField(FieldDescriptor field, Object value,
                          CodedOutputStream output) throws java.io.IOException {
     if (field.isExtension() &&
         field.getContainingType().getOptions().getMessageSetWireFormat()) {
       output.writeMessageSetExtension(field.getNumber(), (Message)value);
     } else {
       if (field.isRepeated()) {
         for (Object element : (List)value) {
           output.writeField(field.getType(), field.getNumber(), element);
         }
       } else {
         output.writeField(field.getType(), field.getNumber(), value);
       }
     }
   }

   /**
    * See {@link Message#getSerializedSize()}.  It's up to the caller to cache
    * the resulting size if desired.
    */
   public int getSerializedSize() {
     int size = 0;
     for (Map.Entry<FieldDescriptor, Object> entry : fields.entrySet()) {
       FieldDescriptor field = entry.getKey();
       Object value = entry.getValue();

       if (field.isExtension() &&
           field.getContainingType().getOptions().getMessageSetWireFormat()) {
         size += CodedOutputStream.computeMessageSetExtensionSize(
           field.getNumber(), (Message)value);
       } else {
         if (field.isRepeated()) {
           for (Object element : (List)value) {
             size += CodedOutputStream.computeFieldSize(
               field.getType(), field.getNumber(), element);
           }
         } else {
           size += CodedOutputStream.computeFieldSize(
             field.getType(), field.getNumber(), value);
         }
       }
     }
     return size;
   }
 }
	// Protocol Buffers - Google's data interchange format
	// Copyright 2008 Google Inc.
	// http://code.google.com/p/protobuf/
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	package com.google.protobuf;

	import com.google.protobuf.Descriptors.Descriptor;
	import com.google.protobuf.Descriptors.FieldDescriptor;
	import com.google.protobuf.Descriptors.EnumValueDescriptor;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.Iterator;
	import java.util.TreeMap;
	import java.util.List;
	import java.util.Map;

	/**
	* A class which represents an arbitrary set of fields of some message type.
	* This is used to implement {@link DynamicMessage}, and also to represent
	* extensions in {@link GeneratedMessage}. This class is package-private,
	* since outside users should probably be using {@link DynamicMessage}.
	*
	* @author kenton@google.com Kenton Varda
	*/
	final class FieldSet {
	private Map<FieldDescriptor, Object> fields;

	/** Construct a new FieldSet. */
	private FieldSet() {
	// Use a TreeMap because fields need to be in canonical order when
	// serializing.
	this.fields = new TreeMap<FieldDescriptor, Object>();
	}

	/**
	* Construct a new FieldSet with the given map. This is only used by
	* DEFAULT_INSTANCE, to pass in an immutable empty map.
	*/
	private FieldSet(Map<FieldDescriptor, Object> fields) {
	this.fields = fields;
	}

	/** Construct a new FieldSet. */
	public static FieldSet newFieldSet() {
	return new FieldSet();
	}

	/** Get an immutable empty FieldSet. */
	public static FieldSet emptySet() {
	return DEFAULT_INSTANCE;
	}
	private static final FieldSet DEFAULT_INSTANCE =
	new FieldSet(Collections.<FieldDescriptor, Object>emptyMap());

	/** Make this FieldSet immutable from this point forward. */
	@SuppressWarnings("unchecked")
	public void makeImmutable() {
	for (Map.Entry<FieldDescriptor, Object> entry: fields.entrySet()) {
	if (entry.getKey().isRepeated()) {
	List value = (List)entry.getValue();
	entry.setValue(Collections.unmodifiableList(value));
	}
	}
	fields = Collections.unmodifiableMap(fields);
	}

	// =================================================================

	/** See {@link Message.Builder#clear()}. */
	public void clear() {
	fields.clear();
	}

	/** See {@link Message#getAllFields()}. */
	public Map<Descriptors.FieldDescriptor, Object> getAllFields() {
	return Collections.unmodifiableMap(fields);
	}

	/**
	* Get an interator to the field map. This iterator should not be leaked
	* out of the protobuf library as it is not protected from mutation.
	*/
	public Iterator<Map.Entry<Descriptors.FieldDescriptor, Object>> iterator() {
	return fields.entrySet().iterator();
	}

	/** See {@link Message#hasField(Descriptors.FieldDescriptor)}. */
	public boolean hasField(Descriptors.FieldDescriptor field) {
	if (field.isRepeated()) {
	throw new IllegalArgumentException(
	"hasField() can only be called on non-repeated fields.");
	}

	return fields.containsKey(field);
	}

	/**
	* See {@link Message#getField(Descriptors.FieldDescriptor)}. This method
	* returns {@code null} if the field is a singular message type and is not
	* set; in this case it is up to the caller to fetch the message's default
	* instance.
	*/
	public Object getField(Descriptors.FieldDescriptor field) {
	Object result = fields.get(field);
	if (result == null) {
	if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
	if (field.isRepeated()) {
	return Collections.emptyList();
	} else {
	return null;
	}
	} else {
	return field.getDefaultValue();
	}
	} else {
	return result;
	}
	}

	/** See {@link Message.Builder#setField(Descriptors.FieldDescriptor,Object)}. */
	@SuppressWarnings("unchecked")
	public void setField(Descriptors.FieldDescriptor field, Object value) {
	if (field.isRepeated()) {
	if (!(value instanceof List)) {
	throw new IllegalArgumentException(
	"Wrong object type used with protocol message reflection.");
	}

	// Wrap the contents in a new list so that the caller cannot change
	// the list's contents after setting it.
	List newList = new ArrayList();
	newList.addAll((List)value);
	for (Object element : newList) {
	verifyType(field, element);
	}
	value = newList;
	} else {
	verifyType(field, value);
	}

	fields.put(field, value);
	}

	/** See {@link Message.Builder#clearField(Descriptors.FieldDescriptor)}. */
	public void clearField(Descriptors.FieldDescriptor field) {
	fields.remove(field);
	}

	/** See {@link Message#getRepeatedFieldCount(Descriptors.FieldDescriptor)}. */
	public int getRepeatedFieldCount(Descriptors.FieldDescriptor field) {
	if (!field.isRepeated()) {
	throw new IllegalArgumentException(
	"getRepeatedFieldCount() can only be called on repeated fields.");
	}

	return ((List)getField(field)).size();
	}

	/** See {@link Message#getRepeatedField(Descriptors.FieldDescriptor,int)}. */
	public Object getRepeatedField(Descriptors.FieldDescriptor field, int index) {
	if (!field.isRepeated()) {
	throw new IllegalArgumentException(
	"getRepeatedField() can only be called on repeated fields.");
	}

	return ((List)getField(field)).get(index);
	}

	/** See {@link Message.Builder#setRepeatedField(Descriptors.FieldDescriptor,int,Object)}. */
	@SuppressWarnings("unchecked")
	public void setRepeatedField(Descriptors.FieldDescriptor field, int index,
	Object value) {
	if (!field.isRepeated()) {
	throw new IllegalArgumentException(
	"setRepeatedField() can only be called on repeated fields.");
	}

	verifyType(field, value);

	List list = (List)fields.get(field);
	if (list == null) {
	throw new IndexOutOfBoundsException();
	}

	list.set(index, value);
	}

	/** See {@link Message.Builder#addRepeatedField(Descriptors.FieldDescriptor,Object)}. */
	@SuppressWarnings("unchecked")
	public void addRepeatedField(Descriptors.FieldDescriptor field,
	Object value) {
	if (!field.isRepeated()) {
	throw new IllegalArgumentException(
	"setRepeatedField() can only be called on repeated fields.");
	}

	verifyType(field, value);

	List list = (List)fields.get(field);
	if (list == null) {
	list = new ArrayList();
	fields.put(field, list);
	}

	list.add(value);
	}

	/**
	* Verifies that the given object is of the correct type to be a valid
	* value for the given field. (For repeated fields, this checks if the
	* object is the right type to be one element of the field.)
	*
	* @throws IllegalArgumentException The value is not of the right type.
	*/
	private void verifyType(FieldDescriptor field, Object value) {
	boolean isValid = false;
	switch (field.getJavaType()) {
	case INT: isValid = value instanceof Integer ; break;
	case LONG: isValid = value instanceof Long ; break;
	case FLOAT: isValid = value instanceof Float ; break;
	case DOUBLE: isValid = value instanceof Double ; break;
	case BOOLEAN: isValid = value instanceof Boolean ; break;
	case STRING: isValid = value instanceof String ; break;
	case BYTE_STRING: isValid = value instanceof ByteString; break;
	case ENUM:
	isValid = value instanceof EnumValueDescriptor &&
	((EnumValueDescriptor)value).getType() == field.getEnumType();
	break;
	case MESSAGE:
	isValid = value instanceof Message &&
	((Message)value).getDescriptorForType() == field.getMessageType();
	break;
	}

	if (!isValid) {
	// When chaining calls to setField(), it can be hard to tell from
	// the stack trace which exact call failed, since the whole chain is
	// considered one line of code. So, let's make sure to include the
	// field name and other useful info in the exception.
	throw new IllegalArgumentException(
	"Wrong object type used with protocol message reflection. " +
	"Message type \"" + field.getContainingType().getFullName() +
	"\", field \"" +
	(field.isExtension() ? field.getFullName() : field.getName()) +
	"\", value was type \"" + value.getClass().getName() + "\".");
	}
	}

	// =================================================================
	// Parsing and serialization

	/**
	* See {@link Message#isInitialized()}. Note: Since {@code FieldSet}
	* itself does not have any way of knowing about required fields that
	* aren't actually present in the set, it is up to the caller to check
	* that all required fields are present.
	*/
	@SuppressWarnings("unchecked")
	public boolean isInitialized() {
	for (Map.Entry<FieldDescriptor, Object> entry : fields.entrySet()) {
	FieldDescriptor field = entry.getKey();
	if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
	if (field.isRepeated()) {
	for (Message element : (List<Message>) entry.getValue()) {
	if (!element.isInitialized()) {
	return false;
	}
	}
	} else {
	if (!((Message) entry.getValue()).isInitialized()) {
	return false;
	}
	}
	}
	}

	return true;
	}

	/**
	* Like {@link #isInitialized()}, but also checks for the presence of
	* all required fields in the given type.
	*/
	@SuppressWarnings("unchecked")
	public boolean isInitialized(Descriptor type) {
	// Check that all required fields are present.
	for (FieldDescriptor field : type.getFields()) {
	if (field.isRequired()) {
	if (!hasField(field)) {
	return false;
	}
	}
	}

	// Check that embedded messages are initialized.
	return isInitialized();
	}

	/** See {@link Message.Builder#mergeFrom(Message)}. */
	@SuppressWarnings("unchecked")
	public void mergeFrom(Message other) {
	// Note: We don't attempt to verify that other's fields have valid
	// types. Doing so would be a losing battle. We'd have to verify
	// all sub-messages as well, and we'd have to make copies of all of
	// them to insure that they don't change after verification (since
	// the Message interface itself cannot enforce immutability of
	// implementations).
	// TODO(kenton): Provide a function somewhere called makeDeepCopy()
	// which allows people to make secure deep copies of messages.

	for (Map.Entry<FieldDescriptor, Object> entry :
	other.getAllFields().entrySet()) {
	FieldDescriptor field = entry.getKey();
	if (field.isRepeated()) {
	List existingValue = (List)fields.get(field);
	if (existingValue == null) {
	existingValue = new ArrayList();
	fields.put(field, existingValue);
	}
	existingValue.addAll((List)entry.getValue());
	} else if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
	Message existingValue = (Message)fields.get(field);
	if (existingValue == null) {
	setField(field, entry.getValue());
	} else {
	setField(field,
	existingValue.newBuilderForType()
	.mergeFrom(existingValue)
	.mergeFrom((Message)entry.getValue())
	.build());
	}
	} else {
	setField(field, entry.getValue());
	}
	}
	}

	/**
	* Like {@link #mergeFrom(Message)}, but merges from another {@link FieldSet}.
	*/
	@SuppressWarnings("unchecked")
	public void mergeFrom(FieldSet other) {
	for (Map.Entry<FieldDescriptor, Object> entry : other.fields.entrySet()) {
	FieldDescriptor field = entry.getKey();
	Object value = entry.getValue();

	if (field.isRepeated()) {
	List existingValue = (List)fields.get(field);
	if (existingValue == null) {
	existingValue = new ArrayList();
	fields.put(field, existingValue);
	}
	existingValue.addAll((List)value);
	} else if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
	Message existingValue = (Message)fields.get(field);
	if (existingValue == null) {
	setField(field, value);
	} else {
	setField(field,
	existingValue.newBuilderForType()
	.mergeFrom(existingValue)
	.mergeFrom((Message)value)
	.build());
	}
	} else {
	setField(field, value);
	}
	}
	}

	// TODO(kenton): Move parsing code into AbstractMessage, since it no longer
	// uses any special knowledge from FieldSet.

	/**
	* See {@link Message.Builder#mergeFrom(CodedInputStream)}.
	* @param builder The {@code Builder} for the target message.
	*/
	public static void mergeFrom(CodedInputStream input,
	UnknownFieldSet.Builder unknownFields,
	ExtensionRegistry extensionRegistry,
	Message.Builder builder)
	throws java.io.IOException {
	while (true) {
	int tag = input.readTag();
	if (tag == 0) {
	break;
	}

	if (!mergeFieldFrom(input, unknownFields, extensionRegistry,
	builder, tag)) {
	// end group tag
	break;
	}
	}
	}

	/**
	* Like {@link #mergeFrom(CodedInputStream, UnknownFieldSet.Builder,
	* ExtensionRegistry, Message.Builder)}, but parses a single field.
	* @param tag The tag, which should have already been read.
	* @return {@code true} unless the tag is an end-group tag.
	*/
	@SuppressWarnings("unchecked")
	public static boolean mergeFieldFrom(
	CodedInputStream input,
	UnknownFieldSet.Builder unknownFields,
	ExtensionRegistry extensionRegistry,
	Message.Builder builder,
	int tag) throws java.io.IOException {
	Descriptor type = builder.getDescriptorForType();

	if (type.getOptions().getMessageSetWireFormat() &&
	tag == WireFormat.MESSAGE_SET_ITEM_TAG) {
	mergeMessageSetExtensionFromCodedStream(
	input, unknownFields, extensionRegistry, builder);
	return true;
	}

	int wireType = WireFormat.getTagWireType(tag);
	int fieldNumber = WireFormat.getTagFieldNumber(tag);

	FieldDescriptor field;
	Message defaultInstance = null;

	if (type.isExtensionNumber(fieldNumber)) {
	ExtensionRegistry.ExtensionInfo extension =
	extensionRegistry.findExtensionByNumber(type, fieldNumber);
	if (extension == null) {
	field = null;
	} else {
	field = extension.descriptor;
	defaultInstance = extension.defaultInstance;
	}
	} else {
	field = type.findFieldByNumber(fieldNumber);
	}

	if (field == null \|\|
	wireType != WireFormat.getWireFormatForFieldType(field.getType())) {
	// Unknown field or wrong wire type. Skip.
	return unknownFields.mergeFieldFrom(tag, input);
	} else {
	Object value;
	switch (field.getType()) {
	case GROUP: {
	Message.Builder subBuilder;
	if (defaultInstance != null) {
	subBuilder = defaultInstance.newBuilderForType();
	} else {
	subBuilder = builder.newBuilderForField(field);
	}
	if (!field.isRepeated()) {
	subBuilder.mergeFrom((Message) builder.getField(field));
	}
	input.readGroup(field.getNumber(), subBuilder, extensionRegistry);
	value = subBuilder.build();
	break;
	}
	case MESSAGE: {
	Message.Builder subBuilder;
	if (defaultInstance != null) {
	subBuilder = defaultInstance.newBuilderForType();
	} else {
	subBuilder = builder.newBuilderForField(field);
	}
	if (!field.isRepeated()) {
	subBuilder.mergeFrom((Message) builder.getField(field));
	}
	input.readMessage(subBuilder, extensionRegistry);
	value = subBuilder.build();
	break;
	}
	case ENUM: {
	int rawValue = input.readEnum();
	value = field.getEnumType().findValueByNumber(rawValue);
	// If the number isn't recognized as a valid value for this enum,
	// drop it.
	if (value == null) {
	unknownFields.mergeVarintField(fieldNumber, rawValue);
	return true;
	}
	break;
	}
	default:
	value = input.readPrimitiveField(field.getType());
	break;
	}

	if (field.isRepeated()) {
	builder.addRepeatedField(field, value);
	} else {
	builder.setField(field, value);
	}
	}

	return true;
	}

	/** Called by {@code #mergeFieldFrom()} to parse a MessageSet extension. */
	private static void mergeMessageSetExtensionFromCodedStream(
	CodedInputStream input,
	UnknownFieldSet.Builder unknownFields,
	ExtensionRegistry extensionRegistry,
	Message.Builder builder) throws java.io.IOException {
	Descriptor type = builder.getDescriptorForType();

	// The wire format for MessageSet is:
	// message MessageSet {
	// repeated group Item = 1 {
	// required int32 typeId = 2;
	// required bytes message = 3;
	// }
	// }
	// "typeId" is the extension's field number. The extension can only be
	// a message type, where "message" contains the encoded bytes of that
	// message.
	//
	// In practice, we will probably never see a MessageSet item in which
	// the message appears before the type ID, or where either field does not
	// appear exactly once. However, in theory such cases are valid, so we
	// should be prepared to accept them.

	int typeId = 0;
	ByteString rawBytes = null; // If we encounter "message" before "typeId"
	Message.Builder subBuilder = null;
	FieldDescriptor field = null;

	while (true) {
	int tag = input.readTag();
	if (tag == 0) {
	break;
	}

	if (tag == WireFormat.MESSAGE_SET_TYPE_ID_TAG) {
	typeId = input.readUInt32();
	// Zero is not a valid type ID.
	if (typeId != 0) {
	ExtensionRegistry.ExtensionInfo extension =
	extensionRegistry.findExtensionByNumber(type, typeId);
	if (extension != null) {
	field = extension.descriptor;
	subBuilder = extension.defaultInstance.newBuilderForType();
	Message originalMessage = (Message)builder.getField(field);
	if (originalMessage != null) {
	subBuilder.mergeFrom(originalMessage);
	}
	if (rawBytes != null) {
	// We already encountered the message. Parse it now.
	subBuilder.mergeFrom(
	CodedInputStream.newInstance(rawBytes.newInput()));
	rawBytes = null;
	}
	} else {
	// Unknown extension number. If we already saw data, put it
	// in rawBytes.
	if (rawBytes != null) {
	unknownFields.mergeField(typeId,
	UnknownFieldSet.Field.newBuilder()
	.addLengthDelimited(rawBytes)
	.build());
	rawBytes = null;
	}
	}
	}
	} else if (tag == WireFormat.MESSAGE_SET_MESSAGE_TAG) {
	if (typeId == 0) {
	// We haven't seen a type ID yet, so we have to store the raw bytes
	// for now.
	rawBytes = input.readBytes();
	} else if (subBuilder == null) {
	// We don't know how to parse this. Ignore it.
	unknownFields.mergeField(typeId,
	UnknownFieldSet.Field.newBuilder()
	.addLengthDelimited(input.readBytes())
	.build());
	} else {
	// We already know the type, so we can parse directly from the input
	// with no copying. Hooray!
	input.readMessage(subBuilder, extensionRegistry);
	}
	} else {
	// Unknown tag. Skip it.
	if (!input.skipField(tag)) {
	break; // end of group
	}
	}
	}

	input.checkLastTagWas(WireFormat.MESSAGE_SET_ITEM_END_TAG);

	if (subBuilder != null) {
	builder.setField(field, subBuilder.build());
	}
	}

	/** See {@link Message#writeTo(CodedOutputStream)}. */
	public void writeTo(CodedOutputStream output)
	throws java.io.IOException {
	for (Map.Entry<FieldDescriptor, Object> entry : fields.entrySet()) {
	writeField(entry.getKey(), entry.getValue(), output);
	}
	}

	/** Write a single field. */
	public void writeField(FieldDescriptor field, Object value,
	CodedOutputStream output) throws java.io.IOException {
	if (field.isExtension() &&
	field.getContainingType().getOptions().getMessageSetWireFormat()) {
	output.writeMessageSetExtension(field.getNumber(), (Message)value);
	} else {
	if (field.isRepeated()) {
	for (Object element : (List)value) {
	output.writeField(field.getType(), field.getNumber(), element);
	}
	} else {
	output.writeField(field.getType(), field.getNumber(), value);
	}
	}
	}

	/**
	* See {@link Message#getSerializedSize()}. It's up to the caller to cache
	* the resulting size if desired.
	*/
	public int getSerializedSize() {
	int size = 0;
	for (Map.Entry<FieldDescriptor, Object> entry : fields.entrySet()) {
	FieldDescriptor field = entry.getKey();
	Object value = entry.getValue();

	if (field.isExtension() &&
	field.getContainingType().getOptions().getMessageSetWireFormat()) {
	size += CodedOutputStream.computeMessageSetExtensionSize(
	field.getNumber(), (Message)value);
	} else {
	if (field.isRepeated()) {
	for (Object element : (List)value) {
	size += CodedOutputStream.computeFieldSize(
	field.getType(), field.getNumber(), element);
	}
	} else {
	size += CodedOutputStream.computeFieldSize(
	field.getType(), field.getNumber(), value);
	}
	}
	}
	return size;
	}
	}