/*
* This library is part of OpenCms -
* the Open Source Content Management System
*
* Copyright (c) Alkacon Software GmbH (http://www.alkacon.com)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* For further information about Alkacon Software GmbH, please see the
* company website: http://www.alkacon.com
*
* For further information about OpenCms, please see the
* project website: http://www.opencms.org
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package org.opencms.xml;
import org.opencms.file.CmsObject;
import org.opencms.file.CmsResource;
import org.opencms.file.CmsResourceFilter;
import org.opencms.file.types.CmsResourceTypeXmlContent;
import org.opencms.file.types.I_CmsResourceType;
import org.opencms.main.CmsException;
import org.opencms.main.CmsLog;
import org.opencms.main.OpenCms;
import org.opencms.relations.CmsRelation;
import org.opencms.relations.CmsRelationFilter;
import org.opencms.relations.CmsRelationType;
import org.opencms.util.CmsStringUtil;
import org.opencms.xml.content.CmsDefaultXmlContentHandler;
import org.opencms.xml.content.CmsXmlContent;
import org.opencms.xml.content.CmsXmlContentFactory;
import org.opencms.xml.content.I_CmsXmlContentHandler;
import org.opencms.xml.types.CmsXmlLocaleValue;
import org.opencms.xml.types.CmsXmlNestedContentDefinition;
import org.opencms.xml.types.CmsXmlStringValue;
import org.opencms.xml.types.I_CmsXmlContentValue;
import org.opencms.xml.types.I_CmsXmlSchemaType;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import org.apache.commons.logging.Log;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.Namespace;
import org.dom4j.QName;
import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
/**
* Describes the structure definition of an XML content object.<p>
*
* @since 6.0.0
*/
public class CmsXmlContentDefinition implements Cloneable {
/**
* Enumeration of possible sequence types in a content definition.
*/
public enum SequenceType {
/** A <code>xsd:choice</code> where the choice elements can appear more than once in a mix. */
MULTIPLE_CHOICE,
/** A simple <code>xsd:sequence</code>. */
SEQUENCE,
/** A <code>xsd:choice</code> where only one choice element can be selected. */
SINGLE_CHOICE
}
/** Constant for the XML schema attribute "mapto". */
public static final String XSD_ATTRIBUTE_DEFAULT = "default";
/** Constant for the XML schema attribute "elementFormDefault". */
public static final String XSD_ATTRIBUTE_ELEMENT_FORM_DEFAULT = "elementFormDefault";
/** Constant for the XML schema attribute "maxOccurs". */
public static final String XSD_ATTRIBUTE_MAX_OCCURS = "maxOccurs";
/** Constant for the XML schema attribute "minOccurs". */
public static final String XSD_ATTRIBUTE_MIN_OCCURS = "minOccurs";
/** Constant for the XML schema attribute "name". */
public static final String XSD_ATTRIBUTE_NAME = "name";
/** Constant for the XML schema attribute "schemaLocation". */
public static final String XSD_ATTRIBUTE_SCHEMA_LOCATION = "schemaLocation";
/** Constant for the XML schema attribute "type". */
public static final String XSD_ATTRIBUTE_TYPE = "type";
/** Constant for the XML schema attribute "use". */
public static final String XSD_ATTRIBUTE_USE = "use";
/** Constant for the XML schema attribute value "language". */
public static final String XSD_ATTRIBUTE_VALUE_LANGUAGE = "language";
/** Constant for the XML schema attribute value "1". */
public static final String XSD_ATTRIBUTE_VALUE_ONE = "1";
/** Constant for the XML schema attribute value "optional". */
public static final String XSD_ATTRIBUTE_VALUE_OPTIONAL = "optional";
/** Constant for the XML schema attribute value "qualified". */
public static final String XSD_ATTRIBUTE_VALUE_QUALIFIED = "qualified";
/** Constant for the XML schema attribute value "required". */
public static final String XSD_ATTRIBUTE_VALUE_REQUIRED = "required";
/** Constant for the XML schema attribute value "unbounded". */
public static final String XSD_ATTRIBUTE_VALUE_UNBOUNDED = "unbounded";
/** Constant for the XML schema attribute value "0". */
public static final String XSD_ATTRIBUTE_VALUE_ZERO = "0";
/** The opencms default type definition include. */
public static final String XSD_INCLUDE_OPENCMS = CmsXmlEntityResolver.OPENCMS_SCHEME + "opencms-xmlcontent.xsd";
/** The schema definition namespace. */
public static final Namespace XSD_NAMESPACE = Namespace.get("xsd", "http://www.w3.org/2001/XMLSchema");
/** Constant for the "annotation" node in the XML schema namespace. */
public static final QName XSD_NODE_ANNOTATION = QName.get("annotation", XSD_NAMESPACE);
/** Constant for the "appinfo" node in the XML schema namespace. */
public static final QName XSD_NODE_APPINFO = QName.get("appinfo", XSD_NAMESPACE);
/** Constant for the "attribute" node in the XML schema namespace. */
public static final QName XSD_NODE_ATTRIBUTE = QName.get("attribute", XSD_NAMESPACE);
/** Constant for the "choice" node in the XML schema namespace. */
public static final QName XSD_NODE_CHOICE = QName.get("choice", XSD_NAMESPACE);
/** Constant for the "complexType" node in the XML schema namespace. */
public static final QName XSD_NODE_COMPLEXTYPE = QName.get("complexType", XSD_NAMESPACE);
/** Constant for the "element" node in the XML schema namespace. */
public static final QName XSD_NODE_ELEMENT = QName.get("element", XSD_NAMESPACE);
/** Constant for the "include" node in the XML schema namespace. */
public static final QName XSD_NODE_INCLUDE = QName.get("include", XSD_NAMESPACE);
/** Constant for the "schema" node in the XML schema namespace. */
public static final QName XSD_NODE_SCHEMA = QName.get("schema", XSD_NAMESPACE);
/** Constant for the "sequence" node in the XML schema namespace. */
public static final QName XSD_NODE_SEQUENCE = QName.get("sequence", XSD_NAMESPACE);
/** The log object for this class. */
private static final Log LOG = CmsLog.getLog(CmsXmlContentDefinition.class);
/** Null schema type value, required for map lookups. */
private static final I_CmsXmlSchemaType NULL_SCHEMA_TYPE = new CmsXmlStringValue("NULL", "0", "0");
/** Max occurs value for xsd:choice definitions. */
private int m_choiceMaxOccurs;
/** The XML content handler. */
private I_CmsXmlContentHandler m_contentHandler;
/** The Map of configured types indexed by the element xpath. */
private Map<String, I_CmsXmlSchemaType> m_elementTypes;
/** The set of included additional XML content definitions. */
private Set<CmsXmlContentDefinition> m_includes;
/** The inner element name of the content definition (type sequence). */
private String m_innerName;
/** The outer element name of the content definition (language sequence). */
private String m_outerName;
/** The XML document from which the schema was unmarshalled. */
private Document m_schemaDocument;
/** The location from which the XML schema was read (XML system id). */
private String m_schemaLocation;
/** Indicates the sequence type of this content definition. */
private SequenceType m_sequenceType;
/** The main type name of this XML content definition. */
private String m_typeName;
/** The Map of configured types. */
private Map<String, I_CmsXmlSchemaType> m_types;
/** The type sequence. */
private List<I_CmsXmlSchemaType> m_typeSequence;
/**
* Creates a new XML content definition.<p>
*
* @param innerName the inner element name to use for the content definiton
* @param schemaLocation the location from which the XML schema was read (system id)
*/
public CmsXmlContentDefinition(String innerName, String schemaLocation) {
this(innerName + "s", innerName, schemaLocation);
}
/**
* Creates a new XML content definition.<p>
*
* @param outerName the outer element name to use for the content definition
* @param innerName the inner element name to use for the content definition
* @param schemaLocation the location from which the XML schema was read (system id)
*/
public CmsXmlContentDefinition(String outerName, String innerName, String schemaLocation) {
m_outerName = outerName;
m_innerName = innerName;
setInnerName(innerName);
m_typeSequence = new ArrayList<I_CmsXmlSchemaType>();
m_types = new HashMap<String, I_CmsXmlSchemaType>();
m_includes = new HashSet<CmsXmlContentDefinition>();
m_schemaLocation = schemaLocation;
m_contentHandler = new CmsDefaultXmlContentHandler();
m_sequenceType = SequenceType.SEQUENCE;
m_elementTypes = new HashMap<String, I_CmsXmlSchemaType>();
}
/**
* Required empty constructor for clone operation.<p>
*/
protected CmsXmlContentDefinition() {
// noop, required for clone operation
}
/**
* Factory method that returns the XML content definition instance for a given resource.<p>
*
* @param cms the cms-object
* @param resource the resource
*
* @return the XML content definition
*
* @throws CmsException if something goes wrong
*/
public static CmsXmlContentDefinition getContentDefinitionForResource(CmsObject cms, CmsResource resource)
throws CmsException {
CmsXmlContentDefinition contentDef = null;
I_CmsResourceType resType = OpenCms.getResourceManager().getResourceType(resource.getTypeId());
String schema = resType.getConfiguration().get(CmsResourceTypeXmlContent.CONFIGURATION_SCHEMA);
if (!schema.equals("null")) {
try {
// this wont in most cases read the file content because of caching
contentDef = unmarshal(cms, schema);
} catch (CmsException e) {
// this should never happen, unless the configured schema is different than the schema in the XML
if (!LOG.isDebugEnabled()) {
LOG.warn(e);
}
LOG.debug(e.getLocalizedMessage(), e);
}
}
if (contentDef == null) {
// could still be empty since it is not mandatory to configure the resource type in the XML configuration
// try through the XSD relation
List<CmsRelation> relations = cms.getRelationsForResource(
resource,
CmsRelationFilter.TARGETS.filterType(CmsRelationType.XSD));
if ((relations != null) && !relations.isEmpty()) {
CmsXmlEntityResolver entityResolver = new CmsXmlEntityResolver(cms);
String xsd = cms.getSitePath(relations.get(0).getTarget(cms, CmsResourceFilter.ALL));
contentDef = entityResolver.getCachedContentDefinition(xsd);
}
}
if (contentDef == null) {
// could still be empty if the XML content has been saved with an OpenCms before 8.0.0
// so, to unmarshal is the only possibility left
CmsXmlContent content = CmsXmlContentFactory.unmarshal(cms, cms.readFile(resource));
contentDef = content.getContentDefinition();
}
return contentDef;
}
/**
* Reads the content definition which is configured for a resource type.<p>
*
* @param cms the current CMS context
* @param typeName the type name
*
* @return the content definition
*
* @throws CmsException if something goes wrong
*/
public static CmsXmlContentDefinition getContentDefinitionForType(CmsObject cms, String typeName)
throws CmsException {
I_CmsResourceType resType = OpenCms.getResourceManager().getResourceType(typeName);
String schema = resType.getConfiguration().get(CmsResourceTypeXmlContent.CONFIGURATION_SCHEMA);
CmsXmlContentDefinition contentDef = null;
if (schema == null) {
return null;
}
contentDef = unmarshal(cms, schema);
return contentDef;
}
/**
* Returns a content handler instance for the given resource.<p>
*
* @param cms the cms-object
* @param resource the resource
*
* @return the content handler
*
* @throws CmsException if something goes wrong
*/
public static I_CmsXmlContentHandler getContentHandlerForResource(CmsObject cms, CmsResource resource)
throws CmsException {
return getContentDefinitionForResource(cms, resource).getContentHandler();
}
/**
* Factory method to unmarshal (read) a XML content definition instance from a byte array
* that contains XML data.<p>
*
* @param xmlData the XML data in a byte array
* @param schemaLocation the location from which the XML schema was read (system id)
* @param resolver the XML entity resolver to use
*
* @return a XML content definition instance unmarshalled from the byte array
*
* @throws CmsXmlException if something goes wrong
*/
public static CmsXmlContentDefinition unmarshal(byte[] xmlData, String schemaLocation, EntityResolver resolver)
throws CmsXmlException {
schemaLocation = translateSchema(schemaLocation);
CmsXmlContentDefinition result = getCachedContentDefinition(schemaLocation, resolver);
if (result == null) {
// content definition was not found in the cache, unmarshal the XML document
result = unmarshalInternal(CmsXmlUtils.unmarshalHelper(xmlData, resolver), schemaLocation, resolver);
}
return result;
}
/**
* Factory method to unmarshal (read) a XML content definition instance from the OpenCms VFS resource name.<p>
*
* @param cms the current users CmsObject
* @param resourcename the resource name to unmarshal the XML content definition from
*
* @return a XML content definition instance unmarshalled from the VFS resource
*
* @throws CmsXmlException if something goes wrong
*/
public static CmsXmlContentDefinition unmarshal(CmsObject cms, String resourcename) throws CmsXmlException {
CmsXmlEntityResolver resolver = new CmsXmlEntityResolver(cms);
String schemaLocation = CmsXmlEntityResolver.OPENCMS_SCHEME.concat(resourcename.substring(1));
schemaLocation = translateSchema(schemaLocation);
CmsXmlContentDefinition result = getCachedContentDefinition(schemaLocation, resolver);
if (result == null) {
// content definition was not found in the cache, unmarshal the XML document
InputSource source = resolver.resolveEntity(null, schemaLocation);
result = unmarshalInternal(CmsXmlUtils.unmarshalHelper(source, resolver), schemaLocation, resolver);
}
return result;
}
/**
* Factory method to unmarshal (read) a XML content definition instance from a XML document.<p>
*
* This method does additional validation to ensure the document has the required
* XML structure for a OpenCms content definition schema.<p>
*
* @param document the XML document to generate a XML content definition from
* @param schemaLocation the location from which the XML schema was read (system id)
*
* @return a XML content definition instance unmarshalled from the XML document
*
* @throws CmsXmlException if something goes wrong
*/
public static CmsXmlContentDefinition unmarshal(Document document, String schemaLocation) throws CmsXmlException {
schemaLocation = translateSchema(schemaLocation);
EntityResolver resolver = document.getEntityResolver();
CmsXmlContentDefinition result = getCachedContentDefinition(schemaLocation, resolver);
if (result == null) {
// content definition was not found in the cache, unmarshal the XML document
result = unmarshalInternal(document, schemaLocation, resolver);
}
return result;
}
/**
* Factory method to unmarshal (read) a XML content definition instance from a XML InputSource.<p>
*
* @param source the XML InputSource to use
* @param schemaLocation the location from which the XML schema was read (system id)
* @param resolver the XML entity resolver to use
*
* @return a XML content definition instance unmarshalled from the InputSource
*
* @throws CmsXmlException if something goes wrong
*/
public static CmsXmlContentDefinition unmarshal(InputSource source, String schemaLocation, EntityResolver resolver)
throws CmsXmlException {
schemaLocation = translateSchema(schemaLocation);
CmsXmlContentDefinition result = getCachedContentDefinition(schemaLocation, resolver);
if (result == null) {
// content definition was not found in the cache, unmarshal the XML document
result = unmarshalInternal(CmsXmlUtils.unmarshalHelper(source, resolver), schemaLocation, resolver);
}
return result;
}
/**
* Factory method to unmarshal (read) a XML content definition instance from a given XML schema location.<p>
*
* The XML content definition data to unmarshal will be read from the provided schema location using
* an XML InputSource.<p>
*
* @param schemaLocation the location from which to read the XML schema (system id)
* @param resolver the XML entity resolver to use
*
* @return a XML content definition instance unmarshalled from the InputSource
*
* @throws CmsXmlException if something goes wrong
* @throws SAXException if the XML schema location could not be converted to an XML InputSource
* @throws IOException if the XML schema location could not be converted to an XML InputSource
*/
public static CmsXmlContentDefinition unmarshal(String schemaLocation, EntityResolver resolver)
throws CmsXmlException, SAXException, IOException {
schemaLocation = translateSchema(schemaLocation);
CmsXmlContentDefinition result = getCachedContentDefinition(schemaLocation, resolver);
if (result == null) {
// content definition was not found in the cache, unmarshal the XML document
InputSource source = resolver.resolveEntity(null, schemaLocation);
result = unmarshalInternal(CmsXmlUtils.unmarshalHelper(source, resolver), schemaLocation, resolver);
}
return result;
}
/**
* Factory method to unmarshal (read) a XML content definition instance from a String
* that contains XML data.<p>
*
* @param xmlData the XML data in a String
* @param schemaLocation the location from which the XML schema was read (system id)
* @param resolver the XML entity resolver to use
*
* @return a XML content definition instance unmarshalled from the byte array
*
* @throws CmsXmlException if something goes wrong
*/
public static CmsXmlContentDefinition unmarshal(String xmlData, String schemaLocation, EntityResolver resolver)
throws CmsXmlException {
schemaLocation = translateSchema(schemaLocation);
CmsXmlContentDefinition result = getCachedContentDefinition(schemaLocation, resolver);
if (result == null) {
// content definition was not found in the cache, unmarshal the XML document
result = unmarshalInternal(CmsXmlUtils.unmarshalHelper(xmlData, resolver), schemaLocation, resolver);
}
return result;
}
/**
* Creates the name of the type attribute from the given content name.<p>
*
* @param name the name to use
*
* @return the name of the type attribute
*/
protected static String createTypeName(String name) {
StringBuffer result = new StringBuffer(32);
result.append("OpenCms");
result.append(name.substring(0, 1).toUpperCase());
if (name.length() > 1) {
result.append(name.substring(1));
}
return result.toString();
}
/**
* Validates if a given attribute exists at the given element with an (optional) specified value.<p>
*
* If the required value is not <code>null</code>, the attribute must have exactly this
* value set.<p>
*
* If no value is required, some simple validation is performed on the attribute value,
* like a check that the value does not have leading or trailing white spaces.<p>
*
* @param element the element to validate
* @param attributeName the attribute to check for
* @param requiredValue the required value of the attribute, or <code>null</code> if any value is allowed
*
* @return the value of the attribute
*
* @throws CmsXmlException if the element does not have the required attribute set, or if the validation fails
*/
protected static String validateAttribute(Element element, String attributeName, String requiredValue)
throws CmsXmlException {
Attribute attribute = element.attribute(attributeName);
if (attribute == null) {
throw new CmsXmlException(Messages.get().container(
Messages.ERR_EL_MISSING_ATTRIBUTE_2,
element.getUniquePath(),
attributeName));
}
String value = attribute.getValue();
if (requiredValue == null) {
if (CmsStringUtil.isEmptyOrWhitespaceOnly(value) || !value.equals(value.trim())) {
throw new CmsXmlException(Messages.get().container(
Messages.ERR_EL_BAD_ATTRIBUTE_WS_3,
element.getUniquePath(),
attributeName,
value));
}
} else {
if (!requiredValue.equals(value)) {
throw new CmsXmlException(Messages.get().container(
Messages.ERR_EL_BAD_ATTRIBUTE_VALUE_4,
new Object[] {element.getUniquePath(), attributeName, requiredValue, value}));
}
}
return value;
}
/**
* Validates if a given element has exactly the required attributes set.<p>
*
* @param element the element to validate
* @param requiredAttributes the list of required attributes
* @param optionalAttributes the list of optional attributes
*
* @throws CmsXmlException if the validation fails
*/
protected static void validateAttributesExists(
Element element,
String[] requiredAttributes,
String[] optionalAttributes) throws CmsXmlException {
if (element.attributeCount() < requiredAttributes.length) {
throw new CmsXmlException(Messages.get().container(
Messages.ERR_EL_ATTRIBUTE_TOOFEW_3,
element.getUniquePath(),
new Integer(requiredAttributes.length),
new Integer(element.attributeCount())));
}
if (element.attributeCount() > (requiredAttributes.length + optionalAttributes.length)) {
throw new CmsXmlException(Messages.get().container(
Messages.ERR_EL_ATTRIBUTE_TOOMANY_3,
element.getUniquePath(),
new Integer(requiredAttributes.length + optionalAttributes.length),
new Integer(element.attributeCount())));
}
for (int i = 0; i < requiredAttributes.length; i++) {
String attributeName = requiredAttributes[i];
if (element.attribute(attributeName) == null) {
throw new CmsXmlException(Messages.get().container(
Messages.ERR_EL_MISSING_ATTRIBUTE_2,
element.getUniquePath(),
attributeName));
}
}
List<String> rA = Arrays.asList(requiredAttributes);
List<String> oA = Arrays.asList(optionalAttributes);
for (int i = 0; i < element.attributes().size(); i++) {
String attributeName = element.attribute(i).getName();
if (!rA.contains(attributeName) && !oA.contains(attributeName)) {
throw new CmsXmlException(Messages.get().container(
Messages.ERR_EL_INVALID_ATTRIBUTE_2,
element.getUniquePath(),
attributeName));
}
}
}
/**
* Validates the given element as a complex type sequence.<p>
*
* @param element the element to validate
* @param includes the XML schema includes
*
* @return a data structure containing the validated complex type sequence data
*
* @throws CmsXmlException if the validation fails
*/
protected static CmsXmlComplexTypeSequence validateComplexTypeSequence(
Element element,
Set<CmsXmlContentDefinition> includes) throws CmsXmlException {
validateAttributesExists(element, new String[] {XSD_ATTRIBUTE_NAME}, new String[0]);
String name = validateAttribute(element, XSD_ATTRIBUTE_NAME, null);
// now check the type definition list
List<Element> mainElements = CmsXmlGenericWrapper.elements(element);
if ((mainElements.size() != 1) && (mainElements.size() != 2)) {
throw new CmsXmlException(Messages.get().container(
Messages.ERR_TS_SUBELEMENT_COUNT_2,
element.getUniquePath(),
new Integer(mainElements.size())));
}
boolean hasLanguageAttribute = false;
if (mainElements.size() == 2) {
// two elements in the master list: the second must be the "language" attribute definition
Element typeAttribute = mainElements.get(1);
if (!XSD_NODE_ATTRIBUTE.equals(typeAttribute.getQName())) {
throw new CmsXmlException(Messages.get().container(
Messages.ERR_CD_ELEMENT_NAME_3,
typeAttribute.getUniquePath(),
XSD_NODE_ATTRIBUTE.getQualifiedName(),
typeAttribute.getQName().getQualifiedName()));
}
validateAttribute(typeAttribute, XSD_ATTRIBUTE_NAME, XSD_ATTRIBUTE_VALUE_LANGUAGE);
validateAttribute(typeAttribute, XSD_ATTRIBUTE_TYPE, CmsXmlLocaleValue.TYPE_NAME);
try {
validateAttribute(typeAttribute, XSD_ATTRIBUTE_USE, XSD_ATTRIBUTE_VALUE_REQUIRED);
} catch (CmsXmlException e) {
validateAttribute(typeAttribute, XSD_ATTRIBUTE_USE, XSD_ATTRIBUTE_VALUE_OPTIONAL);
}
// no error: then the language attribute is valid
hasLanguageAttribute = true;
}
// the type of the sequence
SequenceType sequenceType;
int choiceMaxOccurs = 0;
// check the main element type sequence
Element typeSequenceElement = mainElements.get(0);
if (!XSD_NODE_SEQUENCE.equals(typeSequenceElement.getQName())) {
if (!XSD_NODE_CHOICE.equals(typeSequenceElement.getQName())) {
throw new CmsXmlException(Messages.get().container(
Messages.ERR_CD_ELEMENT_NAME_4,
new Object[] {
typeSequenceElement.getUniquePath(),
XSD_NODE_SEQUENCE.getQualifiedName(),
XSD_NODE_CHOICE.getQualifiedName(),
typeSequenceElement.getQName().getQualifiedName()}));
} else {
// this is a xsd:choice, check if this is single or multiple choice
String minOccursStr = typeSequenceElement.attributeValue(XSD_ATTRIBUTE_MIN_OCCURS);
int minOccurs = 1;
if (CmsStringUtil.isNotEmptyOrWhitespaceOnly(minOccursStr)) {
try {
minOccurs = Integer.parseInt(minOccursStr.trim());
} catch (NumberFormatException e) {
throw new CmsXmlException(Messages.get().container(
Messages.ERR_EL_BAD_ATTRIBUTE_3,
element.getUniquePath(),
XSD_ATTRIBUTE_MIN_OCCURS,
minOccursStr == null ? "1" : minOccursStr));
}
}
String maxOccursStr = typeSequenceElement.attributeValue(XSD_ATTRIBUTE_MAX_OCCURS);
choiceMaxOccurs = 1;
if (CmsStringUtil.isNotEmptyOrWhitespaceOnly(maxOccursStr)) {
if (CmsXmlContentDefinition.XSD_ATTRIBUTE_VALUE_UNBOUNDED.equals(maxOccursStr.trim())) {
choiceMaxOccurs = Integer.MAX_VALUE;
} else {
try {
choiceMaxOccurs = Integer.parseInt(maxOccursStr.trim());
} catch (NumberFormatException e) {
throw new CmsXmlException(Messages.get().container(
Messages.ERR_EL_BAD_ATTRIBUTE_3,
element.getUniquePath(),
XSD_ATTRIBUTE_MAX_OCCURS,
maxOccursStr));
}
}
}
if ((minOccurs == 0) && (choiceMaxOccurs == 1)) {
// minOccurs 0 and maxOccurs 1, this is a single choice sequence
sequenceType = SequenceType.SINGLE_CHOICE;
} else {
// this is a multiple choice sequence
if (minOccurs > choiceMaxOccurs) {
throw new CmsXmlException(Messages.get().container(
Messages.ERR_EL_BAD_ATTRIBUTE_3,
element.getUniquePath(),
XSD_ATTRIBUTE_MIN_OCCURS,
minOccursStr == null ? "1" : minOccursStr));
}
sequenceType = SequenceType.MULTIPLE_CHOICE;
}
}
} else {
// this is a simple sequence
sequenceType = SequenceType.SEQUENCE;
}
// check the type definition sequence
List<Element> typeSequenceElements = CmsXmlGenericWrapper.elements(typeSequenceElement);
if (typeSequenceElements.size() < 1) {
throw new CmsXmlException(Messages.get().container(
Messages.ERR_TS_SUBELEMENT_TOOFEW_3,
typeSequenceElement.getUniquePath(),
new Integer(1),
new Integer(typeSequenceElements.size())));
}
// now add all type definitions from the schema
List<I_CmsXmlSchemaType> sequence = new ArrayList<I_CmsXmlSchemaType>();
if (hasLanguageAttribute) {
// only generate types for sequence node with language attribute
CmsXmlContentTypeManager typeManager = OpenCms.getXmlContentTypeManager();
Iterator<Element> i = typeSequenceElements.iterator();
while (i.hasNext()) {
Element typeElement = i.next();
if (sequenceType != SequenceType.SEQUENCE) {
// in case of xsd:choice, need to make sure "minOccurs" for all type elements is 0
String minOccursStr = typeElement.attributeValue(XSD_ATTRIBUTE_MIN_OCCURS);
int minOccurs = 1;
if (CmsStringUtil.isNotEmptyOrWhitespaceOnly(minOccursStr)) {
try {
minOccurs = Integer.parseInt(minOccursStr.trim());
} catch (NumberFormatException e) {
// ignore
}
}
// minOccurs must be "0"
if (minOccurs != 0) {
throw new CmsXmlException(Messages.get().container(
Messages.ERR_EL_BAD_ATTRIBUTE_3,
typeElement.getUniquePath(),
XSD_ATTRIBUTE_MIN_OCCURS,
minOccursStr == null ? "1" : minOccursStr));
}
}
// create the type with the type manager
I_CmsXmlSchemaType type = typeManager.getContentType(typeElement, includes);
if (sequenceType == SequenceType.MULTIPLE_CHOICE) {
// if this is a multiple choice sequence,
// all elements must have "minOccurs" 0 or 1 and "maxOccurs" of 1
if ((type.getMinOccurs() < 0) || (type.getMinOccurs() > 1) || (type.getMaxOccurs() != 1)) {
throw new CmsXmlException(Messages.get().container(
Messages.ERR_EL_BAD_ATTRIBUTE_3,
typeElement.getUniquePath(),
XSD_ATTRIBUTE_MAX_OCCURS,
typeElement.attributeValue(XSD_ATTRIBUTE_MAX_OCCURS)));
}
}
sequence.add(type);
}
} else {
// generate a nested content definition for the main type sequence
Element e = typeSequenceElements.get(0);
String typeName = validateAttribute(e, XSD_ATTRIBUTE_NAME, null);
String minOccurs = validateAttribute(e, XSD_ATTRIBUTE_MIN_OCCURS, XSD_ATTRIBUTE_VALUE_ZERO);
String maxOccurs = validateAttribute(e, XSD_ATTRIBUTE_MAX_OCCURS, XSD_ATTRIBUTE_VALUE_UNBOUNDED);
validateAttribute(e, XSD_ATTRIBUTE_TYPE, createTypeName(typeName));
CmsXmlNestedContentDefinition cd = new CmsXmlNestedContentDefinition(null, typeName, minOccurs, maxOccurs);
sequence.add(cd);
}
// return a data structure with the collected values
return new CmsXmlComplexTypeSequence(name, sequence, hasLanguageAttribute, sequenceType, choiceMaxOccurs);
}
/**
* Looks up the given XML content definition system id in the internal content definition cache.<p>
*
* @param schemaLocation the system id of the XML content definition to look up
* @param resolver the XML entity resolver to use (contains the cache)
*
* @return the XML content definition found, or null if no definition is cached for the given system id
*/
private static CmsXmlContentDefinition getCachedContentDefinition(String schemaLocation, EntityResolver resolver) {
if (resolver instanceof CmsXmlEntityResolver) {
// check for a cached version of this content definition
CmsXmlEntityResolver cmsResolver = (CmsXmlEntityResolver)resolver;
return cmsResolver.getCachedContentDefinition(schemaLocation);
}
return null;
}
/**
* Translates the XSD schema location.<p>
*
* @param schemaLocation the location to translate
*
* @return the translated schema location
*/
private static String translateSchema(String schemaLocation) {
if (OpenCms.getRepositoryManager() != null) {
return OpenCms.getResourceManager().getXsdTranslator().translateResource(schemaLocation);
}
return schemaLocation;
}
/**
* Internal method to unmarshal (read) a XML content definition instance from a XML document.<p>
*
* It is assumed that the XML content definition cache has already been tested and the document
* has not been found in the cache. After the XML content definition has been successfully created,
* it is placed in the cache.<p>
*
* @param document the XML document to generate a XML content definition from
* @param schemaLocation the location from which the XML schema was read (system id)
* @param resolver the XML entity resolver used by the given XML document
*
* @return a XML content definition instance unmarshalled from the XML document
*
* @throws CmsXmlException if something goes wrong
*/
private static CmsXmlContentDefinition unmarshalInternal(
Document document,
String schemaLocation,
EntityResolver resolver) throws CmsXmlException {
// analyze the document and generate the XML content type definition
Element root = document.getRootElement();
if (!XSD_NODE_SCHEMA.equals(root.getQName())) {
// schema node is required
throw new CmsXmlException(Messages.get().container(Messages.ERR_CD_NO_SCHEMA_NODE_0));
}
List<Element> includes = CmsXmlGenericWrapper.elements(root, XSD_NODE_INCLUDE);
if (includes.size() < 1) {
// one include is required
throw new CmsXmlException(Messages.get().container(Messages.ERR_CD_ONE_INCLUDE_REQUIRED_0));
}
Element include = includes.get(0);
String target = validateAttribute(include, XSD_ATTRIBUTE_SCHEMA_LOCATION, null);
if (!XSD_INCLUDE_OPENCMS.equals(target)) {
// the first include must point to the default OpenCms standard schema include
throw new CmsXmlException(Messages.get().container(
Messages.ERR_CD_FIRST_INCLUDE_2,
XSD_INCLUDE_OPENCMS,
target));
}
boolean recursive = false;
Set<CmsXmlContentDefinition> nestedDefinitions = new HashSet<CmsXmlContentDefinition>();
if (includes.size() > 1) {
// resolve additional, nested include calls
for (int i = 1; i < includes.size(); i++) {
Element inc = includes.get(i);
String schemaLoc = validateAttribute(inc, XSD_ATTRIBUTE_SCHEMA_LOCATION, null);
if (!(schemaLoc.equals(schemaLocation))) {
InputSource source = null;
try {
source = resolver.resolveEntity(null, schemaLoc);
} catch (Exception e) {
throw new CmsXmlException(Messages.get().container(Messages.ERR_CD_BAD_INCLUDE_1, schemaLoc));
}
CmsXmlContentDefinition xmlContentDefinition = unmarshal(source, schemaLoc, resolver);
nestedDefinitions.add(xmlContentDefinition);
} else {
// recursion
recursive = true;
}
}
}
List<Element> elements = CmsXmlGenericWrapper.elements(root, XSD_NODE_ELEMENT);
if (elements.size() != 1) {
// only one root element is allowed
throw new CmsXmlException(Messages.get().container(
Messages.ERR_CD_ROOT_ELEMENT_COUNT_1,
XSD_INCLUDE_OPENCMS,
new Integer(elements.size())));
}
// collect the data from the root element node
Element main = elements.get(0);
String name = validateAttribute(main, XSD_ATTRIBUTE_NAME, null);
// now process the complex types
List<Element> complexTypes = CmsXmlGenericWrapper.elements(root, XSD_NODE_COMPLEXTYPE);
if (complexTypes.size() != 2) {
// exactly two complex types are required
throw new CmsXmlException(Messages.get().container(
Messages.ERR_CD_COMPLEX_TYPE_COUNT_1,
new Integer(complexTypes.size())));
}
// get the outer element sequence, this must be the first element
CmsXmlComplexTypeSequence outerSequence = validateComplexTypeSequence(complexTypes.get(0), nestedDefinitions);
CmsXmlNestedContentDefinition outer = (CmsXmlNestedContentDefinition)outerSequence.getSequence().get(0);
// make sure the inner and outer element names are as required
String outerTypeName = createTypeName(name);
String innerTypeName = createTypeName(outer.getName());
validateAttribute(complexTypes.get(0), XSD_ATTRIBUTE_NAME, outerTypeName);
validateAttribute(complexTypes.get(1), XSD_ATTRIBUTE_NAME, innerTypeName);
validateAttribute(main, XSD_ATTRIBUTE_TYPE, outerTypeName);
// generate the result XML content definition
CmsXmlContentDefinition result = new CmsXmlContentDefinition(name, null, schemaLocation);
// set the nested definitions
result.m_includes = nestedDefinitions;
// set the schema document
result.m_schemaDocument = document;
// the inner name is the element name set in the outer sequence
result.setInnerName(outer.getName());
if (recursive) {
nestedDefinitions.add(result);
}
// get the inner element sequence, this must be the second element
CmsXmlComplexTypeSequence innerSequence = validateComplexTypeSequence(complexTypes.get(1), nestedDefinitions);
// add the types from the main sequence node
Iterator<I_CmsXmlSchemaType> it = innerSequence.getSequence().iterator();
while (it.hasNext()) {
result.addType(it.next());
}
// store if this content definition contains a xsd:choice sequence
result.m_sequenceType = innerSequence.getSequenceType();
result.m_choiceMaxOccurs = innerSequence.getChoiceMaxOccurs();
// resolve the XML content handler information
List<Element> annotations = CmsXmlGenericWrapper.elements(root, XSD_NODE_ANNOTATION);
I_CmsXmlContentHandler contentHandler = null;
Element appInfoElement = null;
if (annotations.size() > 0) {
List<Element> appinfos = CmsXmlGenericWrapper.elements(annotations.get(0), XSD_NODE_APPINFO);
if (appinfos.size() > 0) {
// the first appinfo node contains the specific XML content data
appInfoElement = appinfos.get(0);
// check for a special content handler in the appinfo node
Element handlerElement = appInfoElement.element("handler");
if (handlerElement != null) {
String className = handlerElement.attributeValue("class");
if (className != null) {
contentHandler = OpenCms.getXmlContentTypeManager().getFreshContentHandler(className);
}
}
}
}
if (contentHandler == null) {
// if no content handler is defined, the default handler is used
contentHandler = OpenCms.getXmlContentTypeManager().getFreshContentHandler(
CmsDefaultXmlContentHandler.class.getName());
}
// analyze the app info node with the selected XML content handler
contentHandler.initialize(appInfoElement, result);
result.m_contentHandler = contentHandler;
result.freeze();
if (resolver instanceof CmsXmlEntityResolver) {
// put the generated content definition in the cache
((CmsXmlEntityResolver)resolver).cacheContentDefinition(schemaLocation, result);
}
return result;
}
/**
* Adds the missing default XML according to this content definition to the given document element.<p>
*
* In case the root element already contains sub nodes, only missing sub nodes are added.<p>
*
* @param cms the current users OpenCms context
* @param document the document where the XML is added in (required for default XML generation)
* @param root the root node to add the missing XML for
* @param locale the locale to add the XML for
*
* @return the given root element with the missing content added
*/
public Element addDefaultXml(CmsObject cms, I_CmsXmlDocument document, Element root, Locale locale) {
Iterator<I_CmsXmlSchemaType> i = m_typeSequence.iterator();
int currentPos = 0;
List<Element> allElements = CmsXmlGenericWrapper.elements(root);
while (i.hasNext()) {
I_CmsXmlSchemaType type = i.next();
// check how many elements of this type already exist in the XML
String elementName = type.getName();
List<Element> elements = CmsXmlGenericWrapper.elements(root, elementName);
currentPos += elements.size();
for (int j = elements.size(); j < type.getMinOccurs(); j++) {
// append the missing elements
Element typeElement = type.generateXml(cms, document, root, locale);
// need to check for default value again because the of appinfo "mappings" node
I_CmsXmlContentValue value = type.createValue(document, typeElement, locale);
String defaultValue = document.getHandler().getDefault(cms, value, locale);
if (defaultValue != null) {
// only if there is a default value available use it to overwrite the initial default
value.setStringValue(cms, defaultValue);
}
// re-sort elements as they have been appended to the end of the XML root, not at the correct position
typeElement.detach();
allElements.add(currentPos, typeElement);
currentPos++;
}
}
return root;
}
/**
* Adds a nested (included) XML content definition.<p>
*
* @param nestedSchema the nested (included) XML content definition to add
*/
public void addInclude(CmsXmlContentDefinition nestedSchema) {
m_includes.add(nestedSchema);
}
/**
* Adds the given content type.<p>
*
* @param type the content type to add
*
* @throws CmsXmlException in case an unregistered type is added
*/
public void addType(I_CmsXmlSchemaType type) throws CmsXmlException {
// check if the type to add actually exists in the type manager
CmsXmlContentTypeManager typeManager = OpenCms.getXmlContentTypeManager();
if (type.isSimpleType() && (typeManager.getContentType(type.getTypeName()) == null)) {
throw new CmsXmlException(Messages.get().container(Messages.ERR_UNREGISTERED_TYPE_1, type.getTypeName()));
}
// add the type to the internal type sequence and lookup table
m_typeSequence.add(type);
m_types.put(type.getName(), type);
// store reference to the content definition in the type
type.setContentDefinition(this);
}
/**
* Creates a clone of this XML content definition.<p>
*
* @return a clone of this XML content definition
*/
@Override
public Object clone() {
CmsXmlContentDefinition result = new CmsXmlContentDefinition();
result.m_innerName = m_innerName;
result.m_schemaLocation = m_schemaLocation;
result.m_typeSequence = m_typeSequence;
result.m_types = m_types;
result.m_contentHandler = m_contentHandler;
result.m_typeName = m_typeName;
result.m_includes = m_includes;
result.m_sequenceType = m_sequenceType;
result.m_choiceMaxOccurs = m_choiceMaxOccurs;
result.m_elementTypes = m_elementTypes;
return result;
}
/**
* Generates the default XML content for this content definition, and append it to the given root element.<p>
*
* Please note: The default values for the annotations are read from the content definition of the given
* document. For a nested content definitions, this means that all defaults are set in the annotations of the
* "outer" or "main" content definition.<p>
*
* @param cms the current users OpenCms context
* @param document the OpenCms XML document the XML is created for
* @param root the node of the document where to append the generated XML to
* @param locale the locale to create the default element in the document with
*
* @return the default XML content for this content definition, and append it to the given root element
*/
public Element createDefaultXml(CmsObject cms, I_CmsXmlDocument document, Element root, Locale locale) {
Iterator<I_CmsXmlSchemaType> i = m_typeSequence.iterator();
while (i.hasNext()) {
I_CmsXmlSchemaType type = i.next();
for (int j = 0; j < type.getMinOccurs(); j++) {
Element typeElement = type.generateXml(cms, document, root, locale);
// need to check for default value again because of the appinfo "mappings" node
I_CmsXmlContentValue value = type.createValue(document, typeElement, locale);
String defaultValue = document.getHandler().getDefault(cms, value, locale);
if (defaultValue != null) {
// only if there is a default value available use it to overwrite the initial default
value.setStringValue(cms, defaultValue);
}
}
}
return root;
}
/**
* Generates a valid XML document according to the XML schema of this content definition.<p>
*
* @param cms the current users OpenCms context
* @param document the OpenCms XML document the XML is created for
* @param locale the locale to create the default element in the document with
*
* @return a valid XML document according to the XML schema of this content definition
*/
public Document createDocument(CmsObject cms, I_CmsXmlDocument document, Locale locale) {
Document doc = DocumentHelper.createDocument();
Element root = doc.addElement(getOuterName());
root.add(I_CmsXmlSchemaType.XSI_NAMESPACE);
root.addAttribute(I_CmsXmlSchemaType.XSI_NAMESPACE_ATTRIBUTE_NO_SCHEMA_LOCATION, getSchemaLocation());
createLocale(cms, document, root, locale);
return doc;
}
/**
* Generates a valid locale (language) element for the XML schema of this content definition.<p>
*
* @param cms the current users OpenCms context
* @param document the OpenCms XML document the XML is created for
* @param root the root node of the document where to append the locale to
* @param locale the locale to create the default element in the document with
*
* @return a valid XML element for the locale according to the XML schema of this content definition
*/
public Element createLocale(CmsObject cms, I_CmsXmlDocument document, Element root, Locale locale) {
// add an element with a "locale" attribute to the given root node
Element element = root.addElement(getInnerName());
element.addAttribute(XSD_ATTRIBUTE_VALUE_LANGUAGE, locale.toString());
// now generate the default XML for the element
return createDefaultXml(cms, document, element, locale);
}
/**
* @see java.lang.Object#equals(java.lang.Object)
*/
@Override
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof CmsXmlContentDefinition)) {
return false;
}
CmsXmlContentDefinition other = (CmsXmlContentDefinition)obj;
if (!getInnerName().equals(other.getInnerName())) {
return false;
}
if (!getOuterName().equals(other.getOuterName())) {
return false;
}
return m_typeSequence.equals(other.m_typeSequence);
}
/**
* Freezes this content definition, making all internal data structures
* unmodifiable.<p>
*
* This is required to prevent modification of a cached content definition.<p>
*/
public void freeze() {
m_types = Collections.unmodifiableMap(m_types);
m_typeSequence = Collections.unmodifiableList(m_typeSequence);
}
/**
* Returns the maxOccurs value for the choice in case this is a <code>xsd:choice</code> content definition.<p>
*
* This content definition is a <code>xsd:choice</code> sequence if the returned value is larger then 0.<p>
*
* @return the maxOccurs value for the choice in case this is a <code>xsd:choice</code> content definition
*/
public int getChoiceMaxOccurs() {
return m_choiceMaxOccurs;
}
/**
* Returns the selected XML content handler for this XML content definition.<p>
*
* If no specific XML content handler was provided in the "appinfo" node of the
* XML schema, the default XML content handler <code>{@link CmsDefaultXmlContentHandler}</code> is used.<p>
*
* @return the contentHandler
*/
public I_CmsXmlContentHandler getContentHandler() {
return m_contentHandler;
}
/**
* Returns the set of nested (included) XML content definitions.<p>
*
* @return the set of nested (included) XML content definitions
*/
public Set<CmsXmlContentDefinition> getIncludes() {
return m_includes;
}
/**
* Returns the inner element name of this content definition.<p>
*
* @return the inner element name of this content definition
*/
public String getInnerName() {
return m_innerName;
}
/**
* Returns the outer element name of this content definition.<p>
*
* @return the outer element name of this content definition
*/
public String getOuterName() {
return m_outerName;
}
/**
* Generates an XML schema for the content definition.<p>
*
* @return the generated XML schema
*/
public Document getSchema() {
Document result;
if (m_schemaDocument == null) {
result = DocumentHelper.createDocument();
Element root = result.addElement(XSD_NODE_SCHEMA);
root.addAttribute(XSD_ATTRIBUTE_ELEMENT_FORM_DEFAULT, XSD_ATTRIBUTE_VALUE_QUALIFIED);
Element include = root.addElement(XSD_NODE_INCLUDE);
include.addAttribute(XSD_ATTRIBUTE_SCHEMA_LOCATION, XSD_INCLUDE_OPENCMS);
if (m_includes.size() > 0) {
Iterator<CmsXmlContentDefinition> i = m_includes.iterator();
while (i.hasNext()) {
CmsXmlContentDefinition definition = i.next();
root.addElement(XSD_NODE_INCLUDE).addAttribute(
XSD_ATTRIBUTE_SCHEMA_LOCATION,
definition.m_schemaLocation);
}
}
String outerTypeName = createTypeName(getOuterName());
String innerTypeName = createTypeName(getInnerName());
Element content = root.addElement(XSD_NODE_ELEMENT);
content.addAttribute(XSD_ATTRIBUTE_NAME, getOuterName());
content.addAttribute(XSD_ATTRIBUTE_TYPE, outerTypeName);
Element list = root.addElement(XSD_NODE_COMPLEXTYPE);
list.addAttribute(XSD_ATTRIBUTE_NAME, outerTypeName);
Element listSequence = list.addElement(XSD_NODE_SEQUENCE);
Element listElement = listSequence.addElement(XSD_NODE_ELEMENT);
listElement.addAttribute(XSD_ATTRIBUTE_NAME, getInnerName());
listElement.addAttribute(XSD_ATTRIBUTE_TYPE, innerTypeName);
listElement.addAttribute(XSD_ATTRIBUTE_MIN_OCCURS, XSD_ATTRIBUTE_VALUE_ZERO);
listElement.addAttribute(XSD_ATTRIBUTE_MAX_OCCURS, XSD_ATTRIBUTE_VALUE_UNBOUNDED);
Element main = root.addElement(XSD_NODE_COMPLEXTYPE);
main.addAttribute(XSD_ATTRIBUTE_NAME, innerTypeName);
Element mainSequence;
if (m_sequenceType == SequenceType.SEQUENCE) {
mainSequence = main.addElement(XSD_NODE_SEQUENCE);
} else {
mainSequence = main.addElement(XSD_NODE_CHOICE);
if (getChoiceMaxOccurs() > 1) {
mainSequence.addAttribute(XSD_ATTRIBUTE_MAX_OCCURS, String.valueOf(getChoiceMaxOccurs()));
} else {
mainSequence.addAttribute(XSD_ATTRIBUTE_MIN_OCCURS, XSD_ATTRIBUTE_VALUE_ZERO);
mainSequence.addAttribute(XSD_ATTRIBUTE_MAX_OCCURS, XSD_ATTRIBUTE_VALUE_ONE);
}
}
Iterator<I_CmsXmlSchemaType> i = m_typeSequence.iterator();
while (i.hasNext()) {
I_CmsXmlSchemaType schemaType = i.next();
schemaType.appendXmlSchema(mainSequence);
}
Element language = main.addElement(XSD_NODE_ATTRIBUTE);
language.addAttribute(XSD_ATTRIBUTE_NAME, XSD_ATTRIBUTE_VALUE_LANGUAGE);
language.addAttribute(XSD_ATTRIBUTE_TYPE, CmsXmlLocaleValue.TYPE_NAME);
language.addAttribute(XSD_ATTRIBUTE_USE, XSD_ATTRIBUTE_VALUE_OPTIONAL);
} else {
result = (Document)m_schemaDocument.clone();
}
return result;
}
/**
* Returns the location from which the XML schema was read (XML system id).<p>
*
* @return the location from which the XML schema was read (XML system id)
*/
public String getSchemaLocation() {
return m_schemaLocation;
}
/**
* Returns the schema type for the given element name, or <code>null</code> if no
* node is defined with this name.<p>
*
* @param elementPath the element xpath to look up the type for
* @return the type for the given element name, or <code>null</code> if no
* node is defined with this name
*/
public I_CmsXmlSchemaType getSchemaType(String elementPath) {
String path = CmsXmlUtils.removeXpath(elementPath);
I_CmsXmlSchemaType result = m_elementTypes.get(path);
if (result == null) {
result = getSchemaTypeRecusive(path);
if (result != null) {
m_elementTypes.put(path, result);
} else {
m_elementTypes.put(path, NULL_SCHEMA_TYPE);
}
} else if (result == NULL_SCHEMA_TYPE) {
result = null;
}
return result;
}
/**
* Returns the internal set of schema type names.<p>
*
* @return the internal set of schema type names
*/
public Set<String> getSchemaTypes() {
return m_types.keySet();
}
/**
* Returns the sequence type of this content definition.<p>
*
* @return the sequence type of this content definition
*/
public SequenceType getSequenceType() {
return m_sequenceType;
}
/**
* Returns the main type name of this XML content definition.<p>
*
* @return the main type name of this XML content definition
*/
public String getTypeName() {
return m_typeName;
}
/**
* Returns the type sequence, contains instances of {@link I_CmsXmlSchemaType}.<p>
*
* @return the type sequence, contains instances of {@link I_CmsXmlSchemaType}
*/
public List<I_CmsXmlSchemaType> getTypeSequence() {
return m_typeSequence;
}
/**
* @see java.lang.Object#hashCode()
*/
@Override
public int hashCode() {
return getInnerName().hashCode();
}
/**
* Sets the inner element name to use for the content definition.<p>
*
* @param innerName the inner element name to set
*/
protected void setInnerName(String innerName) {
m_innerName = innerName;
if (m_innerName != null) {
m_typeName = createTypeName(innerName);
}
}
/**
* Sets the outer element name to use for the content definition.<p>
*
* @param outerName the outer element name to set
*/
protected void setOuterName(String outerName) {
m_outerName = outerName;
}
/**
* Calculates the schema type for the given element name by recursing into the schema structure.<p>
*
* @param elementPath the element xpath to look up the type for
* @return the type for the given element name, or <code>null</code> if no
* node is defined with this name
*/
private I_CmsXmlSchemaType getSchemaTypeRecusive(String elementPath) {
String path = CmsXmlUtils.getFirstXpathElement(elementPath);
I_CmsXmlSchemaType type = m_types.get(path);
if (type == null) {
// no node with the given path defined in schema
return null;
}
// check if recursion is required to get value from a nested schema
if (type.isSimpleType() || !CmsXmlUtils.isDeepXpath(elementPath)) {
// no recursion required
return type;
}
// recursion required since the path is an xpath and the type must be a nested content definition
CmsXmlNestedContentDefinition nestedDefinition = (CmsXmlNestedContentDefinition)type;
path = CmsXmlUtils.removeFirstXpathElement(elementPath);
return nestedDefinition.getNestedContentDefinition().getSchemaType(path);
}
}