Back to index...

	/*
	* reserved comment block
	* DO NOT REMOVE OR ALTER!
	*/
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.sun.org.apache.xerces.internal.impl.xs.identity;

	import com.sun.org.apache.xerces.internal.impl.xpath.XPathException;
	import com.sun.org.apache.xerces.internal.impl.xs.util.ShortListImpl;
	import com.sun.org.apache.xerces.internal.util.SymbolTable;
	import com.sun.org.apache.xerces.internal.util.XMLChar;
	import com.sun.org.apache.xerces.internal.xni.NamespaceContext;
	import com.sun.org.apache.xerces.internal.xs.ShortList;
	import com.sun.org.apache.xerces.internal.xs.XSComplexTypeDefinition;
	import com.sun.org.apache.xerces.internal.xs.XSConstants;
	import com.sun.org.apache.xerces.internal.xs.XSTypeDefinition;

	/**
	* Schema identity constraint field.
	*
	* @xerces.internal
	*
	* @author Andy Clark, IBM
	*/
	public class Field {

	//
	// Data
	//

	/** Field XPath. */
	protected final Field.XPath fXPath;


	/** Identity constraint. */
	protected final IdentityConstraint fIdentityConstraint;

	//
	// Constructors
	//

	/** Constructs a field. */
	public Field(Field.XPath xpath,
	IdentityConstraint identityConstraint) {
	fXPath = xpath;
	fIdentityConstraint = identityConstraint;
	} // <init>(Field.XPath,IdentityConstraint)

	//
	// Public methods
	//

	/** Returns the field XPath. */
	public com.sun.org.apache.xerces.internal.impl.xpath.XPath getXPath() {
	return fXPath;
	} // getXPath():org.apache.xerces.impl.v1.schema.identity.XPath

	/** Returns the identity constraint. */
	public IdentityConstraint getIdentityConstraint() {
	return fIdentityConstraint;
	} // getIdentityConstraint():IdentityConstraint

	// factory method

	/** Creates a field matcher. */
	public XPathMatcher createMatcher(ValueStore store) {
	return new Field.Matcher(fXPath, store);
	} // createMatcher(ValueStore):XPathMatcher

	//
	// Object methods
	//

	/** Returns a string representation of this object. */
	public String toString() {
	return fXPath.toString();
	} // toString():String

	//
	// Classes
	//

	/**
	* Field XPath.
	*
	* @author Andy Clark, IBM
	*/
	public static class XPath
	extends com.sun.org.apache.xerces.internal.impl.xpath.XPath {

	//
	// Constructors
	//

	/** Constructs a field XPath expression. */
	public XPath(String xpath,
	SymbolTable symbolTable,
	NamespaceContext context) throws XPathException {
	super(fixupXPath(xpath), symbolTable, context);

	// verify that only one attribute is selected per branch
	for (int i=0;i<fLocationPaths.length;i++) {
	for(int j=0; j<fLocationPaths[i].steps.length; j++) {
	com.sun.org.apache.xerces.internal.impl.xpath.XPath.Axis axis =
	fLocationPaths[i].steps[j].axis;
	if (axis.type == XPath.Axis.ATTRIBUTE &&
	(j < fLocationPaths[i].steps.length-1)) {
	throw new XPathException("c-fields-xpaths");
	}
	}
	}
	} // <init>(String,SymbolTable,NamespacesContext)

	/** Fixup XPath expression. Avoid creating a new String if possible. */
	private static String fixupXPath(String xpath) {

	final int end = xpath.length();
	int offset = 0;
	boolean whitespace = true;
	char c;

	// NOTE: We have to prefix the field XPath with "./" in
	// order to handle selectors such as "@attr" that
	// select the attribute because the fields could be
	// relative to the selector element. -Ac
	// Unless xpath starts with a descendant node -Achille Fokoue
	// ... or a / or a . - NG
	for (; offset < end; ++offset) {
	c = xpath.charAt(offset);
	if (whitespace) {
	if (!XMLChar.isSpace(c)) {
	if (c == '.' \|\| c == '/') {
	whitespace = false;
	}
	else if (c != '\|') {
	return fixupXPath2(xpath, offset, end);
	}
	}
	}
	else if (c == '\|') {
	whitespace = true;
	}
	}
	return xpath;

	} // fixupXPath(String):String

	private static String fixupXPath2(String xpath, int offset, final int end) {

	StringBuffer buffer = new StringBuffer(end + 2);
	for (int i = 0; i < offset; ++i) {
	buffer.append(xpath.charAt(i));
	}
	buffer.append("./");

	boolean whitespace = false;
	char c;

	for (; offset < end; ++offset) {
	c = xpath.charAt(offset);
	if (whitespace) {
	if (!XMLChar.isSpace(c)) {
	if (c == '.' \|\| c == '/') {
	whitespace = false;
	}
	else if (c != '\|') {
	buffer.append("./");
	whitespace = false;
	}
	}
	}
	else if (c == '\|') {
	whitespace = true;
	}
	buffer.append(c);
	}
	return buffer.toString();

	} // fixupXPath2(String, int, int):String

	} // class XPath

	/**
	* Field matcher.
	*
	* @author Andy Clark, IBM
	*/
	protected class Matcher
	extends XPathMatcher {

	//
	// Data
	//

	/** Value store for data values. */
	protected final ValueStore fStore;

	/** A flag indicating whether the field is allowed to match a value. */
	protected boolean fMayMatch = true;

	//
	// Constructors
	//

	/** Constructs a field matcher. */
	public Matcher(Field.XPath xpath, ValueStore store) {
	super(xpath);
	fStore = store;
	} // <init>(Field.XPath,ValueStore)

	//
	// XPathHandler methods
	//

	/**
	* This method is called when the XPath handler matches the
	* XPath expression.
	*/
	protected void matched(Object actualValue, short valueType, ShortList itemValueType, boolean isNil) {
	super.matched(actualValue, valueType, itemValueType, isNil);
	if(isNil && (fIdentityConstraint.getCategory() == IdentityConstraint.IC_KEY)) {
	String code = "KeyMatchesNillable";
	fStore.reportError(code,
	new Object[]{fIdentityConstraint.getElementName(), fIdentityConstraint.getIdentityConstraintName()});
	}
	fStore.addValue(Field.this, fMayMatch, actualValue, convertToPrimitiveKind(valueType), convertToPrimitiveKind(itemValueType));
	// once we've stored the value for this field, we set the mayMatch
	// member to false so that in the same scope, we don't match any more
	// values (and throw an error instead).
	fMayMatch = false;
	} // matched(String)

	private short convertToPrimitiveKind(short valueType) {
	/** Primitive datatypes. */
	if (valueType <= XSConstants.NOTATION_DT) {
	return valueType;
	}
	/** Types derived from string. */
	if (valueType <= XSConstants.ENTITY_DT) {
	return XSConstants.STRING_DT;
	}
	/** Types derived from decimal. */
	if (valueType <= XSConstants.POSITIVEINTEGER_DT) {
	return XSConstants.DECIMAL_DT;
	}
	/** Other types. */
	return valueType;
	}

	private ShortList convertToPrimitiveKind(ShortList itemValueType) {
	if (itemValueType != null) {
	int i;
	final int length = itemValueType.getLength();
	for (i = 0; i < length; ++i) {
	short type = itemValueType.item(i);
	if (type != convertToPrimitiveKind(type)) {
	break;
	}
	}
	if (i != length) {
	final short [] arr = new short[length];
	for (int j = 0; j < i; ++j) {
	arr[j] = itemValueType.item(j);
	}
	for(; i < length; ++i) {
	arr[i] = convertToPrimitiveKind(itemValueType.item(i));
	}
	return new ShortListImpl(arr, arr.length);
	}
	}
	return itemValueType;
	}

	protected void handleContent(XSTypeDefinition type, boolean nillable, Object actualValue, short valueType, ShortList itemValueType) {
	if (type == null \|\|
	type.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE &&
	((XSComplexTypeDefinition) type).getContentType()
	!= XSComplexTypeDefinition.CONTENTTYPE_SIMPLE) {

	// the content must be simpleType content
	fStore.reportError( "cvc-id.3", new Object[] {
	fIdentityConstraint.getName(),
	fIdentityConstraint.getElementName()});

	}
	fMatchedString = actualValue;
	matched(fMatchedString, valueType, itemValueType, nillable);
	} // handleContent(XSElementDecl, String)

	} // class Matcher

	} // class Field

Back to index...