plugins/org.eclipse.bpel.validator/src/org/eclipse/bpel/validator/rules/CValidator.java - bpel/org.eclipse.bpel - Git at Google

 /*******************************************************************************
  * Copyright (c) 2006 Oracle Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     Oracle Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.bpel.validator.rules;

 import java.lang.reflect.Field;
 import java.util.List;

 import javax.xml.namespace.QName;

 import org.eclipse.bpel.validator.model.ARule;
 import org.eclipse.bpel.validator.model.Filters;
 import org.eclipse.bpel.validator.model.IConstants;
 import org.eclipse.bpel.validator.model.IFilter;
 import org.eclipse.bpel.validator.model.IModelQueryLookups;
 import org.eclipse.bpel.validator.model.INode;
 import org.eclipse.bpel.validator.model.IProblem;
 import org.eclipse.bpel.validator.model.NodeNameFilter;
 import org.eclipse.bpel.validator.model.RuleFactory;
 import org.eclipse.bpel.validator.model.Validator;


 /**
  * @author Michal Chmielewski (michal.chmielewski@oracle.com)
  * @date Oct 12, 2006
  *
  */

 @SuppressWarnings("nls")
 public class CValidator extends Validator {

 	/** The parent node */
 	protected INode fParentNode;

 	/** Children nodes */
 	protected List<INode> fChildren;

 	List<INode> fTypeToCheckList;


 	@Override
 	protected void start () {

 		super.start();

 		fParentNode = mNode.parentNode();

 		// get the children, as we will be checking them
 		fChildren = mNode.children() ;
 	}
 	/**
 	 * Check to make sure that parent node
 	 * of my node is within the set of nodes
 	 * that is allowed.
 	 */

 	@ARule(
 		sa = 2001,
 		desc = "Check to make sure that my parent node is within a set of allowed nodes",
 		author = "michal.chmielewski@oracle.com",
 		date = "02/15/2007"
 	)
 	public void rule_CheckParentNode_1 () {

 		checkParentNode ();
 	}


 	/**
 	 * Check the parent Node
 	 */
 	public void checkParentNode () {
 		IFilter<INode> filter = parentNodeNames();

 		if (fParentNode == null) {
 			return ;
 		}

 		if (filter.select(fParentNode) ) {
 			return ;
 		}

 		// Otherwise, we have a problem ...

 		IProblem problem;
 		problem = createError();
 		problem.fill("BPELC__WRONG_PARENT", //$NON-NLS-1$
 				toString(mNode.nodeName()),
 				toString(fParentNode.nodeName()),
 				filter.toString() );

 		// Disable all the rules from being run, if we get here.
 		disableRules();

 	}


 	/**
 	 * Check the children nodes, to make sure that they are present
 	 */

 	@ARule(
 		sa = 2002,
 		desc = "Check my children nodes (types and occurances)",
 		author = "michal.chmielewski@oracle.com",
 		date = "02/15/2007"
 	)
 	public void rule_CheckChildrenNodes_0 () {
 		checkChildren();
 	}


 	/**
 	 * Check the children nodes
 	 *
 	 */

 	public void checkChildren () {

 	}


 	/**
 	 * Check to make sure that the node nodeName appears in the
 	 * children as specified by  he min/max parameters.
 	 * @param node
 	 * @param min
 	 * @param max
 	 * @return the number of occurrences of this child.
 	 */

 	public int checkChild (QName node, int min, int max) {
 		return checkChild ( new NodeNameFilter(node),min,max) ;
 	}

 	/**
 	 * @param filter
 	 * @param min
 	 * @param max
 	 * @return the # of occurrences of this child
 	 */


 	@SuppressWarnings("boxing")
 	public int checkChild ( IFilter<INode> filter, int min, int max) {
 		int count = 0;
 		for(INode n : fChildren) {
 			if (filter.select(n)) {
 				count += 1;
 			}
 		}

 		IProblem problem;

 		if (count < min) {
 			problem = createError();
 			problem.fill("BPELC__MIN_IN_PARENT",
 					toString(mNode.nodeName()),
 					getNodeKind ( mNode ),
 					IConstants.KIND_NODE,
 					filter.toString(),
 					count,
 					min
 			);

 		} else if (count > max) {
 			problem = createError();
 			problem.fill("BPELC__MAX_IN_PARENT",
 					toString(mNode.nodeName()),
 					getNodeKind ( mNode ),
 					IConstants.KIND_NODE,
 					filter.toString(),
 					count,
 					max
 			);
 		}

 		return count;
 	}


 	/**
 	 * Answer with my parent nodes. Subclasses must override this
 	 * because most nodes can only be children of certain nodes.
 	 *
 	 * @return an array of valid parent nodes.
 	 */


 	@SuppressWarnings("unchecked")
 	public  IFilter<INode> parentNodeNames () {
 		try {
 			Field f = getClass().getField("PARENTS");
 			return (IFilter) f.get(null);
 		} catch (java.lang.NoSuchFieldException nsfe) {
 			// do nothing.
 		} catch (Throwable t) {
 			t.printStackTrace();
 		}
 		return Filters.EMPTY ;
 	}


 	/**
 	 * Return the value of getExitOnStandardFault
 	 *
 	 * @param node
 	 * @return either yes or no, depending on the setting in the scopes.
 	 */

 	public String getExitOnStandardFault ( INode node ) {

 		INode nn = mSelector.selectParent(node, new IFilter<INode>() {

 			public boolean select(INode n) {
 				QName name = n.nodeName();
 				if (name.equals(ND_SCOPE) == false && name.equals(ND_PROCESS) == false) {
 					return false;
 				}
 				String value = n.getAttribute(AT_EXIT_ON_STANDARD_FAULT);
 				if (isEmpty(value) == false) {
 					return true;
 				}
 				return false;
 			}
 		});

 		if (nn != null) {
 			return nn.getAttribute(AT_EXIT_ON_STANDARD_FAULT);
 		}
 		return NO;
 	}


 	/**
 	 * Register a type to check.
 	 * @param node
 	 */

 	public void registerTypeToCheck (INode node) {

 		if (isUndefined(node)) {
 			return;
 		}

 		if ( fTypeToCheckList == null) {

 			INode process = mNode.rootNode();
 			fTypeToCheckList = getValue(process, "types.to.check", null);
 		}

 		if (fTypeToCheckList == null) {
 			return ;
 		}

 		if ( fTypeToCheckList.contains ( node ) == false ) {
 			fTypeToCheckList.add ( node );
 		}

 	}


 	/**
 	 * Check if the copy is compatible
 	 *
 	 * @param fromNode
 	 * @param toNode
 	 */
 	public void compatibleCopyCheck ( INode fromNode, INode toNode ) {

 		INode fromTypeNode = getValue(fromNode,"type",null);
 		INode toTypeNode = getValue(toNode,"type",null);

 		if (hasProblems(fromNode) || hasProblems(toNode)) {
 			return ;
 		}

 		if (fromTypeNode == null && toTypeNode == null) {
 			return ;
 		}

 		/** Compatible assign */
 		IProblem problem ;
 		if (fromTypeNode == null || toTypeNode == null) {

 			problem = createInfo();
 			problem.fill("BPELC_COPY__NOT_CHECKED",
 					toString(mNode.nodeName()),
 					"text.term.from",
 					fromTypeNode == null ? "text.term.unspecified" : fromTypeNode ,
 					"text.term.to",
 					toTypeNode == null ? "text.term.unspecified" : toTypeNode );
 			return ;
 		}


 		// source -> destination
 		boolean bCompatible = mModelQuery.check(IModelQueryLookups.TEST_COMPATIBLE_TYPE, fromTypeNode, toTypeNode);

 		// if these are simple types, warn if incompatibility found as engines may perform implicit conversion
 		// much like XPath does.

 		if (mModelQuery.check(IModelQueryLookups.TEST_IS_SIMPLE_TYPE,fromTypeNode,null) &&
 			mModelQuery.check(IModelQueryLookups.TEST_IS_SIMPLE_TYPE,toTypeNode,null)) {

 			if (bCompatible == false) {

 				problem = createWarning();
 				problem.fill("BPELC_COPY__INCOMPATIBLE_SIMPLE",
 						toString(mNode.nodeName()),
 						"text.term.from",
 						fromTypeNode,
 						"text.term.to",
 						toTypeNode
 				);

 			}

 			// Temporary workaround for 3369 - disable check if from/to has a part attr
 			String fromPart = fromNode.getAttribute(AT_PART);
 			String toPart = toNode.getAttribute(AT_PART);
 			if (fromPart != null || toPart != null){
 				return;
 			}


 		} else if (bCompatible == false) {

 			problem = createError();
 			problem.fill("BPELC_COPY__INCOMPATIBLE",
 					toString(mNode.nodeName()),
 					"text.term.from",
 					fromTypeNode,
 					"text.term.to",
 					toTypeNode
 			);

 		}

 	}


 	/**
 	 * A generic check against attributes
 	 *
 	 * @param node the context node.
 	 * @param name name of the attribute
 	 * @param kind 1 for activity node, 0 for generic node
 	 * @param filter the filter that checks the allowed values
 	 * @param bMandatory true for mandatory, false otherwise.
 	 * @return the attribute value or null if the value does not exist or is not allowed.
 	 */

 	@SuppressWarnings("boxing")
 	public String  getAttribute ( INode node, QName name, int kind, IFilter<String> filter, boolean bMandatory  ) {

 		IProblem problem;

 		String value = node.getAttribute(name);

 		if (bMandatory) {
 			if (isEmpty(value)) {
 				problem = createError(node);
 				problem.setAttribute(IProblem.CONTEXT, name.getLocalPart() );
 				problem.fill("BPELC__UNSET_ATTRIBUTE", //$NON-NLS-1$
 						toString(node.nodeName()) ,
 						toString(name), kind );
 				return null;
 			}
 		}


 		if (filter == null || isEmpty(value) ) {
 			return value;
 		}

 		if (filter.select(value)) {
 			return value;
 		}

 		problem = createError(node);
 		problem.setAttribute(IProblem.CONTEXT, name.getLocalPart());
 		problem.fill("BPELC__INVALID_ATTRIBUTE_VALUE", //$NON-NLS-1$
 				toString(node.nodeName()),
 				toString(name),
 				value,
 				filter.toString() ,
 				kind);

 		return null ;
 	}


 	/**
 	 * A generic check against all attributes that are pointers to other
 	 * objects. For example, portType on invoke, partnerLink, etc. are
 	 * represented as attributes but in fact refer to larger objects in the
 	 * models.
 	 *
 	 * @param node
 	 * @param ref the referenced node
 	 * @param name the name of the attribute that references the node
 	 * @param kind 1 for activity node, 0 for generic node
 	 * @return true if the attribute pointer can be resolved, false otherwise
 	 */

 	@SuppressWarnings("boxing")
 	public boolean checkAttributeNode ( INode node, INode ref, QName name, int kind ) {

 		IProblem problem;

 		if (ref == null) {
 			problem = createError(node);
 			problem.setAttribute(IProblem.CONTEXT, name);
 			problem.fill("BPELC__UNSET_ATTRIBUTE", //$NON-NLS-1$
 					toString(node.nodeName()) ,
 					toString(name), kind );
 			return false;
 		}

 		if (ref.isResolved() == false) {
 			String atValue = node.getAttribute( name );

 			problem = createError(node);
 			problem.setAttribute(IProblem.CONTEXT, name);
 			problem.fill("BPELC__UNRESOLVED_ATTRIBUTE", //$NON-NLS-1$
 					toString(node.nodeName()),
 					toString(name), kind , atValue );
 			return false;
 		}

 		return true;
 	}


 	/**
 	 * Check if NCName is valid.
 	 *
 	 * @param node the node on which we are checking.
 	 * @param ncName the ncName
 	 * @param atName the attribute name from where the ncName came from.
 	 * @return return true if checkName succeeds, false otherwise.
 	 */


 	@SuppressWarnings("boxing")
 	public boolean checkNCName ( INode node, String ncName, QName atName ) {

 		if (ncName == null || ncName.length() == 0) {

 			IProblem problem = createError( node );
 			problem.setAttribute(IProblem.CONTEXT, atName.getLocalPart() );
 			problem.fill("BPELC__UNSET_ATTRIBUTE",
 					toString(node.nodeName()) ,
 					atName,
 					IConstants.KIND_NODE);
 			return false ;
 		}

 		if (Filters.NC_NAME.select(ncName) == false) {

 			IProblem problem = createError( node );
 			problem.setAttribute(IProblem.CONTEXT, atName.getLocalPart() );
 			problem.fill("General.NCName_Bad", //$NON-NLS-1$
 					toString(atName),
 					toString(node.nodeName()) , ncName );
 			return false;
 		}

 		// Check for uniqueness of name within a scope or process ?
 		return true;
 	}


 	/**
 	 * Check the node's validator to see if there are any problems reported on the
 	 * node.
 	 *
 	 * @param node the context node
 	 * @param ref  the referenced node that comes from the node via an attribute
 	 * @param name the name of the attribute reference
 	 * @param kind 0 for node, 1 for activity
 	 * @return true if there are any problems, false otherwise.
 	 */

 	@SuppressWarnings("boxing")
 	public boolean checkValidator ( INode node, INode ref, QName name, int kind ) {

 		if (ref == null) {
 			return false;
 		}

 		Validator validator = ref.nodeValidator();
 		if (validator == null) {
 			return true;
 		}

 		IProblem problem;
 		if (validator.hasProblems()) {
 			problem = createWarning(node);
 			problem.setAttribute(IProblem.CONTEXT, name.getLocalPart() );
 			problem.fill("BPELC_REF_NODE_PROBLEMS", //$NON-NLS-1$
 					toString(node.nodeName()),
 					toString(ref.nodeName()),
 					name,
 					kind);

 			return false;
 		}

 		return true;
 	}


 	/**
 	 *
 	 * Return the language (expression or query) from the node.
 	 *
 	 * @param node
 	 * @param atName the attribute name
 	 * @return the default language.
 	 */

 	public String getLanguage (INode node, QName atName) {

 		// get the expression language
 		String lang = node.getAttribute (atName);
 		if (lang == null) {
 			INode process = node.rootNode ();
 			lang = process.getAttribute(atName);
 		}

 		// the default language

 		if (lang == null) {
 			return IConstants.XMLNS_XPATH_EXPRESSION_LANGUAGE;
 		}
 		return lang;
 	}


 	protected int getNodeKind ( INode node ) {
 		if (Filters.ACTIVITIES.select(node)) {
 			return IConstants.KIND_ACTIVITY;
 		}
 		return IConstants.KIND_NODE;
 	}


 	protected Validator createExpressionValidator ( QName qname ) {

 		Validator object = RuleFactory.INSTANCE.createValidator ( qname );

 		IProblem problem;

 		if  (object == null) {

 			problem = createWarning();
 			problem.fill("BPELC__NO_EXPRESSION_VALIDATOR",  //$NON-NLS-1$
 					toString(mNode.nodeName()),
 					qname.getNamespaceURI()
 			);
 			return null;
 		}
 		return object;
 	}


 }
	/*******************************************************************************
	* Copyright (c) 2006 Oracle Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* Oracle Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.bpel.validator.rules;

	import java.lang.reflect.Field;
	import java.util.List;

	import javax.xml.namespace.QName;

	import org.eclipse.bpel.validator.model.ARule;
	import org.eclipse.bpel.validator.model.Filters;
	import org.eclipse.bpel.validator.model.IConstants;
	import org.eclipse.bpel.validator.model.IFilter;
	import org.eclipse.bpel.validator.model.IModelQueryLookups;
	import org.eclipse.bpel.validator.model.INode;
	import org.eclipse.bpel.validator.model.IProblem;
	import org.eclipse.bpel.validator.model.NodeNameFilter;
	import org.eclipse.bpel.validator.model.RuleFactory;
	import org.eclipse.bpel.validator.model.Validator;


	/**
	* @author Michal Chmielewski (michal.chmielewski@oracle.com)
	* @date Oct 12, 2006
	*
	*/

	@SuppressWarnings("nls")
	public class CValidator extends Validator {

	/** The parent node */
	protected INode fParentNode;

	/** Children nodes */
	protected List<INode> fChildren;

	List<INode> fTypeToCheckList;


	@Override
	protected void start () {

	super.start();

	fParentNode = mNode.parentNode();

	// get the children, as we will be checking them
	fChildren = mNode.children() ;
	}
	/**
	* Check to make sure that parent node
	* of my node is within the set of nodes
	* that is allowed.
	*/

	@ARule(
	sa = 2001,
	desc = "Check to make sure that my parent node is within a set of allowed nodes",
	author = "michal.chmielewski@oracle.com",
	date = "02/15/2007"
	)
	public void rule_CheckParentNode_1 () {

	checkParentNode ();
	}


	/**
	* Check the parent Node
	*/
	public void checkParentNode () {
	IFilter<INode> filter = parentNodeNames();

	if (fParentNode == null) {
	return ;
	}

	if (filter.select(fParentNode) ) {
	return ;
	}

	// Otherwise, we have a problem ...

	IProblem problem;
	problem = createError();
	problem.fill("BPELC__WRONG_PARENT", //$NON-NLS-1$
	toString(mNode.nodeName()),
	toString(fParentNode.nodeName()),
	filter.toString() );

	// Disable all the rules from being run, if we get here.
	disableRules();

	}


	/**
	* Check the children nodes, to make sure that they are present
	*/

	@ARule(
	sa = 2002,
	desc = "Check my children nodes (types and occurances)",
	author = "michal.chmielewski@oracle.com",
	date = "02/15/2007"
	)
	public void rule_CheckChildrenNodes_0 () {
	checkChildren();
	}



	/**
	* Check the children nodes
	*
	*/

	public void checkChildren () {

	}


	/**
	* Check to make sure that the node nodeName appears in the
	* children as specified by he min/max parameters.
	* @param node
	* @param min
	* @param max
	* @return the number of occurrences of this child.
	*/

	public int checkChild (QName node, int min, int max) {
	return checkChild ( new NodeNameFilter(node),min,max) ;
	}

	/**
	* @param filter
	* @param min
	* @param max
	* @return the # of occurrences of this child
	*/


	@SuppressWarnings("boxing")
	public int checkChild ( IFilter<INode> filter, int min, int max) {
	int count = 0;
	for(INode n : fChildren) {
	if (filter.select(n)) {
	count += 1;
	}
	}

	IProblem problem;

	if (count < min) {
	problem = createError();
	problem.fill("BPELC__MIN_IN_PARENT",
	toString(mNode.nodeName()),
	getNodeKind ( mNode ),
	IConstants.KIND_NODE,
	filter.toString(),
	count,
	min
	);

	} else if (count > max) {
	problem = createError();
	problem.fill("BPELC__MAX_IN_PARENT",
	toString(mNode.nodeName()),
	getNodeKind ( mNode ),
	IConstants.KIND_NODE,
	filter.toString(),
	count,
	max
	);
	}

	return count;
	}



	/**
	* Answer with my parent nodes. Subclasses must override this
	* because most nodes can only be children of certain nodes.
	*
	* @return an array of valid parent nodes.
	*/


	@SuppressWarnings("unchecked")
	public IFilter<INode> parentNodeNames () {
	try {
	Field f = getClass().getField("PARENTS");
	return (IFilter) f.get(null);
	} catch (java.lang.NoSuchFieldException nsfe) {
	// do nothing.
	} catch (Throwable t) {
	t.printStackTrace();
	}
	return Filters.EMPTY ;
	}


	/**
	* Return the value of getExitOnStandardFault
	*
	* @param node
	* @return either yes or no, depending on the setting in the scopes.
	*/

	public String getExitOnStandardFault ( INode node ) {

	INode nn = mSelector.selectParent(node, new IFilter<INode>() {

	public boolean select(INode n) {
	QName name = n.nodeName();
	if (name.equals(ND_SCOPE) == false && name.equals(ND_PROCESS) == false) {
	return false;
	}
	String value = n.getAttribute(AT_EXIT_ON_STANDARD_FAULT);
	if (isEmpty(value) == false) {
	return true;
	}
	return false;
	}
	});

	if (nn != null) {
	return nn.getAttribute(AT_EXIT_ON_STANDARD_FAULT);
	}
	return NO;
	}


	/**
	* Register a type to check.
	* @param node
	*/

	public void registerTypeToCheck (INode node) {

	if (isUndefined(node)) {
	return;
	}

	if ( fTypeToCheckList == null) {

	INode process = mNode.rootNode();
	fTypeToCheckList = getValue(process, "types.to.check", null);
	}

	if (fTypeToCheckList == null) {
	return ;
	}

	if ( fTypeToCheckList.contains ( node ) == false ) {
	fTypeToCheckList.add ( node );
	}

	}



	/**
	* Check if the copy is compatible
	*
	* @param fromNode
	* @param toNode
	*/
	public void compatibleCopyCheck ( INode fromNode, INode toNode ) {

	INode fromTypeNode = getValue(fromNode,"type",null);
	INode toTypeNode = getValue(toNode,"type",null);

	if (hasProblems(fromNode) \|\| hasProblems(toNode)) {
	return ;
	}

	if (fromTypeNode == null && toTypeNode == null) {
	return ;
	}

	/** Compatible assign */
	IProblem problem ;
	if (fromTypeNode == null \|\| toTypeNode == null) {

	problem = createInfo();
	problem.fill("BPELC_COPY__NOT_CHECKED",
	toString(mNode.nodeName()),
	"text.term.from",
	fromTypeNode == null ? "text.term.unspecified" : fromTypeNode ,
	"text.term.to",
	toTypeNode == null ? "text.term.unspecified" : toTypeNode );
	return ;
	}


	// source -> destination
	boolean bCompatible = mModelQuery.check(IModelQueryLookups.TEST_COMPATIBLE_TYPE, fromTypeNode, toTypeNode);

	// if these are simple types, warn if incompatibility found as engines may perform implicit conversion
	// much like XPath does.

	if (mModelQuery.check(IModelQueryLookups.TEST_IS_SIMPLE_TYPE,fromTypeNode,null) &&
	mModelQuery.check(IModelQueryLookups.TEST_IS_SIMPLE_TYPE,toTypeNode,null)) {

	if (bCompatible == false) {

	problem = createWarning();
	problem.fill("BPELC_COPY__INCOMPATIBLE_SIMPLE",
	toString(mNode.nodeName()),
	"text.term.from",
	fromTypeNode,
	"text.term.to",
	toTypeNode
	);

	}

	// Temporary workaround for 3369 - disable check if from/to has a part attr
	String fromPart = fromNode.getAttribute(AT_PART);
	String toPart = toNode.getAttribute(AT_PART);
	if (fromPart != null \|\| toPart != null){
	return;
	}


	} else if (bCompatible == false) {

	problem = createError();
	problem.fill("BPELC_COPY__INCOMPATIBLE",
	toString(mNode.nodeName()),
	"text.term.from",
	fromTypeNode,
	"text.term.to",
	toTypeNode
	);

	}

	}


	/**
	* A generic check against attributes
	*
	* @param node the context node.
	* @param name name of the attribute
	* @param kind 1 for activity node, 0 for generic node
	* @param filter the filter that checks the allowed values
	* @param bMandatory true for mandatory, false otherwise.
	* @return the attribute value or null if the value does not exist or is not allowed.
	*/

	@SuppressWarnings("boxing")
	public String getAttribute ( INode node, QName name, int kind, IFilter<String> filter, boolean bMandatory ) {

	IProblem problem;

	String value = node.getAttribute(name);

	if (bMandatory) {
	if (isEmpty(value)) {
	problem = createError(node);
	problem.setAttribute(IProblem.CONTEXT, name.getLocalPart() );
	problem.fill("BPELC__UNSET_ATTRIBUTE", //$NON-NLS-1$
	toString(node.nodeName()) ,
	toString(name), kind );
	return null;
	}
	}


	if (filter == null \|\| isEmpty(value) ) {
	return value;
	}

	if (filter.select(value)) {
	return value;
	}

	problem = createError(node);
	problem.setAttribute(IProblem.CONTEXT, name.getLocalPart());
	problem.fill("BPELC__INVALID_ATTRIBUTE_VALUE", //$NON-NLS-1$
	toString(node.nodeName()),
	toString(name),
	value,
	filter.toString() ,
	kind);

	return null ;
	}


	/**
	* A generic check against all attributes that are pointers to other
	* objects. For example, portType on invoke, partnerLink, etc. are
	* represented as attributes but in fact refer to larger objects in the
	* models.
	*
	* @param node
	* @param ref the referenced node
	* @param name the name of the attribute that references the node
	* @param kind 1 for activity node, 0 for generic node
	* @return true if the attribute pointer can be resolved, false otherwise
	*/

	@SuppressWarnings("boxing")
	public boolean checkAttributeNode ( INode node, INode ref, QName name, int kind ) {

	IProblem problem;

	if (ref == null) {
	problem = createError(node);
	problem.setAttribute(IProblem.CONTEXT, name);
	problem.fill("BPELC__UNSET_ATTRIBUTE", //$NON-NLS-1$
	toString(node.nodeName()) ,
	toString(name), kind );
	return false;
	}

	if (ref.isResolved() == false) {
	String atValue = node.getAttribute( name );

	problem = createError(node);
	problem.setAttribute(IProblem.CONTEXT, name);
	problem.fill("BPELC__UNRESOLVED_ATTRIBUTE", //$NON-NLS-1$
	toString(node.nodeName()),
	toString(name), kind , atValue );
	return false;
	}

	return true;
	}


	/**
	* Check if NCName is valid.
	*
	* @param node the node on which we are checking.
	* @param ncName the ncName
	* @param atName the attribute name from where the ncName came from.
	* @return return true if checkName succeeds, false otherwise.
	*/


	@SuppressWarnings("boxing")
	public boolean checkNCName ( INode node, String ncName, QName atName ) {

	if (ncName == null \|\| ncName.length() == 0) {

	IProblem problem = createError( node );
	problem.setAttribute(IProblem.CONTEXT, atName.getLocalPart() );
	problem.fill("BPELC__UNSET_ATTRIBUTE",
	toString(node.nodeName()) ,
	atName,
	IConstants.KIND_NODE);
	return false ;
	}

	if (Filters.NC_NAME.select(ncName) == false) {

	IProblem problem = createError( node );
	problem.setAttribute(IProblem.CONTEXT, atName.getLocalPart() );
	problem.fill("General.NCName_Bad", //$NON-NLS-1$
	toString(atName),
	toString(node.nodeName()) , ncName );
	return false;
	}

	// Check for uniqueness of name within a scope or process ?
	return true;
	}


	/**
	* Check the node's validator to see if there are any problems reported on the
	* node.
	*
	* @param node the context node
	* @param ref the referenced node that comes from the node via an attribute
	* @param name the name of the attribute reference
	* @param kind 0 for node, 1 for activity
	* @return true if there are any problems, false otherwise.
	*/

	@SuppressWarnings("boxing")
	public boolean checkValidator ( INode node, INode ref, QName name, int kind ) {

	if (ref == null) {
	return false;
	}

	Validator validator = ref.nodeValidator();
	if (validator == null) {
	return true;
	}

	IProblem problem;
	if (validator.hasProblems()) {
	problem = createWarning(node);
	problem.setAttribute(IProblem.CONTEXT, name.getLocalPart() );
	problem.fill("BPELC_REF_NODE_PROBLEMS", //$NON-NLS-1$
	toString(node.nodeName()),
	toString(ref.nodeName()),
	name,
	kind);

	return false;
	}

	return true;
	}


	/**
	*
	* Return the language (expression or query) from the node.
	*
	* @param node
	* @param atName the attribute name
	* @return the default language.
	*/

	public String getLanguage (INode node, QName atName) {

	// get the expression language
	String lang = node.getAttribute (atName);
	if (lang == null) {
	INode process = node.rootNode ();
	lang = process.getAttribute(atName);
	}

	// the default language

	if (lang == null) {
	return IConstants.XMLNS_XPATH_EXPRESSION_LANGUAGE;
	}
	return lang;
	}


	protected int getNodeKind ( INode node ) {
	if (Filters.ACTIVITIES.select(node)) {
	return IConstants.KIND_ACTIVITY;
	}
	return IConstants.KIND_NODE;
	}


	protected Validator createExpressionValidator ( QName qname ) {

	Validator object = RuleFactory.INSTANCE.createValidator ( qname );

	IProblem problem;

	if (object == null) {

	problem = createWarning();
	problem.fill("BPELC__NO_EXPRESSION_VALIDATOR", //$NON-NLS-1$
	toString(mNode.nodeName()),
	qname.getNamespaceURI()
	);
	return null;
	}
	return object;
	}



	}