@Override protected Type convertDefault(TypeDescriptor<?> type) { return type.getType(); }
@Override protected Type convertArray(TypeDescriptor<?> type) { return createListType(type).getType(); }
private static String formatType(TypeDescriptor<?> t) { return ReflectHelpers.TYPE_SIMPLE_DESCRIPTION.apply(t.getType()); }
/** * If {@code coderType} is a subclass of {@code Coder<T>} for a specific type {@code T}, returns * {@code T.class}. */ @SuppressWarnings({"rawtypes", "unchecked"}) public static TypeDescriptor getCodedType(TypeDescriptor coderDescriptor) { ParameterizedType coderType = (ParameterizedType) coderDescriptor.getSupertype(Coder.class).getType(); TypeDescriptor codedType = TypeDescriptor.of(coderType.getActualTypeArguments()[0]); return codedType; } }
@Override public <T> Coder<T> coderFor(TypeDescriptor<T> typeDescriptor, List<? extends Coder<?>> componentCoders) throws CannotProvideCoderException { Type t = typeDescriptor.getType(); if (IndexedRecord.class.isAssignableFrom(typeDescriptor.getRawType())) { Coder<T> c = LazyAvroCoder.<T> of(); return c; } throw new CannotProvideCoderException(String.format("Cannot provide %s because %s is not implement IndexedRecord", LazyAvroCoder.class.getSimpleName(), typeDescriptor)); } }
@Override public <T> Coder<T> coderFor(TypeDescriptor<T> typeDescriptor, List<? extends Coder<?>> componentCoders) throws CannotProvideCoderException { Type t = typeDescriptor.getType(); if (IndexedRecord.class.isAssignableFrom(typeDescriptor.getRawType())) { Coder<T> c = LazyAvroCoder.<T> of(); return c; } throw new CannotProvideCoderException(String.format("Cannot provide %s because %s is not implement IndexedRecord", LazyAvroCoder.class.getSimpleName(), typeDescriptor)); } }
@Override public RelDataType getReturnType(RelDataTypeFactory typeFactory) { return CalciteUtils.sqlTypeWithAutoCast(typeFactory, combineFn.getOutputType().getType()); } }
@SuppressWarnings("unchecked") private static Implementation getMapType(TypeDescriptor valueType, int index) { if (valueType.isSubtypeOf(TypeDescriptor.of(Map.class))) { TypeDescriptor<Collection<?>> map = valueType.getSupertype(Map.class); if (map.getType() instanceof ParameterizedType) { ParameterizedType ptype = (ParameterizedType) map.getType(); java.lang.reflect.Type[] params = ptype.getActualTypeArguments(); return FixedValue.reference(params[index]); } else { throw new RuntimeException("Map type is not parameterized! " + map); } } return FixedValue.nullValue(); } }
private static FieldType getMapFieldType(TypeDescriptor typeDescriptor) { TypeDescriptor<Collection<?>> map = typeDescriptor.getSupertype(Map.class); if (map.getType() instanceof ParameterizedType) { ParameterizedType ptype = (ParameterizedType) map.getType(); java.lang.reflect.Type[] params = ptype.getActualTypeArguments(); return FieldType.map( fieldTypeForJavaType(TypeDescriptor.of(params[0])), fieldTypeForJavaType(TypeDescriptor.of(params[1]))); } throw new RuntimeException("Cound not determine array parameter type for field."); } }
@SuppressWarnings("unchecked") static Implementation getArrayComponentType(TypeDescriptor valueType) { if (valueType.isArray()) { Type component = valueType.getComponentType().getType(); if (!component.equals(byte.class)) { return FixedValue.reference(component); } } else if (valueType.isSubtypeOf(TypeDescriptor.of(Collection.class))) { TypeDescriptor<Collection<?>> collection = valueType.getSupertype(Collection.class); if (collection.getType() instanceof ParameterizedType) { ParameterizedType ptype = (ParameterizedType) collection.getType(); java.lang.reflect.Type[] params = ptype.getActualTypeArguments(); checkArgument(params.length == 1); return FixedValue.reference(params[0]); } else { throw new RuntimeException("Collection parameter is not parameterized!"); } } return FixedValue.nullValue(); }
private static FieldType getArrayFieldType(TypeDescriptor typeDescriptor) { if (typeDescriptor.isArray()) { if (typeDescriptor.getComponentType().getType().equals(byte.class)) { return FieldType.BYTES; } else { return FieldType.array(fieldTypeForJavaType(typeDescriptor.getComponentType())); } } if (typeDescriptor.isSubtypeOf(TypeDescriptor.of(Collection.class))) { TypeDescriptor<Collection<?>> collection = typeDescriptor.getSupertype(Collection.class); if (collection.getType() instanceof ParameterizedType) { ParameterizedType ptype = (ParameterizedType) collection.getType(); java.lang.reflect.Type[] params = ptype.getActualTypeArguments(); checkArgument(params.length == 1); return FieldType.array(fieldTypeForJavaType(TypeDescriptor.of(params[0]))); } } throw new RuntimeException("Could not determine array parameter type for field."); }
@Test public void testTypeDescriptorNested() throws Exception { TypeRememberer<String> rememberer = new TypeRememberer<String>() {}; assertEquals(new TypeToken<String>() {}.getType(), rememberer.descriptorByClass.getType()); assertEquals(new TypeToken<String>() {}.getType(), rememberer.descriptorByInstance.getType()); TypeRememberer<List<String>> genericRememberer = new TypeRememberer<List<String>>() {}; assertEquals( new TypeToken<List<String>>() {}.getType(), genericRememberer.descriptorByClass.getType()); assertEquals( new TypeToken<List<String>>() {}.getType(), genericRememberer.descriptorByInstance.getType()); }
@Test public void testTypeDescriptorNested2() throws Exception { TypeRemembererer<String, Integer> remembererer = new TypeRemembererer<String, Integer>() {}; assertEquals(new TypeToken<String>() {}.getType(), remembererer.descriptor1.getType()); assertEquals(new TypeToken<Integer>() {}.getType(), remembererer.descriptor2.getType()); TypeRemembererer<List<String>, Set<Integer>> genericRemembererer = new TypeRemembererer<List<String>, Set<Integer>>() {}; assertEquals( new TypeToken<List<String>>() {}.getType(), genericRemembererer.descriptor1.getType()); assertEquals( new TypeToken<Set<Integer>>() {}.getType(), genericRemembererer.descriptor2.getType()); }
@Test public void testTypeDescriptorGeneric() throws Exception { TypeDescriptor<List<String>> descriptor = new TypeDescriptor<List<String>>() {}; TypeToken<List<String>> token = new TypeToken<List<String>>() {}; assertEquals(token.getType(), descriptor.getType()); }
private <T> void useWhereMethodToDefineTypeParam(TypeDescriptor<T> parameterType) { TypeDescriptor<Set<T>> typeDescriptor = new TypeDescriptor<Set<T>>() {}.where(new TypeParameter<T>() {}, parameterType); assertEquals(new TypeToken<Set<String>>() {}.getType(), typeDescriptor.getType()); } }
@Test public void testParameterizedWildcardTypeIsUnknown() throws Exception { CoderRegistry registry = CoderRegistry.createDefault(); TypeDescriptor<List<? extends MyValue>> wildcardUnknownToken = new TypeDescriptor<List<? extends MyValue>>() {}; thrown.expect(CannotProvideCoderException.class); thrown.expectMessage( String.format( "Cannot provide coder for parameterized type %s: Cannot provide a coder for wildcard type %s.", wildcardUnknownToken, ((ParameterizedType) wildcardUnknownToken.getType()).getActualTypeArguments()[0])); registry.getCoder(wildcardUnknownToken); }
@Test public void testEnclosing() throws Exception { TypeRememberer<List<String>> rememberer = new GenericMaker<String>() {}.getRememberer(); assertEquals( new TypeToken<List<String>>() {}.getType(), rememberer.descriptorByInstance.getType()); // descriptorByClass *is not* able to find the type of T because it comes from the enclosing // instance of GenericMaker. // assertEquals(new TypeToken<List<T>>() {}.getType(), rememberer.descriptorByClass.getType()); }
@Test public void testGetArgumentTypes() throws Exception { Method identity = Id.class.getDeclaredMethod("identity", Object.class); TypeToken<Id<String>> token = new TypeToken<Id<String>>() {}; TypeDescriptor<Id<String>> descriptor = new TypeDescriptor<Id<String>>() {}; assertEquals( token.method(identity).getParameters().get(0).getType().getType(), descriptor.getArgumentTypes(identity).get(0).getType()); TypeToken<Id<List<String>>> genericToken = new TypeToken<Id<List<String>>>() {}; TypeDescriptor<Id<List<String>>> genericDescriptor = new TypeDescriptor<Id<List<String>>>() {}; assertEquals( genericToken.method(identity).getParameters().get(0).getType().getType(), genericDescriptor.getArgumentTypes(identity).get(0).getType()); }
@Test public void testEnclosing2() throws Exception { // If we don't override, the best we can get is List<Set<T>> // TypeRememberer<List<Set<String>>> rememberer = // new GenericMaker2<String>(){}.getGenericMaker().getRememberer(); // assertNotEquals( // new TypeToken<List<Set<String>>>() {}.getType(), // rememberer.descriptorByInstance.getType()); // If we've overridden the getGenericMaker we can determine the types. TypeRememberer<List<Set<String>>> rememberer = new GenericMaker2<String>() { @Override public GenericMaker<Set<String>> getGenericMaker() { return new GenericMaker<Set<String>>() {}; } }.getGenericMaker().getRememberer(); assertEquals( new TypeToken<List<Set<String>>>() {}.getType(), rememberer.descriptorByInstance.getType()); }