下面列出了com.google.protobuf.Descriptors#EnumValueDescriptor ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
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 EnumValueChangeInfo diffEnumValue(
Descriptors.EnumValueDescriptor f_ref, Descriptors.EnumValueDescriptor f_new) {
diffOptionsFromEnumValue(f_ref, f_new);
EnumValueChangeInfo.Builder builder = EnumValueChangeInfo.newBuilder();
if (!f_ref.getName().equals(f_new.getName())) {
builder.setChangeType(ChangeType.CHANGED);
builder.setFromName(f_ref.getName());
builder.setToName(f_new.getName());
}
if (isDeprecated(f_ref) != isDeprecated(f_new)) {
builder.setChangeType(ChangeType.CHANGED);
builder.setFromDeprecated(isDeprecated(f_ref));
builder.setToDeprecated(isDeprecated(f_new));
}
if (builder.getChangeType().equals(ChangeType.CHANGED)) {
return builder.build();
}
return null;
}
@SuppressWarnings("unchecked")
static public void dumpConstIntoHashMap(String package_name, HashMap<String, Object> parent,
Descriptors.EnumDescriptor enum_desc) {
String enum_seg = enum_desc.getName();
HashMap<String, Object> enum_root;
if (parent.containsKey(enum_seg)) {
Object node = parent.get(enum_seg);
if (node instanceof HashMap) {
enum_root = (HashMap<String, Object>) node;
} else {
ProgramOptions.getLoger().error("enum name %s.%s conflict.", package_name, enum_seg);
return;
}
} else {
enum_root = new HashMap<String, Object>();
parent.put(enum_seg, enum_root);
}
// 写出所有常量值
for (Descriptors.EnumValueDescriptor enum_val : enum_desc.getValues()) {
enum_root.put(enum_val.getName(), enum_val.getNumber());
}
}
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);
}
/**
* Convert a value into a type that can be stored within a {@link Tuple}.
*
* @param obj the value to convert
* @return the value converted to some {@link Tuple}-encodable type
*/
@Nullable
static Object toTupleAppropriateValue(@Nullable Object obj) {
if (obj instanceof Key.Evaluated.NullStandin) {
return null;
} else if (obj instanceof ByteString) {
return ((ByteString) obj).toByteArray();
} else if (obj instanceof List) {
return toTupleAppropriateList((List<?>) obj);
// Following two are both Internal.EnumLite, so could use that, too.
} else if (obj instanceof ProtocolMessageEnum) {
return ((ProtocolMessageEnum) obj).getNumber();
} else if (obj instanceof Descriptors.EnumValueDescriptor) {
return ((Descriptors.EnumValueDescriptor) obj).getNumber();
} else if (obj instanceof FDBRecordVersion) {
return ((FDBRecordVersion) obj).toVersionstamp(false);
} else {
return obj;
}
}
/**
* set preparedstatement params
*
* @param ps
* @param args
* @return
* @throws SQLException
*/
private void populate(PreparedStatement ps, List<?> args)
throws SQLException {
for (int i = 0; i < args.size(); i++) {
Object o = args.get(i);
if (o instanceof Integer) {
ps.setInt(i + 1, (int) o);
} else if (o instanceof Long) {
ps.setLong(i + 1, (long) o);
} else if (o instanceof String) {
ps.setString(i + 1, (String) o);
} else if (o instanceof Date) {
ps.setDate(i + 1, (Date) o);
} else if (o instanceof Float) {
ps.setFloat(i + 1, (Float) o);
} else if (o instanceof Double) {
ps.setDouble(i + 1, (Double) o);
} else if (o instanceof Date) {
ps.setDate(i + 1, (Date) o);
} else if (o instanceof Timestamp) {
ps.setTimestamp(i + 1, (Timestamp) o);
} else if (o instanceof Descriptors.EnumValueDescriptor) {
ps.setInt(i + 1,
((Descriptors.EnumValueDescriptor) o).getNumber());
} else if(o instanceof Boolean){
ps.setBoolean(i+1, (Boolean)o);
} else {
ps.setObject(i+1, o);
}
}
}
/**
* Translates given parquet enum value to protocol buffer enum value.
* @throws org.apache.parquet.io.InvalidRecordException is there is no corresponding value.
* */
private Descriptors.EnumValueDescriptor translateEnumValue(Binary binaryValue) {
Descriptors.EnumValueDescriptor protoValue = enumLookup.get(binaryValue);
if (protoValue == null) {
Set<Binary> knownValues = enumLookup.keySet();
String msg = "Illegal enum value \"" + binaryValue + "\""
+ " in protocol buffer \"" + fieldType.getFullName() + "\""
+ " legal values are: \"" + knownValues + "\"";
throw new InvalidRecordException(msg);
}
return protoValue;
}
@Override
public void setDictionary(Dictionary dictionary) {
dict = new Descriptors.EnumValueDescriptor[dictionary.getMaxId() + 1];
for (int i = 0; i <= dictionary.getMaxId(); i++) {
Binary binaryValue = dictionary.decodeToBinary(i);
dict[i] = translateEnumValue(binaryValue);
}
}
@Override
public Object getValue() {
if (descriptor.isRepeated()) {
List<Descriptors.EnumValueDescriptor> enumValues = ((List<Descriptors.EnumValueDescriptor>) (fieldValue));
List<String> enumStrValues = new ArrayList<>();
for (Descriptors.EnumValueDescriptor enumVal : enumValues) {
enumStrValues.add(enumVal.toString());
}
return enumStrValues;
}
return fieldValue.toString();
}
private static Object getRealFieldValue(Object valueObject) {
if (valueObject != null && valueObject instanceof Descriptors.EnumValueDescriptor) {
return ((Descriptors.EnumValueDescriptor) valueObject).getName();
} else {
return valueObject;
}
}
private static Object getProtoFieldValueByName(Message message, String fieldName) {
Object field = message.getField(message.getDescriptorForType().findFieldByName(fieldName));
if(field instanceof Descriptors.EnumValueDescriptor){
return ((Descriptors.EnumValueDescriptor) field).getName();
} else {
return field;
}
}
public static Object toTupleItem(@Nullable Object item) {
if (item instanceof ByteString) {
return ((ByteString) item).toByteArray();
// Following two are both Internal.EnumLite, so could use that, too.
} else if (item instanceof ProtocolMessageEnum) {
return ((ProtocolMessageEnum) item).getNumber();
} else if (item instanceof Descriptors.EnumValueDescriptor) {
return ((Descriptors.EnumValueDescriptor) item).getNumber();
} else if (item instanceof FDBRecordVersion) {
return ((FDBRecordVersion) item).toVersionstamp();
} else {
return item;
}
}
/**
* Normalize a value so that it compares equal to anything with the same {@link Tuple} representation.
* The value that is returned cannot necessarily be packed by a {@code Tuple} (for example,
* a <code>byte[]</code> is returned as a {@link ByteString}), but it does implement {@link Object#equals(Object)}
* and {@link Object#hashCode()}, so the value can be used in hash-based data structures like
* {@link java.util.HashSet HashSet}s and {@link java.util.HashMap HashMap}s. In other words, it should
* bethe case that:
*
* <pre> {@code
* Objects.equals(toTupleEquivalentValue(value1), toTupleEquivalentValue(value2))
* == Arrays.equals(Tuple.from(value1).pack(), Tuple.from(value2).pack())
* }</pre>
*
* <p>
* for any two values {@code value1} and {@code value2}.
* </p>
*
* <p>
* This will only return {@code null} if {@link #toTupleAppropriateValue(Object)} would return {@code null}
* on the same input. If the object is already in
* </p>
*
* @param obj the value to normalize
* @return a value that has the same representation when {@link Tuple}-encoded
*/
@Nullable
static Object toTupleEquivalentValue(@Nullable Object obj) {
if (obj == null || obj instanceof Key.Evaluated.NullStandin) {
return null;
} else if (obj instanceof List<?>) {
List<?> list = (List<?>)obj;
return toTupleEquivalentList(list);
} else if (obj instanceof Tuple) {
return toTupleEquivalentList(((Tuple)obj).getItems());
} else if (obj instanceof byte[]) {
return ByteString.copyFrom((byte[]) obj);
} else if ((obj instanceof Byte) || (obj instanceof Short) || (obj instanceof Integer)) {
return ((Number)obj).longValue();
} else if (obj instanceof BigInteger) {
BigInteger bigInt = (BigInteger)obj;
if (bigInt.compareTo(BIG_INT_MIN_LONG) > 0 && bigInt.compareTo(BIG_INT_MAX_LONG) < 0) {
return bigInt.longValue();
} else {
return bigInt;
}
} else if (obj instanceof ProtocolMessageEnum) {
return (long)((ProtocolMessageEnum)obj).getNumber();
} else if (obj instanceof Descriptors.EnumValueDescriptor) {
return (long)((Descriptors.EnumValueDescriptor)obj).getNumber();
} else if (obj instanceof FDBRecordVersion) {
return ((FDBRecordVersion)obj).toVersionstamp(false);
} else {
return obj;
}
}
@Test
public void duplicateEnumSubspaceKey() {
// This exact use case is somewhat contrived, but one could imagine maintaining an enum with one entry per index
RecordMetaDataBuilder metaData = RecordMetaData.newBuilder().setRecords(TestRecords1Proto.getDescriptor());
final Descriptors.EnumValueDescriptor enumValueDescriptor = TestRecordsEnumProto.MyShapeRecord.Size.SMALL.getValueDescriptor();
metaData.getIndex("MySimpleRecord$str_value_indexed").setSubspaceKey((long)enumValueDescriptor.getNumber());
metaData.getIndex("MySimpleRecord$num_value_3_indexed").setSubspaceKey(enumValueDescriptor);
assertInvalid("Same subspace key " + enumValueDescriptor.getNumber() + " used by both", metaData);
}
PathLocation addEnunValue(Descriptors.EnumValueDescriptor type) {
return add('e', type.getIndex());
}
public void add(Descriptors.EnumValueDescriptor value, RuleInfo ruleInfo) {
EnumValueResultContainer methodResultContainer = getOrCreateValueContainer(value);
methodResultContainer.add(ruleInfo);
}
public void addPatch(Descriptors.EnumValueDescriptor value, EnumValueChangeInfo patch) {
EnumValueResultContainer valueResultContainer = getOrCreateValueContainer(value);
valueResultContainer.addPatch(patch);
}
/**
* 根据请求参数获取对应参数列表的值
* <p>
* 目前的方法是将参数列表中的各参数值转化为String拼接起来。 <br>
* 对于参数列表也有一定的限制，不支持参数在嵌套的层次中，即必须在第一层。 <br>
* 如果客户端为未配置参数列表，或者参数值列表不正确，则取按照参数名升序获取第一个非嵌套类型参数的参数值返回。 <br>
* </p>
*
* @author sxp
* @since 2019/2/1
*/
public static Object getArgumentFromRequest(Object request) {
Map<String, Boolean> validArgs = ConsistentHashArguments.getValidArgs();
boolean isGetFirst = false;
if (validArgs.size() == 0) {
isGetFirst = true;
}
// 遍历入参的所有参数，取出参数列表对应的参数值
GeneratedMessageV3 param;
try {
param = GeneratedMessageV3.class.cast(request);
} catch (ClassCastException e) {
return ConsistentHashArguments.NULL_VALUE;// 入参不是GeneratedMessageV3的子类
}
Map<Descriptors.FieldDescriptor, Object> fieldMap = param.getAllFields();
Descriptors.FieldDescriptor field;
String name;
String value;
Descriptors.FieldDescriptor.JavaType type;
StringBuilder sb = new StringBuilder();
for (Iterator<Descriptors.FieldDescriptor> keys = fieldMap.keySet().iterator(); keys.hasNext(); ) {
field = keys.next();
name = field.getName();
if (!validArgs.containsKey(name) && !isGetFirst) {
continue;
}
type = field.getJavaType();
if (type.equals(Descriptors.FieldDescriptor.JavaType.MESSAGE)) {
// 嵌套数据类型
} else if (type.equals(Descriptors.FieldDescriptor.JavaType.ENUM)) {
Descriptors.EnumValueDescriptor en = (Descriptors.EnumValueDescriptor) fieldMap.get(field);
value = String.valueOf(en.toProto().getNumber());
sb.append(value);
} else {
value = String.valueOf(fieldMap.get(field));
sb.append(value);
}
if (isGetFirst && sb.length() > 0) {
break;
}
}
String result = sb.toString();
if (StringUtils.isEmpty(result)) {
return String.valueOf(System.currentTimeMillis());
} else {
return result;
}
}
@Override
final public void addBinary(Binary binaryValue) {
Descriptors.EnumValueDescriptor protoValue = translateEnumValue(binaryValue);
parent.add(protoValue);
}
static Object objToMessageObjInner(Builder b, Object value, Descriptors.FieldDescriptor field, boolean isRepeated) {
switch (field.getType()) {
case INT32:
case SINT32:
case SFIXED32:
return TypeSafe.anyToInt(value);
case INT64:
case SINT64:
case SFIXED64:
if( value instanceof Date)
return ((Date)value).getTime();
return TypeSafe.anyToLong(value);
case BOOL:
return TypeSafe.anyToBool(value);
case FLOAT:
return TypeSafe.anyToFloat(value);
case DOUBLE:
return TypeSafe.anyToDouble(value);
case UINT32:
case FIXED32:
return (int) (TypeSafe.anyToLong(value) & 0x00000000FFFFFFFFL);
case UINT64:
case FIXED64:
BigInteger bi = new BigInteger(value.toString());
return bi.longValue();
case STRING:
if( value instanceof Date)
return formatDate((Date)value);
return TypeSafe.anyToString(value);
case BYTES: {
if (value instanceof ByteString) {
return value;
}
if (value instanceof String) {
byte[] bb = getBytes((String) value);
if (bb == null) return null;
return ByteString.copyFrom(bb);
}
if (value instanceof byte[]) {
return ByteString.copyFrom((byte[]) value);
}
}
return null;
case ENUM:
Descriptors.EnumDescriptor ed = field.getEnumType();
Descriptors.EnumValueDescriptor evd = ed.findValueByName(value.toString());
if (evd == null) {
evd = ed.findValueByNumber(TypeSafe.anyToInt(value));
}
if (evd == null) return null;
return evd;
case MESSAGE:
Object bean = value;
Builder b2 = isRepeated ?
getRepeatedFieldBuilder(b, field.getName()) :
getFieldBuilder(b, field);
for (Descriptors.FieldDescriptor subfield : b2.getDescriptorForType().getFields()) {
String subName = subfield.getName();
Object subValue = getValue(bean, subName);
if (subValue == null) continue;
if (subfield.isRepeated()) {
objToMessageObjRepeated(b2, subValue, subfield);
} else {
objToMessageObj(b2, subValue, subfield);
}
}
return isRepeated ? null : b2.build();
default:
return null;
}
}