Java CompositeType.getTotalFields方法代码示例

import org.apache.flink.api.common.typeutils.CompositeType; //导入方法依赖的package包/类
@Override
@PublicEvolving
public void getFlatFields(String fieldExpression, int offset, List<FlatFieldDescriptor> result) {

	Matcher matcher = PATTERN_NESTED_FIELDS_WILDCARD.matcher(fieldExpression);
	if(!matcher.matches()) {
		throw new InvalidFieldReferenceException("Invalid POJO field reference \""+fieldExpression+"\".");
	}

	String field = matcher.group(0);
	if(field.equals(ExpressionKeys.SELECT_ALL_CHAR) || field.equals(ExpressionKeys.SELECT_ALL_CHAR_SCALA)) {
		// handle select all
		int keyPosition = 0;
		for(PojoField pField : fields) {
			if(pField.getTypeInformation() instanceof CompositeType) {
				CompositeType<?> cType = (CompositeType<?>)pField.getTypeInformation();
				cType.getFlatFields(String.valueOf(ExpressionKeys.SELECT_ALL_CHAR), offset + keyPosition, result);
				keyPosition += cType.getTotalFields()-1;
			} else {
				result.add(
					new NamedFlatFieldDescriptor(
						pField.getField().getName(),
						offset + keyPosition,
						pField.getTypeInformation()));
			}
			keyPosition++;
		}
		return;
	} else {
		field = matcher.group(1);
	}

	// get field
	int fieldPos = -1;
	TypeInformation<?> fieldType = null;
	for (int i = 0; i < fields.length; i++) {
		if (fields[i].getField().getName().equals(field)) {
			fieldPos = i;
			fieldType = fields[i].getTypeInformation();
			break;
		}
	}
	if (fieldPos == -1) {
		throw new InvalidFieldReferenceException("Unable to find field \""+field+"\" in type "+this+".");
	}
	String tail = matcher.group(3);
	if(tail == null) {
		if(fieldType instanceof CompositeType) {
			// forward offset
			for(int i=0; i<fieldPos; i++) {
				offset += this.getTypeAt(i).getTotalFields();
			}
			// add all fields of composite type
			((CompositeType<?>) fieldType).getFlatFields("*", offset, result);
		} else {
			// we found the field to add
			// compute flat field position by adding skipped fields
			int flatFieldPos = offset;
			for(int i=0; i<fieldPos; i++) {
				flatFieldPos += this.getTypeAt(i).getTotalFields();
			}
			result.add(new FlatFieldDescriptor(flatFieldPos, fieldType));
		}
	} else {
		if(fieldType instanceof CompositeType<?>) {
			// forward offset
			for(int i=0; i<fieldPos; i++) {
				offset += this.getTypeAt(i).getTotalFields();
			}
			((CompositeType<?>) fieldType).getFlatFields(tail, offset, result);
		} else {
			throw new InvalidFieldReferenceException("Nested field expression \""+tail+"\" not possible on atomic type "+fieldType+".");
		}
	}
}
 

import org.apache.flink.api.common.typeutils.CompositeType; //导入方法依赖的package包/类
@Override
public void getFlatFields(String fieldExpression, int offset, List<FlatFieldDescriptor> result) {
	Matcher matcher = PATTERN_NESTED_FIELDS_WILDCARD.matcher(fieldExpression);

	if (!matcher.matches()) {
		throw new InvalidFieldReferenceException(
			"Invalid tuple field reference \"" + fieldExpression + "\".");
	}

	String field = matcher.group(0);

	if ((field.equals(ExpressionKeys.SELECT_ALL_CHAR)) ||
		(field.equals(ExpressionKeys.SELECT_ALL_CHAR_SCALA))) {
		// handle select all
		int keyPosition = 0;
		for (TypeInformation<?> fType : types) {
			if (fType instanceof CompositeType) {
				CompositeType<?> cType = (CompositeType<?>) fType;
				cType.getFlatFields(ExpressionKeys.SELECT_ALL_CHAR, offset + keyPosition, result);
				keyPosition += cType.getTotalFields() - 1;
			} else {
				result.add(new FlatFieldDescriptor(offset + keyPosition, fType));
			}
			keyPosition++;
		}
	} else {
		field = matcher.group(1);

		Matcher intFieldMatcher = PATTERN_INT_FIELD.matcher(field);
		int fieldIndex;
		if (intFieldMatcher.matches()) {
			// field expression is an integer
			fieldIndex = Integer.valueOf(field);
		} else {
			fieldIndex = this.getFieldIndex(field);
		}
		// fetch the field type will throw exception if the index is illegal
		TypeInformation<?> fieldType = this.getTypeAt(fieldIndex);
		// compute the offset,
		for (int i = 0; i < fieldIndex; i++) {
			offset += this.getTypeAt(i).getTotalFields();
		}

		String tail = matcher.group(3);

		if (tail == null) {
			// expression hasn't nested field
			if (fieldType instanceof CompositeType) {
				((CompositeType) fieldType).getFlatFields("*", offset, result);
			} else {
				result.add(new FlatFieldDescriptor(offset, fieldType));
			}
		} else {
			// expression has nested field
			if (fieldType instanceof CompositeType) {
				((CompositeType) fieldType).getFlatFields(tail, offset, result);
			} else {
				throw new InvalidFieldReferenceException(
					"Nested field expression \"" + tail + "\" not possible on atomic type " + fieldType + ".");
			}
		}
	}
}
 

import org.apache.flink.api.common.typeutils.CompositeType; //导入方法依赖的package包/类
@Override
public void getFlatFields(String fieldExpression, int offset, List<FlatFieldDescriptor> result) {

	Matcher matcher = PATTERN_NESTED_FIELDS_WILDCARD.matcher(fieldExpression);
	if (!matcher.matches()) {
		throw new InvalidFieldReferenceException("Invalid tuple field reference \""+fieldExpression+"\".");
	}

	String field = matcher.group(0);
	if (field.equals(ExpressionKeys.SELECT_ALL_CHAR) || field.equals(ExpressionKeys.SELECT_ALL_CHAR_SCALA)) {
		// handle select all
		int keyPosition = 0;
		for (TypeInformation<?> type : types) {
			if (type instanceof CompositeType) {
				CompositeType<?> cType = (CompositeType<?>) type;
				cType.getFlatFields(String.valueOf(ExpressionKeys.SELECT_ALL_CHAR), offset + keyPosition, result);
				keyPosition += cType.getTotalFields() - 1;
			} else {
				result.add(new FlatFieldDescriptor(offset + keyPosition, type));
			}
			keyPosition++;
		}
	} else {
		String fieldStr = matcher.group(1);
		Matcher fieldMatcher = PATTERN_FIELD.matcher(fieldStr);

		if (!fieldMatcher.matches()) {
			throw new RuntimeException("Invalid matcher pattern");
		}

		field = fieldMatcher.group(2);
		int fieldPos = Integer.valueOf(field);

		if (fieldPos >= this.getArity()) {
			throw new InvalidFieldReferenceException("Tuple field expression \"" + fieldStr + "\" out of bounds of " + this.toString() + ".");
		}
		TypeInformation<?> fieldType = this.getTypeAt(fieldPos);
		String tail = matcher.group(5);
		if (tail == null) {
			if (fieldType instanceof CompositeType) {
				// forward offsets
				for (int i = 0; i < fieldPos; i++) {
					offset += this.getTypeAt(i).getTotalFields();
				}
				// add all fields of composite type
				((CompositeType<?>) fieldType).getFlatFields("*", offset, result);
			} else {
				// we found the field to add
				// compute flat field position by adding skipped fields
				int flatFieldPos = offset;
				for (int i = 0; i < fieldPos; i++) {
					flatFieldPos += this.getTypeAt(i).getTotalFields();
				}
				result.add(new FlatFieldDescriptor(flatFieldPos, fieldType));
			}
		} else {
			if (fieldType instanceof CompositeType<?>) {
				// forward offset
				for (int i = 0; i < fieldPos; i++) {
					offset += this.getTypeAt(i).getTotalFields();
				}
				((CompositeType<?>) fieldType).getFlatFields(tail, offset, result);
			} else {
				throw new InvalidFieldReferenceException("Nested field expression \"" + tail + "\" not possible on atomic type " + fieldType + ".");
			}
		}
	}
}