/*
* 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.
*/
/*
* $Id: XSLTElementDef.java 468640 2006-10-28 06:53:53Z minchau $
*/
package org.apache.xalan.processor;
import java.util.Enumeration;
import java.util.Hashtable;
import org.apache.xalan.templates.Constants;
import org.apache.xml.utils.QName;
/**
* This class defines the allowed structure for an element in a XSLT stylesheet,
* is meant to reflect the structure defined in http://www.w3.org/TR/xslt#dtd, and the
* mapping between Xalan classes and the markup elements in the XSLT instance.
* This actually represents both text nodes and elements.
*/
public class XSLTElementDef
{
/**
* Construct an instance of XSLTElementDef. This must be followed by a
* call to build().
*/
XSLTElementDef(){}
/**
* Construct an instance of XSLTElementDef.
*
* @param namespace The Namespace URI, "*", or null.
* @param name The local name (without prefix), "*", or null.
* @param nameAlias A potential alias for the name, or null.
* @param elements An array of allowed child element defs, or null.
* @param attributes An array of allowed attribute defs, or null.
* @param contentHandler The element processor for this element.
* @param classObject The class of the object that this element def should produce.
*/
XSLTElementDef(XSLTSchema schema, String namespace, String name, String nameAlias,
XSLTElementDef[] elements, XSLTAttributeDef[] attributes,
XSLTElementProcessor contentHandler, Class classObject)
{
build(namespace, name, nameAlias, elements, attributes, contentHandler,
classObject);
if ( (null != namespace)
&& (namespace.equals(Constants.S_XSLNAMESPACEURL)
|| namespace.equals(Constants.S_BUILTIN_EXTENSIONS_URL)
|| namespace.equals(Constants.S_BUILTIN_OLD_EXTENSIONS_URL)))
{
schema.addAvailableElement(new QName(namespace, name));
if(null != nameAlias)
schema.addAvailableElement(new QName(namespace, nameAlias));
}
}
/**
* Construct an instance of XSLTElementDef.
*
* @param namespace The Namespace URI, "*", or null.
* @param name The local name (without prefix), "*", or null.
* @param nameAlias A potential alias for the name, or null.
* @param elements An array of allowed child element defs, or null.
* @param attributes An array of allowed attribute defs, or null.
* @param contentHandler The element processor for this element.
* @param classObject The class of the object that this element def should produce.
* @param has_required true if this element has required elements by the XSLT specification.
*/
XSLTElementDef(XSLTSchema schema, String namespace, String name, String nameAlias,
XSLTElementDef[] elements, XSLTAttributeDef[] attributes,
XSLTElementProcessor contentHandler, Class classObject, boolean has_required)
{
this.m_has_required = has_required;
build(namespace, name, nameAlias, elements, attributes, contentHandler,
classObject);
if ( (null != namespace)
&& (namespace.equals(Constants.S_XSLNAMESPACEURL)
|| namespace.equals(Constants.S_BUILTIN_EXTENSIONS_URL)
|| namespace.equals(Constants.S_BUILTIN_OLD_EXTENSIONS_URL)))
{
schema.addAvailableElement(new QName(namespace, name));
if(null != nameAlias)
schema.addAvailableElement(new QName(namespace, nameAlias));
}
}
/**
* Construct an instance of XSLTElementDef.
*
* @param namespace The Namespace URI, "*", or null.
* @param name The local name (without prefix), "*", or null.
* @param nameAlias A potential alias for the name, or null.
* @param elements An array of allowed child element defs, or null.
* @param attributes An array of allowed attribute defs, or null.
* @param contentHandler The element processor for this element.
* @param classObject The class of the object that this element def should produce.
* @param has_required true if this element has required elements by the XSLT specification.
* @param required true if this element is required by the XSLT specification.
*/
XSLTElementDef(XSLTSchema schema, String namespace, String name, String nameAlias,
XSLTElementDef[] elements, XSLTAttributeDef[] attributes,
XSLTElementProcessor contentHandler, Class classObject,
boolean has_required, boolean required)
{
this(schema, namespace, name, nameAlias,
elements, attributes,
contentHandler, classObject, has_required);
this.m_required = required;
}
/**
* Construct an instance of XSLTElementDef.
*
* @param namespace The Namespace URI, "*", or null.
* @param name The local name (without prefix), "*", or null.
* @param nameAlias A potential alias for the name, or null.
* @param elements An array of allowed child element defs, or null.
* @param attributes An array of allowed attribute defs, or null.
* @param contentHandler The element processor for this element.
* @param classObject The class of the object that this element def should produce.
* @param has_required true if this element has required elements by the XSLT specification.
* @param required true if this element is required by the XSLT specification.
* @param order the order this element should appear according to the XSLT specification.
* @param multiAllowed whether this element is allowed more than once
*/
XSLTElementDef(XSLTSchema schema, String namespace, String name, String nameAlias,
XSLTElementDef[] elements, XSLTAttributeDef[] attributes,
XSLTElementProcessor contentHandler, Class classObject,
boolean has_required, boolean required, int order,
boolean multiAllowed)
{
this(schema, namespace, name, nameAlias,
elements, attributes,
contentHandler, classObject, has_required, required);
this.m_order = order;
this.m_multiAllowed = multiAllowed;
}
/**
* Construct an instance of XSLTElementDef.
*
* @param namespace The Namespace URI, "*", or null.
* @param name The local name (without prefix), "*", or null.
* @param nameAlias A potential alias for the name, or null.
* @param elements An array of allowed child element defs, or null.
* @param attributes An array of allowed attribute defs, or null.
* @param contentHandler The element processor for this element.
* @param classObject The class of the object that this element def should produce.
* @param has_required true if this element has required elements by the XSLT specification.
* @param required true if this element is required by the XSLT specification.
* @param has_order whether this element has ordered child elements
* @param order the order this element should appear according to the XSLT specification.
* @param multiAllowed whether this element is allowed more than once
*/
XSLTElementDef(XSLTSchema schema, String namespace, String name, String nameAlias,
XSLTElementDef[] elements, XSLTAttributeDef[] attributes,
XSLTElementProcessor contentHandler, Class classObject,
boolean has_required, boolean required, boolean has_order, int order,
boolean multiAllowed)
{
this(schema, namespace, name, nameAlias,
elements, attributes,
contentHandler, classObject, has_required, required);
this.m_order = order;
this.m_multiAllowed = multiAllowed;
this.m_isOrdered = has_order;
}
/**
* Construct an instance of XSLTElementDef.
*
* @param namespace The Namespace URI, "*", or null.
* @param name The local name (without prefix), "*", or null.
* @param nameAlias A potential alias for the name, or null.
* @param elements An array of allowed child element defs, or null.
* @param attributes An array of allowed attribute defs, or null.
* @param contentHandler The element processor for this element.
* @param classObject The class of the object that this element def should produce.
* @param has_order whether this element has ordered child elements
* @param order the order this element should appear according to the XSLT specification.
* @param multiAllowed whether this element is allowed more than once
*/
XSLTElementDef(XSLTSchema schema, String namespace, String name, String nameAlias,
XSLTElementDef[] elements, XSLTAttributeDef[] attributes,
XSLTElementProcessor contentHandler, Class classObject,
boolean has_order, int order, boolean multiAllowed)
{
this(schema, namespace, name, nameAlias,
elements, attributes,
contentHandler, classObject,
order, multiAllowed);
this.m_isOrdered = has_order;
}
/**
* Construct an instance of XSLTElementDef.
*
* @param namespace The Namespace URI, "*", or null.
* @param name The local name (without prefix), "*", or null.
* @param nameAlias A potential alias for the name, or null.
* @param elements An array of allowed child element defs, or null.
* @param attributes An array of allowed attribute defs, or null.
* @param contentHandler The element processor for this element.
* @param classObject The class of the object that this element def should produce.
* @param order the order this element should appear according to the XSLT specification.
* @param multiAllowed whether this element is allowed more than once
*/
XSLTElementDef(XSLTSchema schema, String namespace, String name, String nameAlias,
XSLTElementDef[] elements, XSLTAttributeDef[] attributes,
XSLTElementProcessor contentHandler, Class classObject,
int order, boolean multiAllowed)
{
this(schema, namespace, name, nameAlias, elements, attributes, contentHandler,
classObject);
this.m_order = order;
this.m_multiAllowed = multiAllowed;
}
/**
* Construct an instance of XSLTElementDef that represents text.
*
* @param classObject The class of the object that this element def should produce.
* @param contentHandler The element processor for this element.
* @param type Content type, one of T_ELEMENT, T_PCDATA, or T_ANY.
*/
XSLTElementDef(Class classObject, XSLTElementProcessor contentHandler,
int type)
{
this.m_classObject = classObject;
this.m_type = type;
setElementProcessor(contentHandler);
}
/**
* Construct an instance of XSLTElementDef.
*
* @param namespace The Namespace URI, "*", or null.
* @param name The local name (without prefix), "*", or null.
* @param nameAlias A potential alias for the name, or null.
* @param elements An array of allowed child element defs, or null.
* @param attributes An array of allowed attribute defs, or null.
* @param contentHandler The element processor for this element.
* @param classObject The class of the object that this element def should produce.
*/
void build(String namespace, String name, String nameAlias,
XSLTElementDef[] elements, XSLTAttributeDef[] attributes,
XSLTElementProcessor contentHandler, Class classObject)
{
this.m_namespace = namespace;
this.m_name = name;
this.m_nameAlias = nameAlias;
this.m_elements = elements;
this.m_attributes = attributes;
setElementProcessor(contentHandler);
this.m_classObject = classObject;
if (hasRequired() && m_elements != null)
{
int n = m_elements.length;
for (int i = 0; i < n; i++)
{
XSLTElementDef def = m_elements[i];
if (def != null && def.getRequired())
{
if (m_requiredFound == null)
m_requiredFound = new Hashtable();
m_requiredFound.put(def.getName(), "xsl:" +def.getName());
}
}
}
}
/**
* Tell if two objects are equal, when either one may be null.
* If both are null, they are considered equal.
*
* @param obj1 A reference to the first object, or null.
* @param obj2 A reference to the second object, or null.
*
* @return true if the to objects are equal by both being null or
* because obj2.equals(obj1) returns true.
*/
private static boolean equalsMayBeNull(Object obj1, Object obj2)
{
return (obj2 == obj1)
|| ((null != obj1) && (null != obj2) && obj2.equals(obj1));
}
/**
* Tell if the two string refs are equal,
* equality being defined as:
* 1) Both strings are null.
* 2) One string is null and the other is empty.
* 3) Both strings are non-null, and equal.
*
* @param s1 A reference to the first string, or null.
* @param s2 A reference to the second string, or null.
*
* @return true if Both strings are null, or if
* one string is null and the other is empty, or if
* both strings are non-null, and equal because
* s1.equals(s2) returns true.
*/
private static boolean equalsMayBeNullOrZeroLen(String s1, String s2)
{
int len1 = (s1 == null) ? 0 : s1.length();
int len2 = (s2 == null) ? 0 : s2.length();
return (len1 != len2) ? false
: (len1 == 0) ? true
: s1.equals(s2);
}
/** Content type enumerations */
static final int T_ELEMENT = 1, T_PCDATA = 2, T_ANY = 3;
/**
* The type of this element.
*/
private int m_type = T_ELEMENT;
/**
* Get the type of this element.
*
* @return Content type, one of T_ELEMENT, T_PCDATA, or T_ANY.
*/
int getType()
{
return m_type;
}
/**
* Set the type of this element.
*
* @param t Content type, one of T_ELEMENT, T_PCDATA, or T_ANY.
*/
void setType(int t)
{
m_type = t;
}
/**
* The allowed namespace for this element.
*/
private String m_namespace;
/**
* Get the allowed namespace for this element.
*
* @return The Namespace URI, "*", or null.
*/
String getNamespace()
{
return m_namespace;
}
/**
* The name of this element.
*/
private String m_name;
/**
* Get the local name of this element.
*
* @return The local name of this element, "*", or null.
*/
String getName()
{
return m_name;
}
/**
* The name of this element.
*/
private String m_nameAlias;
/**
* Get the name of this element.
*
* @return A potential alias for the name, or null.
*/
String getNameAlias()
{
return m_nameAlias;
}
/**
* The allowed elements for this type.
*/
private XSLTElementDef[] m_elements;
/**
* Get the allowed elements for this type.
*
* @return An array of allowed child element defs, or null.
* @xsl.usage internal
*/
public XSLTElementDef[] getElements()
{
return m_elements;
}
/**
* Set the allowed elements for this type.
*
* @param defs An array of allowed child element defs, or null.
*/
void setElements(XSLTElementDef[] defs)
{
m_elements = defs;
}
/**
* Tell if the namespace URI and local name match this
* element.
* @param uri The namespace uri, which may be null.
* @param localName The local name of an element, which may be null.
*
* @return true if the uri and local name arguments are considered
* to match the uri and local name of this element def.
*/
private boolean QNameEquals(String uri, String localName)
{
return (equalsMayBeNullOrZeroLen(m_namespace, uri)
&& (equalsMayBeNullOrZeroLen(m_name, localName)
|| equalsMayBeNullOrZeroLen(m_nameAlias, localName)));
}
/**
* Given a namespace URI, and a local name, get the processor
* for the element, or return null if not allowed.
*
* @param uri The Namespace URI, or an empty string.
* @param localName The local name (without prefix), or empty string if not namespace processing.
*
* @return The element processor that matches the arguments, or null.
*/
XSLTElementProcessor getProcessorFor(String uri, String localName)
{
XSLTElementProcessor elemDef = null; // return value
if (null == m_elements)
return null;
int n = m_elements.length;
int order = -1;
boolean multiAllowed = true;
for (int i = 0; i < n; i++)
{
XSLTElementDef def = m_elements[i];
// A "*" signals that the element allows literal result
// elements, so just assign the def, and continue to
// see if anything else matches.
if (def.m_name.equals("*"))
{
// Don't allow xsl elements
if (!equalsMayBeNullOrZeroLen(uri, Constants.S_XSLNAMESPACEURL))
{
elemDef = def.m_elementProcessor;
order = def.getOrder();
multiAllowed = def.getMultiAllowed();
}
}
else if (def.QNameEquals(uri, localName))
{
if (def.getRequired())
this.setRequiredFound(def.getName(), true);
order = def.getOrder();
multiAllowed = def.getMultiAllowed();
elemDef = def.m_elementProcessor;
break;
}
}
if (elemDef != null && this.isOrdered())
{
int lastOrder = getLastOrder();
if (order > lastOrder)
setLastOrder(order);
else if (order == lastOrder && !multiAllowed)
{
return null;
}
else if (order < lastOrder && order > 0)
{
return null;
}
}
return elemDef;
}
/**
* Given an unknown element, get the processor
* for the element.
*
* @param uri The Namespace URI, or an empty string.
* @param localName The local name (without prefix), or empty string if not namespace processing.
*
* @return normally a {@link ProcessorUnknown} reference.
* @see ProcessorUnknown
*/
XSLTElementProcessor getProcessorForUnknown(String uri, String localName)
{
// XSLTElementProcessor lreDef = null; // return value
if (null == m_elements)
return null;
int n = m_elements.length;
for (int i = 0; i < n; i++)
{
XSLTElementDef def = m_elements[i];
if (def.m_name.equals("unknown") && uri.length() > 0)
{
return def.m_elementProcessor;
}
}
return null;
}
/**
* The allowed attributes for this type.
*/
private XSLTAttributeDef[] m_attributes;
/**
* Get the allowed attributes for this type.
*
* @return An array of allowed attribute defs, or null.
*/
XSLTAttributeDef[] getAttributes()
{
return m_attributes;
}
/**
* Given a namespace URI, and a local name, return the element's
* attribute definition, if it has one.
*
* @param uri The Namespace URI, or an empty string.
* @param localName The local name (without prefix), or empty string if not namespace processing.
*
* @return The attribute def that matches the arguments, or null.
*/
XSLTAttributeDef getAttributeDef(String uri, String localName)
{
XSLTAttributeDef defaultDef = null;
XSLTAttributeDef[] attrDefs = getAttributes();
int nAttrDefs = attrDefs.length;
for (int k = 0; k < nAttrDefs; k++)
{
XSLTAttributeDef attrDef = attrDefs[k];
String uriDef = attrDef.getNamespace();
String nameDef = attrDef.getName();
if (nameDef.equals("*") && (equalsMayBeNullOrZeroLen(uri, uriDef) ||
(uriDef != null && uriDef.equals("*") && uri!=null && uri.length() > 0 )))
{
return attrDef;
}
else if (nameDef.equals("*") && (uriDef == null))
{
// In this case, all attributes are legal, so return
// this as the last resort.
defaultDef = attrDef;
}
else if (equalsMayBeNullOrZeroLen(uri, uriDef)
&& localName.equals(nameDef))
{
return attrDef;
}
}
if (null == defaultDef)
{
if (uri.length() > 0 && !equalsMayBeNullOrZeroLen(uri, Constants.S_XSLNAMESPACEURL))
{
return XSLTAttributeDef.m_foreignAttr;
}
}
return defaultDef;
}
/**
* If non-null, the ContentHandler/TransformerFactory for this element.
*/
private XSLTElementProcessor m_elementProcessor;
/**
* Return the XSLTElementProcessor for this element.
*
* @return The element processor for this element.
* @xsl.usage internal
*/
public XSLTElementProcessor getElementProcessor()
{
return m_elementProcessor;
}
/**
* Set the XSLTElementProcessor for this element.
*
* @param handler The element processor for this element.
* @xsl.usage internal
*/
public void setElementProcessor(XSLTElementProcessor handler)
{
if (handler != null)
{
m_elementProcessor = handler;
m_elementProcessor.setElemDef(this);
}
}
/**
* If non-null, the class object that should in instantiated for
* a Xalan instance of this element.
*/
private Class m_classObject;
/**
* Return the class object that should in instantiated for
* a Xalan instance of this element.
*
* @return The class of the object that this element def should produce, or null.
*/
Class getClassObject()
{
return m_classObject;
}
/**
* If true, this has a required element.
*/
private boolean m_has_required = false;
/**
* Get whether or not this has a required element.
*
* @return true if this this has a required element.
*/
boolean hasRequired()
{
return m_has_required;
}
/**
* If true, this is a required element.
*/
private boolean m_required = false;
/**
* Get whether or not this is a required element.
*
* @return true if this is a required element.
*/
boolean getRequired()
{
return m_required;
}
Hashtable m_requiredFound;
/**
* Set this required element found.
*
*/
void setRequiredFound(String elem, boolean found)
{
if (m_requiredFound.get(elem) != null)
m_requiredFound.remove(elem);
}
/**
* Get whether all required elements were found.
*
* @return true if all required elements were found.
*/
boolean getRequiredFound()
{
if (m_requiredFound == null)
return true;
return m_requiredFound.isEmpty();
}
/**
* Get required elements that were not found.
*
* @return required elements that were not found.
*/
String getRequiredElem()
{
if (m_requiredFound == null)
return null;
Enumeration elems = m_requiredFound.elements();
String s = "";
boolean first = true;
while (elems.hasMoreElements())
{
if (first)
first = false;
else
s = s + ", ";
s = s + (String)elems.nextElement();
}
return s;
}
boolean m_isOrdered = false;
/**
* Get whether this element requires ordered children.
*
* @return true if this element requires ordered children.
*/
boolean isOrdered()
{
/*if (!m_CheckedOrdered)
{
m_CheckedOrdered = true;
m_isOrdered = false;
if (null == m_elements)
return false;
int n = m_elements.length;
for (int i = 0; i < n; i++)
{
if (m_elements[i].getOrder() > 0)
{
m_isOrdered = true;
return true;
}
}
return false;
}
else*/
return m_isOrdered;
}
/**
* the order that this element should appear, or -1 if not ordered
*/
private int m_order = -1;
/**
* Get the order that this element should appear .
*
* @return the order that this element should appear.
*/
int getOrder()
{
return m_order;
}
/**
* the highest order of child elements have appeared so far,
* or -1 if not ordered
*/
private int m_lastOrder = -1;
/**
* Get the highest order of child elements have appeared so far .
*
* @return the highest order of child elements have appeared so far.
*/
int getLastOrder()
{
return m_lastOrder;
}
/**
* Set the highest order of child elements have appeared so far .
*
* @param order the highest order of child elements have appeared so far.
*/
void setLastOrder(int order)
{
m_lastOrder = order ;
}
/**
* True if this element can appear multiple times
*/
private boolean m_multiAllowed = true;
/**
* Get whether this element can appear multiple times
*
* @return true if this element can appear multiple times
*/
boolean getMultiAllowed()
{
return m_multiAllowed;
}
}