下面列出了com.google.protobuf.Descriptors#EnumDescriptor ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
public Collection<Descriptors.EnumDescriptor> findEnumDescriptorsByOption(String optionName) {
Descriptors.FieldDescriptor fieldDescriptor = optionsCatalog.getEnumOptionByName(optionName);
return enumMap.values().stream()
.filter(
descriptor -> {
DescriptorProtos.EnumOptions options = descriptor.getOptions();
UnknownFieldSet.Field unknown =
options.getUnknownFields().getField(fieldDescriptor.getNumber());
if (unknown.getLengthDelimitedList().size()
+ unknown.getFixed64List().size()
+ unknown.getFixed32List().size()
+ unknown.getVarintList().size()
> 0) {
return true;
}
return options.getAllFields().containsKey(fieldDescriptor);
})
.collect(Collectors.toList());
}
private void writeEnumDescriptor(
Descriptors.EnumDescriptor enumType, PathLocation parent, int indent) {
PathLocation location = parent.addEnum(enumType);
writeLeadingComment(commentIndexer.getLocation(location), indent);
indent(indent);
writer.print("enum ");
writer.print(enumType.getName());
writer.println(" {");
writeOptionsForBlock(enumType.getOptions(), indent + 1, "Enum");
for (Descriptors.EnumValueDescriptor value : enumType.getValues()) {
indent(indent + 1);
writer.print(value.getName());
writer.print(" = ");
writer.print(value.getNumber());
writeOptionsForList(value.getOptions(), indent + 1, "EnumValue");
writer.println(";");
}
indent(indent);
writer.print("}");
writeTrailingComment(commentIndexer.getLocation(location), indent);
}
private AvroSchemaItem toEnumField(
List<Descriptors.EnumDescriptor> enumTypes, String enumFullName) {
AvroSchemaItem enumField = new AvroSchemaItem();
final Optional<Descriptors.EnumDescriptor> first =
enumTypes.stream().filter(f -> f.getFullName().startsWith(enumFullName)).findFirst();
enumField.setType("enum");
enumField.setName(first.get().getName());
List<String> values = new ArrayList<>();
first.get().getValues().forEach(item -> values.add(item.getName()));
enumField.setSymbols(values);
return enumField;
}
static Descriptors.EnumValueDescriptor get_enum_value(PbInfoSet pbs, Descriptors.EnumDescriptor enum_desc,
Integer val) {
String name = enum_desc.getFullName();
while (!name.isEmpty() && '.' == name.charAt(0)) {
name = name.substring(1);
}
HashMap<Integer, Descriptors.EnumValueDescriptor> cache_set = pbs.enum_values_descs.getOrDefault(name, null);
if (cache_set == null) {
cache_set = new HashMap<Integer, Descriptors.EnumValueDescriptor>();
pbs.enum_values_descs.put(name, cache_set);
for (Descriptors.EnumValueDescriptor enum_val : enum_desc.getValues()) {
cache_set.put(Integer.valueOf(enum_val.getNumber()), enum_val);
}
}
return cache_set.getOrDefault(val, null);
}
@Test
public void findEnumDescriptorsByOption() throws IOException {
ProtoDomain domain = TestSets.baseMultipleOptions();
Collection<Descriptors.EnumDescriptor> options =
domain.findEnumDescriptorsByOption("test.v1.enum_option");
// TODO Add more sets with enums
Assert.assertEquals(0, options.size());
}
private void addToEnumsMap(
ObjectMapper mapper, String fieldName, List<Descriptors.EnumDescriptor> enums) {
enums.forEach(
item -> {
addToEnumsMap(mapper, fieldName, item);
});
}
private void addToEnumsMap(
ObjectMapper mapper, String fieldName, Descriptors.EnumDescriptor item) {
ObjectNode nodeEnum = mapper.createObjectNode();
ArrayNode nodeArray = nodeEnum.putArray("enum");
item.getValues()
.forEach(
e -> {
nodeArray.add(e.getName());
});
String key = fieldName == null ? item.getFullName() : fieldName;
enumMaps.put(key, nodeEnum);
}
/**
* Fills lookup structure for translating between parquet enum values and Protocol buffer enum values.
* */
private Map<Binary, Descriptors.EnumValueDescriptor> makeLookupStructure(Descriptors.FieldDescriptor enumFieldType) {
Descriptors.EnumDescriptor enumType = enumFieldType.getEnumType();
Map<Binary, Descriptors.EnumValueDescriptor> lookupStructure = new HashMap<Binary, Descriptors.EnumValueDescriptor>();
List<Descriptors.EnumValueDescriptor> enumValues = enumType.getValues();
for (Descriptors.EnumValueDescriptor value : enumValues) {
String name = value.getName();
lookupStructure.put(Binary.fromString(name), enumType.findValueByName(name));
}
return lookupStructure;
}
private EnumResultContainer getOrCreateEnum(Descriptors.EnumDescriptor enumDescriptor) {
String fileName = enumDescriptor.getFullName();
EnumResultContainer enumResult = enumMap.get(fileName);
if (enumResult == null) {
enumResult = new EnumResultContainer();
enumResult.packageName = enumDescriptor.getFile().getPackage();
enumResult.fullName = fileName;
enumMap.put(fileName, enumResult);
}
return enumResult;
}
private static void addEnums(
Map<String, Descriptors.GenericDescriptor> descriptors,
Descriptors.FileDescriptor descriptor,
String packageName) {
for (Descriptors.EnumDescriptor message : descriptor.getEnumTypes()) {
String fullName = packageName + message.getName();
descriptors.put(fullName, message);
}
}
public Descriptors.EnumDescriptor getEnumDescriptorByName(String messageName) {
return enumMap.get(messageName);
}
private void writeFieldType(Descriptors.FieldDescriptor field) {
if (field.isRepeated() && !isMap(field)) {
writer.print("repeated ");
}
switch (field.getType()) {
case UINT64:
writer.print("uint64");
break;
case INT32:
writer.print("int32");
break;
case INT64:
writer.print("int64");
break;
case FIXED64:
writer.print("fixed64");
break;
case FIXED32:
writer.print("fixed32");
break;
case BOOL:
writer.print("bool");
break;
case STRING:
writer.print("string");
break;
case GROUP:
// TODO figure out if we need to support this (proto2)
writer.print("GROUP");
break;
case MESSAGE:
{
Descriptors.Descriptor messageType = field.getMessageType();
if (messageType.getFile() == fd) {
if (isMap(field)) {
writer.print("map<");
writeFieldType(messageType.findFieldByNumber(1));
writer.print(", ");
writeFieldType(messageType.findFieldByNumber(2));
writer.print(">");
} else {
writer.print(messageType.getName());
}
} else {
writer.print(messageType.getFullName());
}
break;
}
case BYTES:
writer.print("bytes");
break;
case UINT32:
writer.print("uint32");
break;
case ENUM:
{
Descriptors.EnumDescriptor enumType = field.getEnumType();
if (enumType.getFile() == fd) {
writer.print(enumType.getName());
} else {
writer.print(enumType.getFullName());
}
break;
}
case SFIXED32:
writer.print("sfixed32");
break;
case SFIXED64:
writer.print("sfixed64");
break;
case SINT32:
writer.print("sint32");
break;
case SINT64:
writer.print("sint64");
break;
case DOUBLE:
writer.print("double");
break;
case FLOAT:
writer.print("float");
break;
}
}
private void write() {
PathLocation location = new PathLocation();
writeLeadingComment(commentIndexer.getSyntaxLocation(), 0);
switch (fd.getSyntax()) {
case PROTO2:
writer.print("syntax = \"proto2\";");
break;
case PROTO3:
writer.print("syntax = \"proto3\";");
break;
default:
break;
}
writeTrailingComment(commentIndexer.getSyntaxLocation(), 0);
writer.println();
if (!fd.getPackage().isEmpty()) {
writeLeadingComment(commentIndexer.getPackageLocation(), 0);
writer.print("package ");
writer.print(fd.getPackage());
writer.print(";");
writeTrailingComment(commentIndexer.getPackageLocation(), 0);
writer.println();
}
List<Descriptors.FileDescriptor> dependencies = fd.getDependencies();
if (dependencies.size() > 0) {
int index = 0;
for (Descriptors.FileDescriptor dependency : dependencies) {
writeLeadingComment(commentIndexer.importLocations.get(index++), 0);
writer.print("import \"");
writer.print(dependency.getName());
writer.print("\";");
writeTrailingComment(commentIndexer.importLocations.get(index++), 0);
}
writer.println();
}
writeOptionsForBlock(fd.getOptions(), 0, "File");
extensions();
for (Descriptors.EnumDescriptor enumDescriptor : fd.getEnumTypes()) {
writer.println();
writeEnumDescriptor(enumDescriptor, location, 0);
}
for (Descriptors.ServiceDescriptor serviceDescriptor : fd.getServices()) {
writer.println();
writeServiceDescriptor(serviceDescriptor, location);
}
for (Descriptors.Descriptor messageType : fd.getMessageTypes()) {
writer.println();
writeMessageDescriptor(messageType, location, 0);
}
}
PathLocation addEnum(Descriptors.EnumDescriptor type) {
return add('E', type.getIndex());
}
private Object handlePrimitive(Tokenizer tokenizer, FieldDescriptor field) throws ParseException {
Object value = null;
switch (field.getType()) {
case INT32:
case SINT32:
case SFIXED32:
value = tokenizer.consumeInt32();
break;
case INT64:
case SINT64:
case SFIXED64:
value = tokenizer.consumeInt64();
break;
case UINT32:
case FIXED32:
value = tokenizer.consumeUInt32();
break;
case UINT64:
case FIXED64:
value = tokenizer.consumeUInt64();
break;
case FLOAT:
value = tokenizer.consumeFloat();
break;
case DOUBLE:
value = tokenizer.consumeDouble();
break;
case BOOL:
value = tokenizer.consumeBoolean();
break;
case STRING:
value = tokenizer.consumeString();
break;
case BYTES:
value = tokenizer.consumeByteString();
break;
case ENUM: {
Descriptors.EnumDescriptor enumType = field.getEnumType();
if (tokenizer.lookingAtInteger()) {
int number = tokenizer.consumeInt32();
value = enumType.findValueByNumber(number);
if (value == null) {
throw tokenizer.parseExceptionPreviousToken("Enum type \""
+ enumType.getFullName()
+ "\" has no value with number "
+ number + ".");
}
} else {
String id = tokenizer.consumeIdentifier();
value = enumType.findValueByName(id);
if (value == null) {
throw tokenizer.parseExceptionPreviousToken("Enum type \""
+ enumType.getFullName()
+ "\" has no value named \""
+ id + "\".");
}
}
break;
}
case MESSAGE:
case GROUP:
throw new RuntimeException("Can't get here.");
}
return value;
}
void setPatch(Descriptors.EnumDescriptor fd, ChangeInfo patch) {
EnumResultContainer resultContainer = getOrCreateEnum(fd);
resultContainer.setPatch(patch);
}
private static Map<String, ?> asRecord(Descriptors.EnumDescriptor descriptor) {
return ImmutableMap.of(
"enum", descriptor.toProto(),
"name", descriptor.getFullName());
}
@Override
Object convertToProtoValue(FieldDescriptor fieldDescriptor, Object value) {
Descriptors.EnumDescriptor enumType = fieldDescriptor.getEnumType();
return enumType.findValueByNumber(((EnumerationType.Value) value).getValue());
}
private FieldProperty parseFieldProperty(Descriptors.FieldDescriptor fieldDescriptor) {
Descriptors.FieldDescriptor.Type type = fieldDescriptor.getType();
FieldTypeEnum fieldTypeEnum = FieldTypeEnum.getByFieldType(type);
FieldProperty fieldProperty = new FieldProperty();
if (fieldDescriptor.isRepeated()) {
// map
if (type == Descriptors.FieldDescriptor.Type.MESSAGE
&& fieldDescriptor.getMessageType().getOptions().getMapEntry()) {
fieldProperty.setType(FieldTypeEnum.OBJECT.getType());
Descriptor messageType = fieldDescriptor.getMessageType();
Descriptors.FieldDescriptor mapValueType = messageType.getFields().get(1);
fieldProperty.setAdditionalProperties(parseFieldProperty(mapValueType));
} else { // array
fieldProperty.setType(FieldTypeEnum.ARRAY.getType());
Items items = new Items();
items.setType(fieldTypeEnum.getType());
items.setFormat(fieldTypeEnum.getFormat());
if (fieldTypeEnum == FieldTypeEnum.OBJECT) {
items.setRef(findRefByType(fieldDescriptor.getMessageType()));
}
fieldProperty.setItems(items);
}
}
// object reference
else if (fieldTypeEnum == FieldTypeEnum.OBJECT) {
fieldProperty.setRef(findRefByType(fieldDescriptor.getMessageType()));
}
// enum
else if (fieldTypeEnum == FieldTypeEnum.ENUM) {
fieldProperty.setType(FieldTypeEnum.ENUM.getType());
List<String> enums = new ArrayList<>();
Descriptors.EnumDescriptor enumDescriptor = fieldDescriptor.getEnumType();
enumDescriptor.getValues().forEach(enumValueDescriptor -> enums.add(enumValueDescriptor.getName()));
fieldProperty.setEnums(enums);
}
// other simple types
else {
fieldProperty.setType(fieldTypeEnum.getType());
fieldProperty.setFormat(fieldTypeEnum.getFormat());
}
return fieldProperty;
}
private void lintOnEnum(Descriptors.EnumDescriptor enu) {}