Java IOObject.getAnnotations方法代码示例

import com.rapidminer.operator.IOObject; //导入方法依赖的package包/类
@Override
public void doWork() throws OperatorException {
	IOObject data = inputPort.getData(IOObject.class);
	Annotations annotations = data.getAnnotations();
	Attribute annotationAttr = AttributeFactory.createAttribute(ANNOTATION_ATTRIBUTE, Ontology.POLYNOMINAL);
	Attribute valueAttr = AttributeFactory.createAttribute(VALUE_ATTRIBUTE, Ontology.POLYNOMINAL);

	MemoryExampleTable table = new MemoryExampleTable(annotationAttr, valueAttr);

	for (String annotation : annotations.getDefinedAnnotationNames()) {
		double[] rowData = new double[2];
		rowData[0] = annotationAttr.getMapping().mapString(annotation);
		rowData[1] = valueAttr.getMapping().mapString(annotations.getAnnotation(annotation));
		table.addDataRow(new DoubleArrayDataRow(rowData));
	}

	ExampleSet exampleSet = table.createExampleSet();
	exampleSet.getAttributes().setSpecialAttribute(annotationAttr, Attributes.ID_NAME);
	outputPort.deliver(data);
	annotationsOutputPort.deliver(exampleSet);
}
 

import com.rapidminer.operator.IOObject; //导入方法依赖的package包/类
/**
 * Tests if the two IOObjects are equal and appends the given message.
 *
 * @param assertEqualAnnotations
 *            if true, annotations will be compared. If false, they will be ignored.
 * @param expectedIOO
 * @param actualIOO
 */
public static void assertEquals(String message, IOObject expectedIOO, IOObject actualIOO, boolean assertEqualAnnotations) {

	/*
	 * Do not forget to add a newly supported class to the ASSERTER_REGISTRY!!!
	 */
	List<Asserter> asserterList = ASSERTER_REGISTRY.getAsserterForObjects(expectedIOO, actualIOO);
	if (asserterList != null) {
		for (Asserter asserter : asserterList) {
			asserter.assertEquals(message, expectedIOO, actualIOO);
		}
	} else {
		throw new ComparisonFailure("Comparison of the two given IOObject classes " + expectedIOO.getClass() + " and "
				+ actualIOO.getClass() + " is not supported. ", expectedIOO.toString(), actualIOO.toString());
	}

	// last, compare annotations:
	if (assertEqualAnnotations) {
		Annotations expectedAnnotations = expectedIOO.getAnnotations();
		Annotations actualAnnotations = actualIOO.getAnnotations();

		if (ignoreRepositoryNameForSourceAnnotation) {
			// compare annotations one by one. For the Source annotation, ignore the repository
			// name
			// (that's what all the regular expressions here are for)
			for (String key : expectedAnnotations.getKeys()) {
				String expectedValue = expectedAnnotations.getAnnotation(key);
				String actualValue = actualAnnotations.getAnnotation(key);

				if (expectedValue != null) {
					Assert.assertNotNull(message + "objects are equal, but annotation '" + key + "' is missing",
							actualValue);
				}

				if (Annotations.KEY_SOURCE.equals(key)) {
					if (expectedValue != null && expectedValue.startsWith("//") && expectedValue.matches("//[^/]+/.*")) {
						expectedValue = expectedValue.replaceAll("^//[^/]+/", "//repository/");
						if (actualValue != null) {
							actualValue = actualValue.replaceAll("^//[^/]+/", "//repository/");
						}
					}
				}
				Assert.assertEquals(message + "objects are equal, but annotation '" + key + "' differs: ",
						expectedValue, actualValue);
			}
		} else {
			Assert.assertEquals(message + "objects are equal, but annotations differ: ", expectedAnnotations,
					actualAnnotations);
		}
	}
}
 

import com.rapidminer.operator.IOObject; //导入方法依赖的package包/类
@Override
public void doWork() throws OperatorException {
	IOObject data = inputPort.getData(IOObject.class);
	Annotations annotations = data.getAnnotations();

	// get index of action for duplicate annotations
	String duplicateActionString = getParameterAsString(PARAMETER_DUPLICATE_HANDLING);
	int duplicateAction = ERROR_ON_DUPLICATES;
	for (int i = 0; i < DUPLICATE_HANDLING_LIST.length; ++i) {
		if (DUPLICATE_HANDLING_LIST[i].equals(duplicateActionString)) {
			duplicateAction = i;
			break;
		}
	}

	// just set annotations without any checks
	List<String[]> parameterList = getParameterList(PARAMETER_ANNOTATIONS);
	for (String[] nameValuePair : parameterList) {
		String key = nameValuePair[0];
		String value = nameValuePair[1];
		if (value == null || "".equals(value)) {
			annotations.removeAnnotation(key);
		} else if (annotations.containsKey(key)) {
			switch (duplicateAction) {
				case OVERWRITE_DUPLICATES:
					// overwrite annotations
					annotations.setAnnotation(key, value);
					break;
				case IGNORE_DUPLICATES:
					// do nothing
					break;
				case ERROR_ON_DUPLICATES:
					// throw user error
					throw new UserError(this, "annotate.duplicate_annotation", key);
			}
		} else {
			annotations.setAnnotation(key, value);
		}
	}
	outputPort.deliver(data);
}
 

import com.rapidminer.operator.IOObject; //导入方法依赖的package包/类
@Override
public void doWork() throws OperatorException {
	IOObject object = objectInputPort.getData(IOObject.class);
	ExampleSet annotationData = annotationsInputPort.getData(ExampleSet.class);

	String keyAttributeName = getParameterAsString(PARAMETER_KEY_ATTRIBUTE);
	String valueAttributeName = getParameterAsString(PARAMETER_VALUE_ATTRIBUTE);

	Attribute keyAttribute = annotationData.getAttributes().get(keyAttributeName);
	Attribute valueAttribute = annotationData.getAttributes().get(valueAttributeName);

	// null checks, type checks on attributes
	if (keyAttribute == null) {
		throw new AttributeNotFoundError(this, PARAMETER_KEY_ATTRIBUTE, keyAttributeName);
	} else if (valueAttribute == null) {
		throw new AttributeNotFoundError(this, PARAMETER_VALUE_ATTRIBUTE, valueAttributeName);
	} else if (!keyAttribute.isNominal()) {
		throw new UserError(this, 103, "Data to Annotations", keyAttributeName);
	} else if (!valueAttribute.isNominal()) {
		throw new UserError(this, 103, "Data to Annotations", valueAttributeName);
	}

	// get index of action for duplicate annotations
	String duplicateActionString = getParameterAsString(PARAMETER_DUPLICATE_HANDLING);
	int duplicateAction = ERROR_ON_DUPLICATES;
	for (int i = 0; i < DUPLICATE_HANDLING_LIST.length; ++i) {
		if (DUPLICATE_HANDLING_LIST[i].equals(duplicateActionString)) {
			duplicateAction = i;
			break;
		}
	}

	// loop all examples and add key/value pairs as annotation
	Annotations annotations = object.getAnnotations();
	for (Example example : annotationData) {
		String key = example.getNominalValue(keyAttribute);
		String value = example.getNominalValue(valueAttribute);
		boolean missingValue = Double.isNaN(example.getValue(valueAttribute));

		if (annotations.containsKey(key)) {
			if (missingValue) {
				annotations.remove(key);
			} else {
				switch (duplicateAction) {
					case OVERWRITE_DUPLICATES:
						// overwrite annotations
						annotations.setAnnotation(key, value);
						break;
					case IGNORE_DUPLICATES:
						// do nothing
						break;
					case ERROR_ON_DUPLICATES:
						// throw user error
						throw new UserError(this, "annotate.duplicate_annotation", key);
				}
			}
		} else if (!missingValue) {
			// add annotation
			annotations.setAnnotation(key, value);
		}
	}

	annotationsOutputPort.deliver(annotationData);
	objectOutputPort.deliver(object);
}