/*
* The Apache Software License, Version 1.1
*
*
* Copyright (c) 2001-2003 The Apache Software Foundation.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Xerces" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation and was
* originally based on software copyright (c) 1999, International
* Business Machines, Inc., http://www.apache.org. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
package com.sun.org.apache.xerces.internal.impl.xs.identity;
import com.sun.org.apache.xerces.internal.xs.XSIDCDefinition;
import com.sun.org.apache.xerces.internal.xs.StringList;
import com.sun.org.apache.xerces.internal.xs.XSNamespaceItem;
import com.sun.org.apache.xerces.internal.xs.XSObjectList;
import com.sun.org.apache.xerces.internal.xs.XSConstants;
import com.sun.org.apache.xerces.internal.impl.xs.util.StringListImpl;
import com.sun.org.apache.xerces.internal.impl.xs.util.XSObjectListImpl;
import com.sun.org.apache.xerces.internal.impl.xs.XSAnnotationImpl;
/**
* Base class of Schema identity constraint.
*
* @author Andy Clark, IBM
* @version $Id: IdentityConstraint.java,v 1.9 2003/11/11 20:14:59 sandygao Exp $
*/
public abstract class IdentityConstraint implements XSIDCDefinition {
//
// Data
//
/** type */
protected short type;
/** target namespace */
protected String fNamespace;
/** Identity constraint name. */
protected String fIdentityConstraintName;
/** name of owning element */
protected String fElementName;
/** Selector. */
protected Selector fSelector;
/** Field count. */
protected int fFieldCount;
/** Fields. */
protected Field[] fFields;
// optional annotations
protected XSAnnotationImpl [] fAnnotations = null;
// number of annotations in this identity constraint
protected int fNumAnnotations;
//
// Constructors
//
/** Default constructor. */
protected IdentityConstraint(String namespace, String identityConstraintName, String elemName) {
fNamespace = namespace;
fIdentityConstraintName = identityConstraintName;
fElementName = elemName;
} // <init>(String,String)
//
// Public methods
//
/** Returns the identity constraint name. */
public String getIdentityConstraintName() {
return fIdentityConstraintName;
} // getIdentityConstraintName():String
/** Sets the selector. */
public void setSelector(Selector selector) {
fSelector = selector;
} // setSelector(Selector)
/** Returns the selector. */
public Selector getSelector() {
return fSelector;
} // getSelector():Selector
/** Adds a field. */
public void addField(Field field) {
if (fFields == null)
fFields = new Field[4];
else if (fFieldCount == fFields.length)
fFields = resize(fFields, fFieldCount*2);
fFields[fFieldCount++] = field;
} // addField(Field)
/** Returns the field count. */
public int getFieldCount() {
return fFieldCount;
} // getFieldCount():int
/** Returns the field at the specified index. */
public Field getFieldAt(int index) {
return fFields[index];
} // getFieldAt(int):Field
// get the name of the owning element
public String getElementName () {
return fElementName;
} // getElementName(): String
//
// Object methods
//
/** Returns a string representation of this object. */
public String toString() {
String s = super.toString();
int index1 = s.lastIndexOf('$');
if (index1 != -1) {
return s.substring(index1 + 1);
}
int index2 = s.lastIndexOf('.');
if (index2 != -1) {
return s.substring(index2 + 1);
}
return s;
} // toString():String
// equals: returns true if and only if the String
// representations of all members of both objects (except for
// the elenemtName field) are equal.
public boolean equals(IdentityConstraint id) {
boolean areEqual = fIdentityConstraintName.equals(id.fIdentityConstraintName);
if(!areEqual) return false;
areEqual = fSelector.toString().equals(id.fSelector.toString());
if(!areEqual) return false;
areEqual = (fFieldCount == id.fFieldCount);
if(!areEqual) return false;
for(int i=0; i<fFieldCount; i++)
if(!fFields[i].toString().equals(id.fFields[i].toString())) return false;
return true;
} // equals
static final Field[] resize(Field[] oldArray, int newSize) {
Field[] newArray = new Field[newSize];
System.arraycopy(oldArray, 0, newArray, 0, oldArray.length);
return newArray;
}
/**
* Get the type of the object, i.e ELEMENT_DECLARATION.
*/
public short getType() {
return XSConstants.IDENTITY_CONSTRAINT;
}
/**
* The <code>name</code> of this <code>XSObject</code> depending on the
* <code>XSObject</code> type.
*/
public String getName() {
return fIdentityConstraintName;
}
/**
* The namespace URI of this node, or <code>null</code> if it is
* unspecified. defines how a namespace URI is attached to schema
* components.
*/
public String getNamespace() {
return fNamespace;
}
/**
* {identity-constraint category} One of key, keyref or unique.
*/
public short getCategory() {
return type;
}
/**
* {selector} A restricted XPath ([XPath]) expression
*/
public String getSelectorStr() {
return fSelector.toString();
}
/**
* {fields} A non-empty list of restricted XPath ([XPath]) expressions.
*/
public StringList getFieldStrs() {
String[] strs = new String[fFieldCount];
for (int i = 0; i < fFieldCount; i++)
strs[i] = fFields[i].toString();
return new StringListImpl(strs, fFieldCount);
}
/**
* {referenced key} Required if {identity-constraint category} is keyref,
* forbidden otherwise. An identity-constraint definition with
* {identity-constraint category} equal to key or unique.
*/
public XSIDCDefinition getRefKey() {
return null;
}
/**
* Optional. Annotation.
*/
public XSObjectList getAnnotations() {
return new XSObjectListImpl(fAnnotations, fNumAnnotations);
}
/**
* @see com.sun.org.apache.xerces.internal.xs.XSObject#getNamespaceItem()
*/
public XSNamespaceItem getNamespaceItem() {
// REVISIT: implement
return null;
}
public void addAnnotation(XSAnnotationImpl annotation) {
if(annotation == null)
return;
if(fAnnotations == null) {
fAnnotations = new XSAnnotationImpl[2];
} else if(fNumAnnotations == fAnnotations.length) {
XSAnnotationImpl[] newArray = new XSAnnotationImpl[fNumAnnotations << 1];
System.arraycopy(fAnnotations, 0, newArray, 0, fNumAnnotations);
fAnnotations = newArray;
}
fAnnotations[fNumAnnotations++] = annotation;
}
} // class IdentityConstraint
|
