Java Descriptor.findFieldByName方法代码示例

import com.google.protobuf.Descriptors.Descriptor; //导入方法依赖的package包/类
private void mergeMapField(FieldDescriptor field, JsonElement json, Message.Builder builder)
    throws InvalidProtocolBufferException {
  if (!(json instanceof JsonObject)) {
    throw new InvalidProtocolBufferException("Expect a map object but found: " + json);
  }
  Descriptor type = field.getMessageType();
  FieldDescriptor keyField = type.findFieldByName("key");
  FieldDescriptor valueField = type.findFieldByName("value");
  if (keyField == null || valueField == null) {
    throw new InvalidProtocolBufferException("Invalid map field: " + field.getFullName());
  }
  JsonObject object = (JsonObject) json;
  for (Map.Entry<String, JsonElement> entry : object.entrySet()) {
    Message.Builder entryBuilder = builder.newBuilderForField(field);
    Object key = parseFieldValue(keyField, new JsonPrimitive(entry.getKey()), entryBuilder);
    Object value = parseFieldValue(valueField, entry.getValue(), entryBuilder);
    if (value == null) {
      throw new InvalidProtocolBufferException("Map value cannot be null.");
    }
    entryBuilder.setField(keyField, key);
    entryBuilder.setField(valueField, value);
    builder.addRepeatedField(field, entryBuilder.build());
  }
}
 

import com.google.protobuf.Descriptors.Descriptor; //导入方法依赖的package包/类
ProtoFieldInfo(FieldDescriptor field, Message containingPrototype) {
  this.field = checkNotNull(field, "field");
  this.containingPrototype = checkNotNull(containingPrototype, "containingPrototype");
  builderClass = containingPrototype.newBuilderForType().getClass();

  camelCaseName = underscoresToUpperCamelCase(field.getName());

  if (field.isMapField()) {
    Descriptor mapType = field.getMessageType();
    mapKeyField = new ProtoFieldInfo(mapType.findFieldByName("key"), containingPrototype);
    mapValueField = new ProtoFieldInfo(mapType.findFieldByName("value"), containingPrototype);
  } else {
    mapKeyField = null;
    mapValueField = null;
  }
}
 

import com.google.protobuf.Descriptors.Descriptor; //导入方法依赖的package包/类
/** Prints google.protobuf.ListValue */
private void printListValue(MessageOrBuilder message) throws IOException {
  Descriptor descriptor = message.getDescriptorForType();
  FieldDescriptor field = descriptor.findFieldByName("values");
  if (field == null) {
    throw new InvalidProtocolBufferException("Invalid ListValue type.");
  }
  printRepeatedFieldValue(field, message.getField(field));
}
 

import com.google.protobuf.Descriptors.Descriptor; //导入方法依赖的package包/类
@SuppressWarnings("rawtypes")
private void printMapFieldValue(FieldDescriptor field, Object value) throws IOException {
  Descriptor type = field.getMessageType();
  FieldDescriptor keyField = type.findFieldByName("key");
  FieldDescriptor valueField = type.findFieldByName("value");
  if (keyField == null || valueField == null) {
    throw new InvalidProtocolBufferException("Invalid map field.");
  }
  generator.print("{" + blankOrNewLine);
  generator.indent();
  boolean printedElement = false;
  for (Object element : (List) value) {
    Message entry = (Message) element;
    Object entryKey = entry.getField(keyField);
    Object entryValue = entry.getField(valueField);
    if (printedElement) {
      generator.print("," + blankOrNewLine);
    } else {
      printedElement = true;
    }
    // Key fields are always double-quoted.
    printSingleFieldValue(keyField, entryKey, true);
    generator.print(":" + blankOrSpace);
    printSingleFieldValue(valueField, entryValue);
  }
  if (printedElement) {
    generator.print(blankOrNewLine);
  }
  generator.outdent();
  generator.print("}");
}
 

import com.google.protobuf.Descriptors.Descriptor; //导入方法依赖的package包/类
/** Prints wrapper types (e.g., google.protobuf.Int32Value) */
private void printWrapper(MessageOrBuilder message) throws IOException {
  Descriptor descriptor = message.getDescriptorForType();
  FieldDescriptor valueField = descriptor.findFieldByName("value");
  if (valueField == null) {
    throw new InvalidProtocolBufferException("Invalid Wrapper type.");
  }
  // When formatting wrapper types, we just print its value field instead of
  // the whole message.
  printSingleFieldValue(valueField, message.getField(valueField));
}
 

import com.google.protobuf.Descriptors.Descriptor; //导入方法依赖的package包/类
private void mergeListValue(JsonElement json, Message.Builder builder)
    throws InvalidProtocolBufferException {
  Descriptor descriptor = builder.getDescriptorForType();
  FieldDescriptor field = descriptor.findFieldByName("values");
  if (field == null) {
    throw new InvalidProtocolBufferException("Invalid ListValue type.");
  }
  mergeRepeatedField(field, json, builder);
}
 

import com.google.protobuf.Descriptors.Descriptor; //导入方法依赖的package包/类
private void mergeWrapper(JsonElement json, Message.Builder builder)
    throws InvalidProtocolBufferException {
  Descriptor type = builder.getDescriptorForType();
  FieldDescriptor field = type.findFieldByName("value");
  if (field == null) {
    throw new InvalidProtocolBufferException("Invalid wrapper type: " + type.getFullName());
  }
  builder.setField(field, parseFieldValue(field, json, builder));
}
 

import com.google.protobuf.Descriptors.Descriptor; //导入方法依赖的package包/类
/** Prints google.protobuf.Struct */
private void printStruct(MessageOrBuilder message) throws IOException {
  Descriptor descriptor = message.getDescriptorForType();
  FieldDescriptor field = descriptor.findFieldByName("fields");
  if (field == null) {
    throw new InvalidProtocolBufferException("Invalid Struct type.");
  }
  // Struct is formatted as a map object.
  printMapFieldValue(field, message.getField(field));
}
 

import com.google.protobuf.Descriptors.Descriptor; //导入方法依赖的package包/类
private void mergeStruct(JsonElement json, Message.Builder builder)
    throws InvalidProtocolBufferException {
  Descriptor descriptor = builder.getDescriptorForType();
  FieldDescriptor field = descriptor.findFieldByName("fields");
  if (field == null) {
    throw new InvalidProtocolBufferException("Invalid Struct type.");
  }
  mergeMapField(field, json, builder);
}
 

import com.google.protobuf.Descriptors.Descriptor; //导入方法依赖的package包/类
private void mergeAny(JsonElement json, Message.Builder builder)
    throws InvalidProtocolBufferException {
  Descriptor descriptor = builder.getDescriptorForType();
  FieldDescriptor typeUrlField = descriptor.findFieldByName("type_url");
  FieldDescriptor valueField = descriptor.findFieldByName("value");
  // Validates type of the message. Note that we can't just cast the message
  // to com.google.protobuf.Any because it might be a DynamicMessage.
  if (typeUrlField == null
      || valueField == null
      || typeUrlField.getType() != FieldDescriptor.Type.STRING
      || valueField.getType() != FieldDescriptor.Type.BYTES) {
    throw new InvalidProtocolBufferException("Invalid Any type.");
  }

  if (!(json instanceof JsonObject)) {
    throw new InvalidProtocolBufferException("Expect message object but got: " + json);
  }
  JsonObject object = (JsonObject) json;
  if (object.entrySet().isEmpty()) {
    return; // builder never modified, so it will end up building the default instance of Any
  }
  JsonElement typeUrlElement = object.get("@type");
  if (typeUrlElement == null) {
    throw new InvalidProtocolBufferException("Missing type url when parsing: " + json);
  }
  String typeUrl = typeUrlElement.getAsString();
  Descriptor contentType = registry.find(getTypeName(typeUrl));
  if (contentType == null) {
    throw new InvalidProtocolBufferException("Cannot resolve type: " + typeUrl);
  }
  builder.setField(typeUrlField, typeUrl);
  Message.Builder contentBuilder =
      DynamicMessage.getDefaultInstance(contentType).newBuilderForType();
  WellKnownTypeParser specialParser = wellKnownTypeParsers.get(contentType.getFullName());
  if (specialParser != null) {
    JsonElement value = object.get("value");
    if (value != null) {
      specialParser.merge(this, value, contentBuilder);
    }
  } else {
    mergeMessage(json, contentBuilder, true);
  }
  builder.setField(valueField, contentBuilder.build().toByteString());
}
 

import com.google.protobuf.Descriptors.Descriptor; //导入方法依赖的package包/类
/**
 * Parse a single field from {@code tokenizer} and merge it into {@code builder}. If a ',' is
 * detected after the field ends, the next field will be parsed automatically
 */
protected void mergeField(Tokenizer tokenizer,
                               ExtensionRegistry extensionRegistry,
                               Message.Builder builder) throws ParseException {
    FieldDescriptor field;
    Descriptor type = builder.getDescriptorForType();
    ExtensionRegistry.ExtensionInfo extension = null;
    boolean unknown = false;

    String name = tokenizer.consumeIdentifier();
    field = type.findFieldByName(name);

    // Group names are expected to be capitalized as they appear in the
    // .proto file, which actually matches their type names, not their field
    // names.
    if (field == null) {
        // Explicitly specify US locale so that this code does not break when
        // executing in Turkey.
        String lowerName = name.toLowerCase(Locale.US);
        field = type.findFieldByName(lowerName);
        // If the case-insensitive match worked but the field is NOT a group,
        if ((field != null) && (field.getType() != FieldDescriptor.Type.GROUP)) {
            field = null;
        }
    }
    // Again, special-case group names as described above.
    if ((field != null) && (field.getType() == FieldDescriptor.Type.GROUP)
        && !field.getMessageType().getName().equals(name)) {
        field = null;
    }

    // Last try to lookup by field-index if 'name' is numeric,
    // which indicates a possible unknown field
    if (field == null && TextUtils.isDigits(name)) {
        field = type.findFieldByNumber(Integer.parseInt(name));
        unknown = true;
    }

    // Finally, look for extensions
    extension = extensionRegistry.findExtensionByName(name);
    if (extension != null) {
        if (extension.descriptor.getContainingType() != type) {
          throw tokenizer.parseExceptionPreviousToken("Extension \"" + name
                                                      + "\" does not extend message type \""
                                                      + type.getFullName() + "\".");
        }
        field = extension.descriptor;
    }

    // Disabled throwing exception if field not found, since it could be a different version.
    if (field == null) {
        handleMissingField(tokenizer, extensionRegistry, builder);
        //throw tokenizer.parseExceptionPreviousToken("Message type \"" + type.getFullName()
        //                                            + "\" has no field named \"" + name
        //                                            + "\".");
    }

    if (field != null) {
        tokenizer.consume(":");
        boolean array = tokenizer.tryConsume("[");

        if (array) {
            while (!tokenizer.tryConsume("]")) {
                handleValue(tokenizer, extensionRegistry, builder, field, extension, unknown);
                tokenizer.tryConsume(",");
            }
        } else {
            handleValue(tokenizer, extensionRegistry, builder, field, extension, unknown);
        }
    }

    if (tokenizer.tryConsume(",")) {
        // Continue with the next field
        mergeField(tokenizer, extensionRegistry, builder);
    }
}
 

import com.google.protobuf.Descriptors.Descriptor; //导入方法依赖的package包/类
private static FieldDescriptor getField(Descriptor descriptor, String name) {
  return descriptor.findFieldByName(name);
}
 

import com.google.protobuf.Descriptors.Descriptor; //导入方法依赖的package包/类
/** Prints google.protobuf.Any */
private void printAny(MessageOrBuilder message) throws IOException {
  if (Any.getDefaultInstance().equals(message)) {
    generator.print("{}");
    return;
  }
  Descriptor descriptor = message.getDescriptorForType();
  FieldDescriptor typeUrlField = descriptor.findFieldByName("type_url");
  FieldDescriptor valueField = descriptor.findFieldByName("value");
  // Validates type of the message. Note that we can't just cast the message
  // to com.google.protobuf.Any because it might be a DynamicMessage.
  if (typeUrlField == null
      || valueField == null
      || typeUrlField.getType() != FieldDescriptor.Type.STRING
      || valueField.getType() != FieldDescriptor.Type.BYTES) {
    throw new InvalidProtocolBufferException("Invalid Any type.");
  }
  String typeUrl = (String) message.getField(typeUrlField);
  String typeName = getTypeName(typeUrl);
  Descriptor type = registry.find(typeName);
  if (type == null) {
    throw new InvalidProtocolBufferException("Cannot find type for url: " + typeUrl);
  }
  ByteString content = (ByteString) message.getField(valueField);
  Message contentMessage =
      DynamicMessage.getDefaultInstance(type).getParserForType().parseFrom(content);
  WellKnownTypePrinter printer = wellKnownTypePrinters.get(typeName);
  if (printer != null) {
    // If the type is one of the well-known types, we use a special
    // formatting.
    generator.print("{" + blankOrNewLine);
    generator.indent();
    generator.print("\"@type\":" + blankOrSpace + gson.toJson(typeUrl) + "," + blankOrNewLine);
    generator.print("\"value\":" + blankOrSpace);
    printer.print(this, contentMessage);
    generator.print(blankOrNewLine);
    generator.outdent();
    generator.print("}");
  } else {
    // Print the content message instead (with a "@type" field added).
    print(contentMessage, typeUrl);
  }
}