@Override public Type getJavaType() { return thriftType.getJavaType(); }
private Method getReadMethod(ThriftType thriftType) { if (ReflectionHelper.isArray(thriftType.getJavaType())) { return ARRAY_READ_METHODS.get(thriftType.getJavaType()); } return READ_METHODS.get(thriftType.getProtocolType()); }
public ThriftContext(String namespace, List<String> includes, List<ThriftType> thriftTypes, List<ThriftServiceMetadata> thriftServices, Map<String, String> namespaceMap) { this.namespace = namespace; this.includes = includes; for (ThriftType t: thriftTypes) { switch (t.getProtocolType()) { case STRUCT: this.thriftStructs.add(t.getStructMetadata()); break; case ENUM: this.thriftEnums.add(t.getEnumMetadata()); break; default: throw new IllegalStateException("Unknown protocol type: " + t.getProtocolType()); } } this.thriftServices = thriftServices; customNamespaces = namespaceMap; }
public static ThriftType array(ThriftType valueType) { checkNotNull(valueType, "valueType is null"); Class<?> javaType = ReflectionHelper.getArrayOfType(valueType.getJavaType()); return new ThriftType(ThriftProtocolType.LIST, javaType, null, valueType); }
switch (type.getProtocolType()) { case STRUCT: { return factory.generateThriftTypeCodec(ThriftCodecManager.this, type.getStructMetadata()); return new MapThriftCodec<>(type, getElementCodec(type.getKeyTypeReference()), getElementCodec(type.getValueTypeReference())); return new SetThriftCodec<>(type, getElementCodec(type.getValueTypeReference())); return new ListThriftCodec<>(type, getElementCodec(type.getValueTypeReference())); if (type.isCoerced()) { ThriftCodec<?> codec = getCodec(type.getUncoercedType()); TypeCoercion coercion = catalog.getDefaultCoercion(type.getJavaType()); return new CoercionThriftCodec<>(codec, coercion); checkState(type.equals(top), "ThriftCatalog circularity detection stack is corrupt: expected %s, but got %s", type,
Class<?> enumClass = TypeToken.of(javaType).getRawType(); ThriftEnumMetadata<? extends Enum<?>> thriftEnumMetadata = getThriftEnumMetadata(enumClass); return enumType(thriftEnumMetadata); return array(getThriftType(elementType)); return map(getThriftType(mapKeyType), getThriftType(mapValueType)); return set(getThriftType(elementType)); return list(getThriftType(elementType)); return struct(structMetadata); return struct(structMetadata);
public String toString(ThriftType t) { switch (t.getProtocolType()) { case BOOL: return "bool"; case BYTE: return "byte"; case DOUBLE: return "double"; case I16: return "i16"; case I32: return "i32"; case I64: return "i64"; case ENUM: return prefix(t) + t.getEnumMetadata().getEnumName(); case MAP: return "map<" + toString(t.getKeyTypeReference().get()) + ", " + toString(t.getValueTypeReference().get()) + ">"; case SET: return "set<" + toString(t.getValueTypeReference().get()) + ">"; case LIST: return "list<" + toString(t.getValueTypeReference().get()) + ">"; // void is encoded as a struct case STRUCT: return t.equals(ThriftType.VOID) ? "void" : prefix(t) + t.getStructMetadata().getStructName(); case STRING: return "string"; case BINARY: return "binary"; } throw new IllegalStateException("Bad protocol type" + t.getProtocolType()); }
@Test public void testCoercedCollection() throws Exception { testRoundTripSerialize(set(I32.coerceTo(Integer.class)), ImmutableSet.of(1, 2, 3)); testRoundTripSerialize(list(I32.coerceTo(Integer.class)), ImmutableList.of(4, 5, 6)); testRoundTripSerialize(map(I32.coerceTo(Integer.class), I32.coerceTo(Integer.class)), ImmutableMap.of(1, 2, 2, 4, 3, 9)); }
if (thriftType.isCoerced()) { coercion = catalog.getDefaultCoercion(thriftType.getJavaType());
verifyCoercionMethod(method); ThriftType thriftType = getThriftType(method.getGenericReturnType()); ThriftType coercedType = thriftType.coerceTo(method.getGenericParameterTypes()[0]); verifyCoercionMethod(method); ThriftType thriftType = getThriftType(method.getGenericParameterTypes()[0]); ThriftType coercedType = thriftType.coerceTo(method.getGenericReturnType()); type); TypeCoercion coercion = new TypeCoercion(type, toThriftMethod, fromThriftMethod); coercions.put(type.getJavaType(), coercion);
@Override public ThriftProtocolType getProtocolType() { return thriftType.getProtocolType(); }
@Test public void testCollectionThriftTypes() throws Exception { testRoundTripSerialize(set(STRING), ImmutableSet.of("some string", "another string")); testRoundTripSerialize(list(STRING), ImmutableList.of("some string", "another string")); testRoundTripSerialize(map(STRING, STRING), ImmutableMap.of("1", "one", "2", "two")); }
private boolean isProtocolTypeJavaPrimitive(ThriftFieldMetadata field) { if (field.getThriftType().isCoerced()) { return isJavaPrimitive(TypeToken.of(field.getThriftType().getUncoercedType().getJavaType())); } else { return isJavaPrimitive(TypeToken.of(field.getThriftType().getJavaType())); } }
private boolean verifyField(ThriftType t) { ThriftProtocolType proto = t.getProtocolType(); if (proto == ThriftProtocolType.SET || proto == ThriftProtocolType.LIST) { return verifyElementType(t.getValueTypeReference()); } else if (proto == ThriftProtocolType.MAP) { // no short-circuit return verifyElementType(t.getKeyTypeReference()) & verifyElementType(t.getValueTypeReference()); } else { if (knownTypes.contains(t)) { return true; } if (includeMap.containsKey(t)) { usedIncludedTypes.add(t); return true; } if (recursive) { // recursive but type is unknown - add it to the list and recurse thriftTypes.add(t); return verifyStruct(t, true); } return false; } }
private boolean verifyStruct(ThriftType t, boolean quiet) { if (t.getProtocolType() == ThriftProtocolType.ENUM) { knownTypes.add(t); return true; } ThriftStructMetadata metadata = t.getStructMetadata(); boolean ok = true; knownTypes.add(t); for (ThriftFieldMetadata fieldMetadata: metadata.getFields(FieldKind.THRIFT_FIELD)) { if (!recursive && fieldMetadata.isTypeReferenceRecursive()) { continue; } boolean fieldOk = verifyField(fieldMetadata.getThriftType()); if (!fieldOk) { ok = false; if (!quiet) { LOG.error("Unknown type %s in %s.%s", thriftTypeRenderer.toString(fieldMetadata.getThriftType()), metadata.getStructName(), fieldMetadata.getName()); } } } if (!ok) { knownTypes.remove(t); } return ok; }
@Test public void testEnum() throws Exception { ThriftEnumMetadata<Fruit> fruitEnumMetadata = new ThriftEnumMetadataBuilder<>(Fruit.class).build(); ThriftEnumMetadata<Letter> letterEnumMetadata = new ThriftEnumMetadataBuilder<>(Letter.class).build(); testRoundTripSerialize(Fruit.CHERRY); testRoundTripSerialize(Letter.C); testRoundTripSerialize(enumType(fruitEnumMetadata), Fruit.CHERRY); testRoundTripSerialize(enumType(letterEnumMetadata), Letter.C); testRoundTripSerialize(list(enumType(fruitEnumMetadata)), ImmutableList.copyOf(Fruit.values())); testRoundTripSerialize(list(enumType(letterEnumMetadata)), ImmutableList.copyOf(Letter.values())); }
public static ThriftType struct(ThriftStructMetadata structMetadata) { return new ThriftType(structMetadata); }
@Override public ThriftType getType() { return ThriftType.array(ThriftType.I32); }
@Override public String toString() { final StringBuilder sb = new StringBuilder(); sb.append("ThriftType"); sb.append("{"); sb.append(protocolType).append(" ").append(javaType); if (structMetadata != null) { sb.append(" ").append(getStructMetadata().getStructClass().getName()); } else if (keyTypeReference != null) { sb.append(" keyTypeReference=").append(keyTypeReference); sb.append(", valueTypeReference=").append(valueTypeReference); } else if (valueTypeReference != null) { sb.append(" valueTypeReference=").append(valueTypeReference); } sb.append('}'); return sb.toString(); } }
public static <E> ThriftType set(ThriftType valueType) { Preconditions.checkNotNull(valueType, "valueType is null"); return set(new DefaultThriftTypeReference(valueType)); }