Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  // 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.util.List;
 import java.util.Map;

A class which represents an arbitrary set of fields of some message type. This is used to implement DynamicMessage, and also to represent extensions in GeneratedMessage. This class is package-private, since outside users should probably be using DynamicMessage.

Author(s):
kenton@google.com Kenton Varda
 
 final class FieldSet<FieldDescriptorType extends
       FieldSet.FieldDescriptorLite<FieldDescriptorType>> {
  
Interface for a FieldDescriptor or lite extension descriptor. This prevents FieldSet from depending on Descriptors.FieldDescriptor.
 
   public interface FieldDescriptorLite<T extends FieldDescriptorLite<T>>
       extends Comparable<T> {
     int getNumber();
     boolean isRepeated();
     boolean isPacked();
 
     // If getLiteJavaType() == MESSAGE, this merges a message object of the
     // type into a builder of the type.  Returns {@code to}.
         MessageLite.Builder toMessageLite from);
   }
 
   private final SmallSortedMap<FieldDescriptorType, Objectfields;
   private boolean isImmutable;
   private boolean hasLazyField = false;

  
Construct a new FieldSet.
 
   private FieldSet() {
     this. = SmallSortedMap.newFieldMap(16);
   }

  
Construct an empty FieldSet. This is only used to initialize DEFAULT_INSTANCE.
 
   private FieldSet(final boolean dummy) {
     this. = SmallSortedMap.newFieldMap(0);
     makeImmutable();
   }

  
Construct a new FieldSet.
 
   public static <T extends FieldSet.FieldDescriptorLite<T>>
       FieldSet<T> newFieldSet() {
     return new FieldSet<T>();
   }

  
Get an immutable empty FieldSet.
 
   @SuppressWarnings("unchecked")
   public static <T extends FieldSet.FieldDescriptorLite<T>>
       FieldSet<T> emptySet() {
     return ;
  }
  @SuppressWarnings("rawtypes")
  private static final FieldSet DEFAULT_INSTANCE = new FieldSet(true);

  
Make this FieldSet immutable from this point forward.
  @SuppressWarnings("unchecked")
  public void makeImmutable() {
    if () {
      return;
    }
     = true;
  }

  
Returns whether the FieldSet is immutable. This is true if it is the emptySet() or if makeImmutable() were called.

Returns:
whether the FieldSet is immutable.
  public boolean isImmutable() {
    return ;
  }

  
Clones the FieldSet. The returned FieldSet will be mutable even if the original FieldSet was immutable.

Returns:
the newly cloned FieldSet
  public FieldSet<FieldDescriptorType> clone() {
    // We can't just call fields.clone because List objects in the map
    // should not be shared.
    FieldSet<FieldDescriptorType> clone = FieldSet.newFieldSet();
    for (int i = 0; i < .getNumArrayEntries(); i++) {
      Map.Entry<FieldDescriptorType, Objectentry = .getArrayEntryAt(i);
      FieldDescriptorType descriptor = entry.getKey();
      clone.setField(descriptorentry.getValue());
    }
    for (Map.Entry<FieldDescriptorType, Objectentry :
             .getOverflowEntries()) {
      FieldDescriptorType descriptor = entry.getKey();
      clone.setField(descriptorentry.getValue());
    }
    clone.hasLazyField = ;
    return clone;
  }
  // =================================================================

  
  public void clear() {
    .clear();
     = false;
  }

  
Get a simple map containing all the fields.
  public Map<FieldDescriptorType, ObjectgetAllFields() {
    if () {
      SmallSortedMap<FieldDescriptorType, Objectresult =
          SmallSortedMap.newFieldMap(16);
      for (int i = 0; i < .getNumArrayEntries(); i++) {
        cloneFieldEntry(result.getArrayEntryAt(i));
      }
      for (Map.Entry<FieldDescriptorType, Objectentry :
          .getOverflowEntries()) {
        cloneFieldEntry(resultentry);
      }
      if (.isImmutable()) {
        result.makeImmutable();
      }
      return result;
    }
    return .isImmutable() ?  : Collections.unmodifiableMap();
  }
  private void cloneFieldEntry(Map<FieldDescriptorType, Objectmap,
      Map.Entry<FieldDescriptorType, Objectentry) {
    FieldDescriptorType key = entry.getKey();
    Object value = entry.getValue();
    if (value instanceof LazyField) {
      map.put(key, ((LazyFieldvalue).getValue());
    } else {
      map.put(keyvalue);
    }
  }

  
Get an iterator to the field map. This iterator should not be leaked out of the protobuf library as it is not protected from mutation when fields is not immutable.
  public Iterator<Map.Entry<FieldDescriptorType, Object>> iterator() {
    if () {
      return new LazyIterator<FieldDescriptorType>(
          .entrySet().iterator());
    }
    return .entrySet().iterator();
  }

  
  public boolean hasField(final FieldDescriptorType descriptor) {
    if (descriptor.isRepeated()) {
      throw new IllegalArgumentException(
        "hasField() can only be called on non-repeated fields.");
    }
    return .get(descriptor) != null;
  }

  
Useful for implementing MessageOrBuilder.getField(com.google.protobuf.Descriptors.FieldDescriptor). This method returns null if the field is not set; in this case it is up to the caller to fetch the field's default value.
  public Object getField(final FieldDescriptorType descriptor) {
    Object o = .get(descriptor);
    if (o instanceof LazyField) {
      return ((LazyFieldo).getValue();
    }
    return o;
  }

  
Useful for implementing Message.Builder.setField(Descriptors.FieldDescriptor,Object).
  @SuppressWarnings({"unchecked""rawtypes"})
  public void setField(final FieldDescriptorType descriptor,
                       Object value) {
    if (descriptor.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.
      final List newList = new ArrayList();
      newList.addAll((Listvalue);
      for (final Object element : newList) {
        verifyType(descriptor.getLiteType(), element);
      }
      value = newList;
    } else {
      verifyType(descriptor.getLiteType(), value);
    }
    if (value instanceof LazyField) {
       = true;
    }
    .put(descriptorvalue);
  }

  
  public void clearField(final FieldDescriptorType descriptor) {
    .remove(descriptor);
    if (.isEmpty()) {
       = false;
    }
  }

  
  public int getRepeatedFieldCount(final FieldDescriptorType descriptor) {
    if (!descriptor.isRepeated()) {
      throw new IllegalArgumentException(
        "getRepeatedField() can only be called on repeated fields.");
    }
    final Object value = getField(descriptor);
    if (value == null) {
      return 0;
    } else {
      return ((List<?>) value).size();
    }
  }

  
  public Object getRepeatedField(final FieldDescriptorType descriptor,
                                 final int index) {
    if (!descriptor.isRepeated()) {
      throw new IllegalArgumentException(
        "getRepeatedField() can only be called on repeated fields.");
    }
    final Object value = getField(descriptor);
    if (value == null) {
      throw new IndexOutOfBoundsException();
    } else {
      return ((List<?>) value).get(index);
    }
  }

  
  @SuppressWarnings("unchecked")
  public void setRepeatedField(final FieldDescriptorType descriptor,
                               final int index,
                               final Object value) {
    if (!descriptor.isRepeated()) {
      throw new IllegalArgumentException(
        "getRepeatedField() can only be called on repeated fields.");
    }
    final Object list = getField(descriptor);
    if (list == null) {
      throw new IndexOutOfBoundsException();
    }
    verifyType(descriptor.getLiteType(), value);
    ((List<Object>) list).set(indexvalue);
  }

  
  @SuppressWarnings("unchecked")
  public void addRepeatedField(final FieldDescriptorType descriptor,
                               final Object value) {
    if (!descriptor.isRepeated()) {
      throw new IllegalArgumentException(
        "addRepeatedField() can only be called on repeated fields.");
    }
    verifyType(descriptor.getLiteType(), value);
    final Object existingValue = getField(descriptor);
    List<Objectlist;
    if (existingValue == null) {
      list = new ArrayList<Object>();
      .put(descriptorlist);
    } else {
      list = (List<Object>) existingValue;
    }
    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:
java.lang.IllegalArgumentException The value is not of the right type.
  private static void verifyType(final WireFormat.FieldType type,
                                 final Object value) {
    if (value == null) {
      throw new NullPointerException();
    }
    boolean isValid = false;
    switch (type.getJavaType()) {
      case :          isValid = value instanceof Integer   ; break;
      case :         isValid = value instanceof Long      ; break;
      case :        isValid = value instanceof Float     ; break;
      case :       isValid = value instanceof Double    ; break;
      case :      isValid = value instanceof Boolean   ; break;
      case :       isValid = value instanceof String    ; break;
      case :
        isValid = value instanceof ByteString || value instanceof byte[];
        break;
      case :
        // TODO(kenton):  Caller must do type checking here, I guess.
        isValid =
            (value instanceof Integer || value instanceof Internal.EnumLite);
        break;
      case :
        // TODO(kenton):  Caller must do type checking here, I guess.
        isValid =
            (value instanceof MessageLite) || (value instanceof LazyField);
        break;
    }
    if (!isValid) {
      // TODO(kenton):  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.  It would be nice to print
      //   more information here, e.g. naming the field.  We used to do that.
      //   But we can't now that FieldSet doesn't use descriptors.  Maybe this
      //   isn't a big deal, though, since it would only really apply when using
      //   reflection and generally people don't chain reflection setters.
      throw new IllegalArgumentException(
        "Wrong object type used with protocol message reflection.");
    }
  }
  // =================================================================
  // Parsing and serialization

  
See MessageLiteOrBuilder.isInitialized(). Note: Since 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.
  public boolean isInitialized() {
    for (int i = 0; i < .getNumArrayEntries(); i++) {
      if (!isInitialized(.getArrayEntryAt(i))) {
        return false;
      }
    }
    for (final Map.Entry<FieldDescriptorType, Objectentry :
             .getOverflowEntries()) {
      if (!isInitialized(entry)) {
        return false;
      }
    }
    return true;
  }
  @SuppressWarnings("unchecked")
  private boolean isInitialized(
      final Map.Entry<FieldDescriptorType, Objectentry) {
    final FieldDescriptorType descriptor = entry.getKey();
    if (descriptor.getLiteJavaType() == ..) {
      if (descriptor.isRepeated()) {
        for (final MessageLite element:
                 (List<MessageLite>) entry.getValue()) {
          if (!element.isInitialized()) {
            return false;
          }
        }
      } else {
        Object value = entry.getValue();
        if (value instanceof MessageLite) {
          if (!((MessageLitevalue).isInitialized()) {
            return false;
          }
        } else if (value instanceof LazyField) {
          return true;
        } else {
          throw new IllegalArgumentException(
              "Wrong object type used with protocol message reflection.");
        }
      }
    }
    return true;
  }

  
Given a field type, return the wire type.

Returns:
One of the WIRETYPE_ constants defined in WireFormat.
  static int getWireFormatForFieldType(final WireFormat.FieldType type,
                                       boolean isPacked) {
    if (isPacked) {
    } else {
      return type.getWireType();
    }
  }

  
  public void mergeFrom(final FieldSet<FieldDescriptorType> other) {
    for (int i = 0; i < other.fields.getNumArrayEntries(); i++) {
      mergeFromField(other.fields.getArrayEntryAt(i));
    }
    for (final Map.Entry<FieldDescriptorType, Objectentry :
             other.fields.getOverflowEntries()) {
      mergeFromField(entry);
    }
  }
  private Object cloneIfMutable(Object value) {
    if (value instanceof byte[]) {
      byte[] bytes = (byte[]) value;
      byte[] copy = new byte[bytes.length];
      System.arraycopy(bytes, 0, copy, 0, bytes.length);
      return copy;
    } else {
      return value;
    }
  }
  @SuppressWarnings({"unchecked""rawtypes"})
  private void mergeFromField(
      final Map.Entry<FieldDescriptorType, Objectentry) {
    final FieldDescriptorType descriptor = entry.getKey();
    Object otherValue = entry.getValue();
    if (otherValue instanceof LazyField) {
      otherValue = ((LazyFieldotherValue).getValue();
    }
    if (descriptor.isRepeated()) {
      Object value = getField(descriptor);
      if (value == null) {
        value = new ArrayList();
      }
      for (Object element : (ListotherValue) {
        ((Listvalue).add(cloneIfMutable(element));
      }
      .put(descriptorvalue);
    } else if (descriptor.getLiteJavaType() == ..) {
      Object value = getField(descriptor);
      if (value == null) {
        .put(descriptorcloneIfMutable(otherValue));
      } else {
        // Merge the messages.
          value = descriptor.internalMergeFrom(
                ((MessageLitevalue).toBuilder(), (MessageLiteotherValue)
                .build();
        .put(descriptorvalue);
      }
    } else {
      .put(descriptorcloneIfMutable(otherValue));
    }
  }
  // TODO(kenton):  Move static parsing and serialization methods into some
  //   other class.  Probably WireFormat.

  
Read a field of any primitive type for immutable messages from a CodedInputStream. Enums, groups, and embedded messages are not handled by this method.

Parameters:
input The stream from which to read.
type Declared type of the field.
checkUtf8 When true, check that the input is valid utf8.
Returns:
An object representing the field's value, of the exact type which would be returned by MessageOrBuilder.getField(com.google.protobuf.Descriptors.FieldDescriptor) for this field.
  public static Object readPrimitiveField(
      CodedInputStream input,
      final WireFormat.FieldType type,
      boolean checkUtf8throws IOException {
    switch (type) {
      case   : return input.readDouble  ();
      case    : return input.readFloat   ();
      case    : return input.readInt64   ();
      case   : return input.readUInt64  ();
      case    : return input.readInt32   ();
      case  : return input.readFixed64 ();
      case  : return input.readFixed32 ();
      case     : return input.readBool    ();
      case   : if (checkUtf8) {
                       return input.readStringRequireUtf8();
                     } else {
                       return input.readString();
                     }
      case    : return input.readBytes   ();
      case   : return input.readUInt32  ();
      case return input.readSFixed32();
      case return input.readSFixed64();
      case   : return input.readSInt32  ();
      case   : return input.readSInt64  ();
      case :
        throw new IllegalArgumentException(
          "readPrimitiveField() cannot handle nested groups.");
      case :
        throw new IllegalArgumentException(
          "readPrimitiveField() cannot handle embedded messages.");
      case :
        // We don't handle enums because we don't know what to do if the
        // value is not recognized.
        throw new IllegalArgumentException(
          "readPrimitiveField() cannot handle enums.");
    }
    throw new RuntimeException(
      "There is no way to get here, but the compiler thinks otherwise.");
  }


  
  public void writeTo(final CodedOutputStream output)
                      throws IOException {
    for (int i = 0; i < .getNumArrayEntries(); i++) {
      final Map.Entry<FieldDescriptorType, Objectentry =
          .getArrayEntryAt(i);
      writeField(entry.getKey(), entry.getValue(), output);
    }
    for (final Map.Entry<FieldDescriptorType, Objectentry :
         .getOverflowEntries()) {
      writeField(entry.getKey(), entry.getValue(), output);
    }
  }

  
Like writeTo(com.google.protobuf.CodedOutputStream) but uses MessageSet wire format.
  public void writeMessageSetTo(final CodedOutputStream output)
                                throws IOException {
    for (int i = 0; i < .getNumArrayEntries(); i++) {
      writeMessageSetTo(.getArrayEntryAt(i), output);
    }
    for (final Map.Entry<FieldDescriptorType, Objectentry :
             .getOverflowEntries()) {
      writeMessageSetTo(entryoutput);
    }
  }
  private void writeMessageSetTo(
      final Map.Entry<FieldDescriptorType, Objectentry,
      final CodedOutputStream outputthrows IOException {
    final FieldDescriptorType descriptor = entry.getKey();
    if (descriptor.getLiteJavaType() == .. &&
        !descriptor.isRepeated() && !descriptor.isPacked()) {
      Object value = entry.getValue();
      if (value instanceof LazyField) {
        value = ((LazyFieldvalue).getValue();
      }
      output.writeMessageSetExtension(entry.getKey().getNumber(),
                                      (MessageLitevalue);
    } else {
      writeField(descriptorentry.getValue(), output);
    }
  }

  
Write a single tag-value pair to the stream.

Parameters:
output The output stream.
type The field's type.
number The field's number.
value Object representing the field's value. Must be of the exact type which would be returned by MessageOrBuilder.getField(com.google.protobuf.Descriptors.FieldDescriptor) for this field.
  private static void writeElement(final CodedOutputStream output,
                                   final WireFormat.FieldType type,
                                   final int number,
                                   final Object valuethrows IOException {
    // Special case for groups, which need a start and end tag; other fields
    // can just use writeTag() and writeFieldNoTag().
    if (type == ..) {
        output.writeGroup(number, (MessageLitevalue);
    } else {
      output.writeTag(numbergetWireFormatForFieldType(typefalse));
      writeElementNoTag(outputtypevalue);
    }
  }

  
Write a field of arbitrary type, without its tag, to the stream.

Parameters:
output The output stream.
type The field's type.
value Object representing the field's value. Must be of the exact type which would be returned by MessageOrBuilder.getField(com.google.protobuf.Descriptors.FieldDescriptor) for this field.
  private static void writeElementNoTag(
      final CodedOutputStream output,
      final WireFormat.FieldType type,
      final Object valuethrows IOException {
    switch (type) {
      case   : output.writeDoubleNoTag  ((Double     ) value); break;
      case    : output.writeFloatNoTag   ((Float      ) value); break;
      case    : output.writeInt64NoTag   ((Long       ) value); break;
      case   : output.writeUInt64NoTag  ((Long       ) value); break;
      case    : output.writeInt32NoTag   ((Integer    ) value); break;
      case  : output.writeFixed64NoTag ((Long       ) value); break;
      case  : output.writeFixed32NoTag ((Integer    ) value); break;
      case     : output.writeBoolNoTag    ((Boolean    ) value); break;
      case   : output.writeStringNoTag  ((String     ) value); break;
      case    : output.writeGroupNoTag   ((MessageLitevalue); break;
      case  : output.writeMessageNoTag ((MessageLitevalue); break;
      case :
        if (value instanceof ByteString) {
          output.writeBytesNoTag((ByteStringvalue);
        } else {
          output.writeByteArrayNoTag((byte[]) value);
        }
        break;
      case   : output.writeUInt32NoTag  ((Integer    ) value); break;
      case output.writeSFixed32NoTag((Integer    ) value); break;
      case output.writeSFixed64NoTag((Long       ) value); break;
      case   : output.writeSInt32NoTag  ((Integer    ) value); break;
      case   : output.writeSInt64NoTag  ((Long       ) value); break;
      case :
        if (value instanceof Internal.EnumLite) {
          output.writeEnumNoTag(((Internal.EnumLitevalue).getNumber());
        } else {
          output.writeEnumNoTag(((Integervalue).intValue());
        }
        break;
    }
  }

  
Write a single field.
  public static void writeField(final FieldDescriptorLite<?> descriptor,
                                final Object value,
                                final CodedOutputStream output)
                                throws IOException {
    WireFormat.FieldType type = descriptor.getLiteType();
    int number = descriptor.getNumber();
    if (descriptor.isRepeated()) {
      final List<?> valueList = (List<?>)value;
      if (descriptor.isPacked()) {
        output.writeTag(number.);
        // Compute the total data size so the length can be written.
        int dataSize = 0;
        for (final Object element : valueList) {
          dataSize += computeElementSizeNoTag(typeelement);
        }
        output.writeRawVarint32(dataSize);
        // Write the data itself, without any tags.
        for (final Object element : valueList) {
          writeElementNoTag(outputtypeelement);
        }
      } else {
        for (final Object element : valueList) {
          writeElement(outputtypenumberelement);
        }
      }
    } else {
      if (value instanceof LazyField) {
        writeElement(outputtypenumber, ((LazyFieldvalue).getValue());
      } else {
        writeElement(outputtypenumbervalue);
      }
    }
  }

  
See MessageLite.getSerializedSize(). It's up to the caller to cache the resulting size if desired.
  public int getSerializedSize() {
    int size = 0;
    for (int i = 0; i < .getNumArrayEntries(); i++) {
      final Map.Entry<FieldDescriptorType, Objectentry =
          .getArrayEntryAt(i);
      size += computeFieldSize(entry.getKey(), entry.getValue());
    }
    for (final Map.Entry<FieldDescriptorType, Objectentry :
         .getOverflowEntries()) {
      size += computeFieldSize(entry.getKey(), entry.getValue());
    }
    return size;
  }

  
Like getSerializedSize() but uses MessageSet wire format.
  public int getMessageSetSerializedSize() {
    int size = 0;
    for (int i = 0; i < .getNumArrayEntries(); i++) {
    }
    for (final Map.Entry<FieldDescriptorType, Objectentry :
             .getOverflowEntries()) {
      size += getMessageSetSerializedSize(entry);
    }
    return size;
  }
      final Map.Entry<FieldDescriptorType, Objectentry) {
    final FieldDescriptorType descriptor = entry.getKey();
    Object value = entry.getValue();
    if (descriptor.getLiteJavaType() == ..
        && !descriptor.isRepeated() && !descriptor.isPacked()) {
      if (value instanceof LazyField) {
        return CodedOutputStream.computeLazyFieldMessageSetExtensionSize(
            entry.getKey().getNumber(), (LazyFieldvalue);
      } else {
        return CodedOutputStream.computeMessageSetExtensionSize(
            entry.getKey().getNumber(), (MessageLitevalue);
      }
    } else {
      return computeFieldSize(descriptorvalue);
    }
  }

  
Compute the number of bytes that would be needed to encode a single tag/value pair of arbitrary type.

Parameters:
type The field's type.
number The field's number.
value Object representing the field's value. Must be of the exact type which would be returned by MessageOrBuilder.getField(com.google.protobuf.Descriptors.FieldDescriptor) for this field.
  private static int computeElementSize(
      final WireFormat.FieldType type,
      final int numberfinal Object value) {
    int tagSize = CodedOutputStream.computeTagSize(number);
    if (type == ..) {
      // Only count the end group tag for proto2 messages as for proto1 the end
      // group tag will be counted as a part of getSerializedSize().
        tagSize *= 2;
    }
    return tagSize + computeElementSizeNoTag(typevalue);
  }

  
Compute the number of bytes that would be needed to encode a particular value of arbitrary type, excluding tag.

Parameters:
type The field's type.
value Object representing the field's value. Must be of the exact type which would be returned by MessageOrBuilder.getField(com.google.protobuf.Descriptors.FieldDescriptor) for this field.
  private static int computeElementSizeNoTag(
      final WireFormat.FieldType typefinal Object value) {
    switch (type) {
      // Note:  Minor violation of 80-char limit rule here because this would
      //   actually be harder to read if we wrapped the lines.
      case   : return CodedOutputStream.computeDoubleSizeNoTag  ((Double     )value);
      case    : return CodedOutputStream.computeFloatSizeNoTag   ((Float      )value);
      case    : return CodedOutputStream.computeInt64SizeNoTag   ((Long       )value);
      case   : return CodedOutputStream.computeUInt64SizeNoTag  ((Long       )value);
      case    : return CodedOutputStream.computeInt32SizeNoTag   ((Integer    )value);
      case  : return CodedOutputStream.computeFixed64SizeNoTag ((Long       )value);
      case  : return CodedOutputStream.computeFixed32SizeNoTag ((Integer    )value);
      case     : return CodedOutputStream.computeBoolSizeNoTag    ((Boolean    )value);
      case   : return CodedOutputStream.computeStringSizeNoTag  ((String     )value);
      case    : return CodedOutputStream.computeGroupSizeNoTag   ((MessageLite)value);
      case    :
        if (value instanceof ByteString) {
          return CodedOutputStream.computeBytesSizeNoTag((ByteStringvalue);
        } else {
          return CodedOutputStream.computeByteArraySizeNoTag((byte[]) value);
        }
      case   : return CodedOutputStream.computeUInt32SizeNoTag  ((Integer    )value);
      case return CodedOutputStream.computeSFixed32SizeNoTag((Integer    )value);
      case return CodedOutputStream.computeSFixed64SizeNoTag((Long       )value);
      case   : return CodedOutputStream.computeSInt32SizeNoTag  ((Integer    )value);
      case   : return CodedOutputStream.computeSInt64SizeNoTag  ((Long       )value);
      case :
        if (value instanceof LazyField) {
          return CodedOutputStream.computeLazyFieldSizeNoTag((LazyFieldvalue);
        } else {
          return CodedOutputStream.computeMessageSizeNoTag((MessageLitevalue);
        }
      case :
        if (value instanceof Internal.EnumLite) {
          return CodedOutputStream.computeEnumSizeNoTag(
              ((Internal.EnumLitevalue).getNumber());
        } else {
          return CodedOutputStream.computeEnumSizeNoTag((Integervalue);
        }
    }
    throw new RuntimeException(
      "There is no way to get here, but the compiler thinks otherwise.");
  }

  
Compute the number of bytes needed to encode a particular field.
  public static int computeFieldSize(final FieldDescriptorLite<?> descriptor,
                                     final Object value) {
    WireFormat.FieldType type = descriptor.getLiteType();
    int number = descriptor.getNumber();
    if (descriptor.isRepeated()) {
      if (descriptor.isPacked()) {
        int dataSize = 0;
        for (final Object element : (List<?>)value) {
          dataSize += computeElementSizeNoTag(typeelement);
        }
        return dataSize +
            CodedOutputStream.computeTagSize(number) +
            CodedOutputStream.computeRawVarint32Size(dataSize);
      } else {
        int size = 0;
        for (final Object element : (List<?>)value) {
          size += computeElementSize(typenumberelement);
        }
        return size;
      }
    } else {
      return computeElementSize(typenumbervalue);
    }
  }
New to GrepCode? Check out our FAQ X