Java Nodes.hasAny方法代码示例

import nu.xom.Nodes; //导入方法依赖的package包/类
public Note(Nodes title, Nodes content, Nodes tags) {
	super();
	if (title.isEmpty()) {
		throw new IllegalArgumentException();
	}
	this.title = extractString(title);
	if (content.isEmpty()) {
		this.content = "";
	} else {
		this.content = extractContent(content);
	}
	for (Node tag : tags) {
		Nodes tagValue = tag.query("./text()");
		if (!tagValue.hasAny()) {
			continue;
		}
		String tagString = extractContent(tagValue);
		this.tags.add(tagString);
	}
}
 

import nu.xom.Nodes; //导入方法依赖的package包/类
private Node findXsdType(String typeQName, Node variable) {
	String variableTypeNamespaceURI = variable.getDocument()
			.getRootElement()
			.getNamespaceURI(PrefixHelper.getPrefix(typeQName));
	String xsdTypeName = PrefixHelper.removePrefix(typeQName);
	Node xsdType = null;

	for (Node node : fileHandler.getSchemas()) {
		if (new NodeHelper(node)
				.hasTargetNamespace(variableTypeNamespaceURI)) {
			Nodes xsdTypes = node.getDocument().query(
					"//*[@name='" + xsdTypeName + "']", CONTEXT);
			if (xsdTypes.hasAny()) {
				xsdType = xsdTypes.get(0);
				break;
			}
		}
	}
	return xsdType;
}
 

import nu.xom.Nodes; //导入方法依赖的package包/类
public Attribute getAttributeNode(String name) {
	Nodes attributes = node.query("@" + name);

	if (attributes.hasAny()) {
		return (Attribute) attributes.get(0);
	}
	return null;
}
 

import nu.xom.Nodes; //导入方法依赖的package包/类
@Override
public void validate() {

	Nodes variables = fileHandler.getBpel().getDocument()
			.query("//bpel:variable", CONTEXT);

	for (Node variable : variables) {

		Nodes messageTypeSet = variable.query("@messageType", CONTEXT);
		Nodes typeSet = variable.query("@type", CONTEXT);
		Nodes elementSet = variable.query("@element", CONTEXT);

		if (messageTypeSet.isEmpty() && typeSet.isEmpty() && elementSet.isEmpty()) {
			addViolation(variable, MESSAGE_TYPE_OR_TYPE_OR_ELEMENT_MISSING);
		} else if (messageTypeSet.hasAny() && typeSet.hasAny()) {
			addViolation(variable, MESSAGE_TYPE_AND_TYPE);
		} else if (messageTypeSet.hasAny() && elementSet.hasAny()) {
			addViolation(variable, MESSAGE_TYPE_AND_ELEMENT);
		} else if (typeSet.hasAny() && elementSet.hasAny()) {
			addViolation(variable, TYPE_AND_ELEMENT);
		} else if (messageTypeSet.hasAny() && typeSet.hasAny() && elementSet.hasAny()) {
			addViolation(variable, MESSAGE_TYPE_AND_TYPE_AND_ELEMENT);
		}
	}
}
 

import nu.xom.Nodes; //导入方法依赖的package包/类
private boolean hasToPartCorrespondingMessagePart(Node toPart, Node message) {
	Nodes messageParts = message.query("wsdl:part", CONTEXT);

	if (messageParts.hasAny()) {
		String partAttribute = new NodeHelper(toPart).getAttribute("part");

		for (Node part : messageParts) {
			String partName = new NodeHelper(part).getAttribute("name");

			if (partName.equals(partAttribute)) {
				return true;
			}

		}
	}

	return false;
}
 

import nu.xom.Nodes; //导入方法依赖的package包/类
private boolean hasFromPartCorrespondingMessagePart(Node fromPart,
                                                    Node message) {
	Nodes messageParts = message.query("wsdl:part", CONTEXT);

	if (messageParts.hasAny()) {
		String partAttribute = new NodeHelper(fromPart).getAttribute("part");

		for (Node part : messageParts) {
			String partName = new NodeHelper(part).getAttribute("name");

			if (partName.equals(partAttribute)) {
				return true;
			}

		}
	}
	return false;
}
 

import nu.xom.Nodes; //导入方法依赖的package包/类
private Node correspondingVariable(Node invokeActivity, String variableName) {
	Nodes variable = invokeActivity.query(
			"(ancestor::*/bpel:variables/bpel:variable[@name='"
					+ variableName + "'])[last()]", CONTEXT);

	if (variable.hasAny())
		return variable.get(0);
	else
		return null;
}
 

import nu.xom.Nodes; //导入方法依赖的package包/类
@Override
public void validate() {

	Nodes invokes = fileHandler.getBpel().getDocument()
			.query("//bpel:invoke", CONTEXT);

	for (Node invoke : invokes) {

		Nodes toPartsSet = invoke.query("bpel:toParts", CONTEXT);
		Nodes inputVariableSet = invoke.query("@inputVariable", CONTEXT);
		if (toPartsSet.hasAny() && inputVariableSet.hasAny()) {
			addViolation(invoke);
		}
	}
}
 

import nu.xom.Nodes; //导入方法依赖的package包/类
private void hasToPartForEveryMessagePart(String xPathOutgoingOperation) {
	Nodes outgoingOperations = fileHandler.getBpel().getDocument()
			.query(xPathOutgoingOperation, CONTEXT);

	for (Node outgoingOperation : outgoingOperations) {
		try {
			Nodes toParts = outgoingOperation.query(
					"bpel:toParts/bpel:toPart", CONTEXT);

			Node message;
			if ("invoke".equals(PrefixHelper
					.removePrefix(xPathOutgoingOperation))) {
				message = navigator
						.getCorrespondingIncomingMessage(outgoingOperation);
			} else {
				message = navigator
						.getCorrespondingOutgoingMessage(outgoingOperation);
			}
			Nodes messageParts = message.query("wsdl:part", CONTEXT);

			if (toParts.hasAny()) {
				for (Node part : messageParts) {

					if (!hasMessagePartCorrespondingToPart(part, toParts)) {
						addViolation(outgoingOperation);
					}
				}
			}
		} catch (NavigationException e) {
			// message does not exist, outgoingOperation is not validatable
			// => valid
		}

	}
}
 

import nu.xom.Nodes; //导入方法依赖的package包/类
private void hasPartForEveryFromPart(String xPathOutgoingOperation) {
	Nodes incomingOperations = fileHandler.getBpel().getDocument()
			.query(xPathOutgoingOperation, CONTEXT);

	for (Node incomingOperation : incomingOperations) {
		try {
			Node message;
			if ("invoke".equals(PrefixHelper
					.removePrefix(xPathOutgoingOperation))) {
				message = navigator
						.getCorrespondingOutgoingMessage(incomingOperation);
			} else {
				message = navigator
						.getCorrespondingIncomingMessage(incomingOperation);
			}

			Nodes fromParts = incomingOperation.query(
					"bpel:fromParts/bpel:fromPart", CONTEXT);

			if (fromParts.hasAny()) {
				for (Node fromPart : fromParts) {

					if (!hasFromPartCorrespondingMessagePart(fromPart, message)) {
						addViolation(fromPart);
					}
				}
			}
		} catch (NavigationException e) {
			// message does not exist, outgoingOperation is not validatable
			// => valid
		}

	}
}
 

import nu.xom.Nodes; //导入方法依赖的package包/类
private Node getMessagePartAttributeElement(Node operationMessage) {
	Nodes partElement = operationMessage.query(
			"child::wsdl:part[position()=1]/@element", CONTEXT);
	return (partElement.hasAny()) ? partElement.get(0) : null;
}
 

import nu.xom.Nodes; //导入方法依赖的package包/类
@Override
public void validate() {
	Nodes invokeNodes = fileHandler.getBpel().getDocument()
			.query("//bpel:invoke", CONTEXT);

	for (Node invoke : invokeNodes) {
		Nodes fromParts = invoke.query("bpel:fromParts", CONTEXT);
		String outputVariable = new NodeHelper(invoke)
				.getAttribute("outputVariable");

		if (!outputVariable.isEmpty() && fromParts.hasAny()) {
			addViolation(invoke);
		}
	}
}
 

import nu.xom.Nodes; //导入方法依赖的package包/类
private boolean hasToPart(Node messageActivity) {
	Nodes toPart = messageActivity.query("child::bpel:toParts", CONTEXT);
	return toPart.hasAny();
}
 

import nu.xom.Nodes; //导入方法依赖的package包/类
private boolean hasFromPart(Node msgActivity) {
	Nodes fromPart = msgActivity.query("child::bpel:fromParts", CONTEXT);
	return fromPart.hasAny();
}
 

import nu.xom.Nodes; //导入方法依赖的package包/类
private boolean hasVariable(Node msgActivity) {
	Nodes variable = msgActivity.query("attribute::variable", CONTEXT);
	return variable.hasAny();
}