Java Code Examples for org.apache.flink.api.common.typeinfo.TypeInformation#getTypeClass()

private static <A> List<FieldInfo> extractFieldInformation(
		TypeInformation<A> inputType,
		Expression[] exprs) {
	final List<FieldInfo> fieldInfos;
	if (inputType instanceof GenericTypeInfo && inputType.getTypeClass() == Row.class) {
		throw new ValidationException(
			"An input of GenericTypeInfo<Row> cannot be converted to Table. " +
				"Please specify the type of the input with a RowTypeInfo.");
	} else if (inputType instanceof TupleTypeInfoBase) {
		fieldInfos = extractFieldInfosFromTupleType((TupleTypeInfoBase<?>) inputType, exprs);
	} else if (inputType instanceof PojoTypeInfo) {
		fieldInfos = extractFieldInfosByNameReference((CompositeType<?>) inputType, exprs);
	} else {
		fieldInfos = extractFieldInfoFromAtomicType(inputType, exprs);
	}
	return fieldInfos;
}
 

@Override
public void setInputType(TypeInformation<?> type, ExecutionConfig executionConfig) {
	if (!type.isTupleType()) {
		throw new IllegalArgumentException("Input TypeInformation is not a tuple type.");
	}

	TupleTypeInfoBase<?> tupleType = (TupleTypeInfoBase<?>) type;

	if (tupleType.getArity() != 2) {
		throw new IllegalArgumentException("Input TypeInformation must be a Tuple2 type.");
	}

	TypeInformation<K> keyType = tupleType.getTypeAt(0);
	TypeInformation<V> valueType = tupleType.getTypeAt(1);

	this.keyClass = keyType.getTypeClass();
	this.valueClass = valueType.getTypeClass();
}
 

@Override
public void setInputType(TypeInformation<?> type, ExecutionConfig executionConfig) {
	if (!type.isTupleType()) {
		throw new IllegalArgumentException("Input TypeInformation is not a tuple type.");
	}

	TupleTypeInfoBase<?> tupleType = (TupleTypeInfoBase<?>) type;

	if (tupleType.getArity() != 2) {
		throw new IllegalArgumentException("Input TypeInformation must be a Tuple2 type.");
	}

	TypeInformation<K> keyType = tupleType.getTypeAt(0);
	TypeInformation<V> valueType = tupleType.getTypeAt(1);

	this.keyClass = keyType.getTypeClass();
	this.valueClass = valueType.getTypeClass();
}
 

private DeserializationRuntimeConverter assembleArrayConverter(
	TypeInformation<?> elementType,
	DeserializationRuntimeConverter elementConverter) {

	final Class<?> elementClass = elementType.getTypeClass();

	return (mapper, jsonNode) -> {
		final ArrayNode node = (ArrayNode) jsonNode;
		final Object[] array = (Object[]) Array.newInstance(elementClass, node.size());
		for (int i = 0; i < node.size(); i++) {
			final JsonNode innerNode = node.get(i);
			array[i] = elementConverter.convert(mapper, innerNode);
		}

		return array;
	};
}
 

private static <A> List<FieldInfo> extractFieldInformation(
	TypeInformation<A> inputType,
	Expression[] exprs) {
	final List<FieldInfo> fieldInfos;
	if (inputType instanceof GenericTypeInfo && inputType.getTypeClass() == Row.class) {
		throw new ValidationException(
			"An input of GenericTypeInfo<Row> cannot be converted to Table. " +
				"Please specify the type of the input with a RowTypeInfo.");
	} else if (inputType instanceof TupleTypeInfoBase) {
		fieldInfos = extractFieldInfosFromTupleType((TupleTypeInfoBase<?>) inputType, exprs);
	} else if (inputType instanceof PojoTypeInfo) {
		fieldInfos = extractFieldInfosByNameReference((CompositeType<?>) inputType, exprs);
	} else {
		fieldInfos = extractFieldInfoFromAtomicType(inputType, exprs);
	}
	return fieldInfos;
}
 

private static RuntimeConverter createObjectArrayRuntimeConverter(
		TypeInformation<?> elementType,
		boolean ignoreParseErrors) {
	final Class<?> elementClass = elementType.getTypeClass();
	final RuntimeConverter elementConverter = createNullableRuntimeConverter(elementType, ignoreParseErrors);

	return (node) -> {
		final int nodeSize = node.size();
		final Object[] array = (Object[]) Array.newInstance(elementClass, nodeSize);
		for (int i = 0; i < nodeSize; i++) {
			array[i] = elementConverter.convert(node.get(i));
		}
		return array;
	};
}
 

/**
 * Validate if class represented by the typeInfo is static and globally accessible.
 *
 * @param typeInfo type to check
 * @throws ValidationException if type does not meet these criteria
 */
public static <A> void validateInputTypeInfo(TypeInformation<A> typeInfo) {
	Class<A> clazz = typeInfo.getTypeClass();
	if ((clazz.isMemberClass() && !Modifier.isStatic(clazz.getModifiers())) ||
		!Modifier.isPublic(clazz.getModifiers()) ||
		clazz.getCanonicalName() == null) {
		throw new ValidationException(format(
			"Class '%s' described in type information '%s' must be " +
			"static and globally accessible.", clazz, typeInfo));
	}
}
 

@SuppressWarnings("BooleanMethodIsAlwaysInverted")
private static boolean isOfGenericType(Parameter parameter, Class<?> baseType, TypeInformation<?> type) {
    if (!(parameter.getParameterizedType() instanceof ParameterizedType)) {
        return false;
    }
    ParameterizedType parameterizedType = (ParameterizedType) parameter.getParameterizedType();
    if (parameterizedType.getRawType() != baseType) {
        return false;
    }
    Type t = parameterizedType.getActualTypeArguments()[0];
    return t == type.getTypeClass();
}
 

static void validateIfWritable(TypeInformation<?> typeInfo, Type type) {
	try {
		// try to load the writable type info

		Class<?> writableTypeInfoClass = Class
				.forName(HADOOP_WRITABLE_TYPEINFO_CLASS, false, typeInfo.getClass().getClassLoader());

		if (writableTypeInfoClass.isAssignableFrom(typeInfo.getClass())) {
			// this is actually a writable type info
			// check if the type is a writable
			if (!(type instanceof Class && isHadoopWritable((Class<?>) type))) {
				throw new InvalidTypesException(HADOOP_WRITABLE_CLASS + " type expected.");
			}

			// check writable type contents
			Class<?> clazz = (Class<?>) type;
			if (typeInfo.getTypeClass() != clazz) {
				throw new InvalidTypesException("Writable type '"
						+ typeInfo.getTypeClass().getCanonicalName() + "' expected but was '"
						+ clazz.getCanonicalName() + "'.");
			}
		}
	}
	catch (ClassNotFoundException e) {
		// class not present at all, so cannot be that type info
		// ignore
	}
}
 

private static RuntimeConverter createObjectArrayRuntimeConverter(
		TypeInformation<?> elementType,
		boolean ignoreParseErrors) {
	final Class<?> elementClass = elementType.getTypeClass();
	final RuntimeConverter elementConverter = createNullableRuntimeConverter(elementType, ignoreParseErrors);

	return (node) -> {
		final int nodeSize = node.size();
		final Object[] array = (Object[]) Array.newInstance(elementClass, nodeSize);
		for (int i = 0; i < nodeSize; i++) {
			array[i] = elementConverter.convert(node.get(i));
		}
		return array;
	};
}
 

private static RuntimeConverter createObjectArrayRuntimeConverter(
		TypeInformation<?> elementType,
		boolean ignoreParseErrors) {
	final Class<?> elementClass = elementType.getTypeClass();
	final RuntimeConverter elementConverter = createNullableRuntimeConverter(elementType, ignoreParseErrors);

	return (node) -> {
		final int nodeSize = node.size();
		final Object[] array = (Object[]) Array.newInstance(elementClass, nodeSize);
		for (int i = 0; i < nodeSize; i++) {
			array[i] = elementConverter.convert(node.get(i));
		}
		return array;
	};
}
 

/**
 * Returns a {@link TypeInfoSchema} for a given {@link TypeInformation}.
 *
 * @param inputType The TypeInformation to extract the mapping from.
 * @param <A> The type of the TypeInformation.
 * @return A description of the input that enables creation of a {@link TableSchema}.
 * @see TypeInfoSchema
 */
public static <A> TypeInfoSchema getFieldsInfo(TypeInformation<A> inputType) {

	if (inputType instanceof GenericTypeInfo && inputType.getTypeClass() == Row.class) {
		throw new ValidationException(
			"An input of GenericTypeInfo<Row> cannot be converted to Table. " +
				"Please specify the type of the input with a RowTypeInfo.");
	} else {
		return new TypeInfoSchema(
			getFieldNames(inputType),
			getFieldIndices(inputType),
			fromLegacyInfoToDataType(getFieldTypes(inputType)),
			false);
	}
}
 

static void validateIfWritable(TypeInformation<?> typeInfo, Type type) {
	try {
		// try to load the writable type info

		Class<?> writableTypeInfoClass = Class
				.forName(HADOOP_WRITABLE_TYPEINFO_CLASS, false, typeInfo.getClass().getClassLoader());

		if (writableTypeInfoClass.isAssignableFrom(typeInfo.getClass())) {
			// this is actually a writable type info
			// check if the type is a writable
			if (!(type instanceof Class && isHadoopWritable((Class<?>) type))) {
				throw new InvalidTypesException(HADOOP_WRITABLE_CLASS + " type expected.");
			}

			// check writable type contents
			Class<?> clazz = (Class<?>) type;
			if (typeInfo.getTypeClass() != clazz) {
				throw new InvalidTypesException("Writable type '"
						+ typeInfo.getTypeClass().getCanonicalName() + "' expected but was '"
						+ clazz.getCanonicalName() + "'.");
			}
		}
	}
	catch (ClassNotFoundException e) {
		// class not present at all, so cannot be that type info
		// ignore
	}
}
 

static void validateIfWritable(TypeInformation<?> typeInfo, Type type) {
	try {
		// try to load the writable type info

		Class<?> writableTypeInfoClass = Class
				.forName(HADOOP_WRITABLE_TYPEINFO_CLASS, false, typeInfo.getClass().getClassLoader());

		if (writableTypeInfoClass.isAssignableFrom(typeInfo.getClass())) {
			// this is actually a writable type info
			// check if the type is a writable
			if (!(type instanceof Class && isHadoopWritable((Class<?>) type))) {
				throw new InvalidTypesException(HADOOP_WRITABLE_CLASS + " type expected.");
			}

			// check writable type contents
			Class<?> clazz = (Class<?>) type;
			if (typeInfo.getTypeClass() != clazz) {
				throw new InvalidTypesException("Writable type '"
						+ typeInfo.getTypeClass().getCanonicalName() + "' expected but was '"
						+ clazz.getCanonicalName() + "'.");
			}
		}
	}
	catch (ClassNotFoundException e) {
		// class not present at all, so cannot be that type info
		// ignore
	}
}
 

public ValueArrayTypeInfo(TypeInformation<T> valueType) {
	this.valueType = valueType;
	this.type = valueType == null ? null : valueType.getTypeClass();
}
 

private <T> TypeSerializerFactory<?> createSerializer(TypeInformation<T> typeInfo) {
	TypeSerializer<T> serializer = typeInfo.createSerializer(executionConfig);

	return new RuntimeSerializerFactory<T>(serializer, typeInfo.getTypeClass());
}
 

private static boolean isOfSimpleType(Parameter parameter, TypeInformation<?> type) {
    return parameter.getType() == type.getTypeClass();
}
 

private <T> TypeSerializerFactory<?> createSerializer(TypeInformation<T> typeInfo) {
	TypeSerializer<T> serializer = typeInfo.createSerializer(executionConfig);

	return new RuntimeSerializerFactory<T>(serializer, typeInfo.getTypeClass());
}
 

public ValueArrayTypeInfo(TypeInformation<T> valueType) {
	this.valueType = valueType;
	this.type = valueType == null ? null : valueType.getTypeClass();
}
 

private <T> TypeSerializerFactory<?> createSerializer(TypeInformation<T> typeInfo) {
	TypeSerializer<T> serializer = typeInfo.createSerializer(executionConfig);

	return new RuntimeSerializerFactory<T>(serializer, typeInfo.getTypeClass());
}