/*
* 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 org.apache.aries.blueprint.container;
import java.io.InputStream;
import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import javax.xml.XMLConstants;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.validation.Schema;
import javax.xml.validation.Validator;
import org.apache.aries.blueprint.ComponentDefinitionRegistry;
import org.apache.aries.blueprint.NamespaceHandler;
import org.apache.aries.blueprint.metadata.Builder;
import org.apache.aries.blueprint.metadata.MutableBeanMetadata;
import org.apache.aries.blueprint.metadata.MutableReferenceListMetadata;
import org.apache.aries.blueprint.metadata.MutableReferenceListener;
import org.apache.aries.blueprint.metadata.MutableReferenceMetadata;
import org.apache.aries.blueprint.metadata.MutableRegistrationListener;
import org.apache.aries.blueprint.metadata.MutableServiceMetadata;
import org.apache.aries.blueprint.metadata.MutableServiceReferenceMetadata;
import org.apache.aries.blueprint.metadata.impl.MetadataUtil;
import org.osgi.service.blueprint.container.ComponentDefinitionException;
import org.osgi.service.blueprint.reflect.BeanArgument;
import org.osgi.service.blueprint.reflect.BeanMetadata;
import org.osgi.service.blueprint.reflect.BeanProperty;
import org.osgi.service.blueprint.reflect.CollectionMetadata;
import org.osgi.service.blueprint.reflect.ComponentMetadata;
import org.osgi.service.blueprint.reflect.IdRefMetadata;
import org.osgi.service.blueprint.reflect.MapEntry;
import org.osgi.service.blueprint.reflect.MapMetadata;
import org.osgi.service.blueprint.reflect.Metadata;
import org.osgi.service.blueprint.reflect.NonNullMetadata;
import org.osgi.service.blueprint.reflect.NullMetadata;
import org.osgi.service.blueprint.reflect.PropsMetadata;
import org.osgi.service.blueprint.reflect.RefMetadata;
import org.osgi.service.blueprint.reflect.ReferenceListMetadata;
import org.osgi.service.blueprint.reflect.ReferenceListener;
import org.osgi.service.blueprint.reflect.ReferenceMetadata;
import org.osgi.service.blueprint.reflect.RegistrationListener;
import org.osgi.service.blueprint.reflect.ServiceMetadata;
import org.osgi.service.blueprint.reflect.ServiceReferenceMetadata;
import org.osgi.service.blueprint.reflect.Target;
import org.osgi.service.blueprint.reflect.ValueMetadata;
import org.w3c.dom.Attr;
import org.w3c.dom.CharacterData;
import org.w3c.dom.Comment;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.EntityReference;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
/**
* TODO: javadoc
*
* @version $Rev: 979454 $, $Date: 2010-07-26 22:38:25 +0100 (Mon, 26 Jul 2010) $
*/
public class Parser {
public static final String BLUEPRINT_NAMESPACE = "http://www.osgi.org/xmlns/blueprint/v1.0.0";
public static final String BLUEPRINT_ELEMENT = "blueprint";
public static final String DESCRIPTION_ELEMENT = "description";
public static final String TYPE_CONVERTERS_ELEMENT = "type-converters";
public static final String BEAN_ELEMENT = "bean";
public static final String ARGUMENT_ELEMENT = "argument";
public static final String REF_ELEMENT = "ref";
public static final String IDREF_ELEMENT = "idref";
public static final String LIST_ELEMENT = "list";
public static final String SET_ELEMENT = "set";
public static final String MAP_ELEMENT = "map";
public static final String ARRAY_ELEMENT = "array";
public static final String PROPS_ELEMENT = "props";
public static final String PROP_ELEMENT = "prop";
public static final String PROPERTY_ELEMENT = "property";
public static final String NULL_ELEMENT = "null";
public static final String VALUE_ELEMENT = "value";
public static final String SERVICE_ELEMENT = "service";
public static final String REFERENCE_ELEMENT = "reference";
public static final String REFERENCE_LIST_ELEMENT = "reference-list";
public static final String INTERFACES_ELEMENT = "interfaces";
public static final String REFERENCE_LISTENER_ELEMENT = "reference-listener";
public static final String SERVICE_PROPERTIES_ELEMENT = "service-properties";
public static final String REGISTRATION_LISTENER_ELEMENT = "registration-listener";
public static final String ENTRY_ELEMENT = "entry";
public static final String KEY_ELEMENT = "key";
public static final String DEFAULT_ACTIVATION_ATTRIBUTE = "default-activation";
public static final String DEFAULT_TIMEOUT_ATTRIBUTE = "default-timeout";
public static final String DEFAULT_AVAILABILITY_ATTRIBUTE = "default-availability";
public static final String NAME_ATTRIBUTE = "name";
public static final String ID_ATTRIBUTE = "id";
public static final String CLASS_ATTRIBUTE = "class";
public static final String INDEX_ATTRIBUTE = "index";
public static final String TYPE_ATTRIBUTE = "type";
public static final String VALUE_ATTRIBUTE = "value";
public static final String VALUE_REF_ATTRIBUTE = "value-ref";
public static final String KEY_ATTRIBUTE = "key";
public static final String KEY_REF_ATTRIBUTE = "key-ref";
public static final String REF_ATTRIBUTE = "ref";
public static final String COMPONENT_ID_ATTRIBUTE = "component-id";
public static final String INTERFACE_ATTRIBUTE = "interface";
public static final String DEPENDS_ON_ATTRIBUTE = "depends-on";
public static final String AUTO_EXPORT_ATTRIBUTE = "auto-export";
public static final String RANKING_ATTRIBUTE = "ranking";
public static final String TIMEOUT_ATTRIBUTE = "timeout";
public static final String FILTER_ATTRIBUTE = "filter";
public static final String COMPONENT_NAME_ATTRIBUTE = "component-name";
public static final String AVAILABILITY_ATTRIBUTE = "availability";
public static final String REGISTRATION_METHOD_ATTRIBUTE = "registration-method";
public static final String UNREGISTRATION_METHOD_ATTRIBUTE = "unregistration-method";
public static final String BIND_METHOD_ATTRIBUTE = "bind-method";
public static final String UNBIND_METHOD_ATTRIBUTE = "unbind-method";
public static final String KEY_TYPE_ATTRIBUTE = "key-type";
public static final String VALUE_TYPE_ATTRIBUTE = "value-type";
public static final String MEMBER_TYPE_ATTRIBUTE = "member-type";
public static final String SCOPE_ATTRIBUTE = "scope";
public static final String INIT_METHOD_ATTRIBUTE = "init-method";
public static final String DESTROY_METHOD_ATTRIBUTE = "destroy-method";
public static final String ACTIVATION_ATTRIBUTE = "activation";
public static final String FACTORY_REF_ATTRIBUTE = "factory-ref";
public static final String FACTORY_METHOD_ATTRIBUTE = "factory-method";
public static final String AUTO_EXPORT_DISABLED = "disabled";
public static final String AUTO_EXPORT_INTERFACES = "interfaces";
public static final String AUTO_EXPORT_CLASS_HIERARCHY = "class-hierarchy";
public static final String AUTO_EXPORT_ALL = "all-classes";
public static final String AUTO_EXPORT_DEFAULT = AUTO_EXPORT_DISABLED;
public static final String RANKING_DEFAULT = "0";
public static final String AVAILABILITY_MANDATORY = "mandatory";
public static final String AVAILABILITY_OPTIONAL = "optional";
public static final String AVAILABILITY_DEFAULT = AVAILABILITY_MANDATORY;
public static final String TIMEOUT_DEFAULT = "300000";
public static final String USE_SERVICE_OBJECT = "service-object";
public static final String USE_SERVICE_REFERENCE = "service-reference";
public static final String ACTIVATION_EAGER = "eager";
public static final String ACTIVATION_LAZY = "lazy";
public static final String ACTIVATION_DEFAULT = ACTIVATION_EAGER;
private static DocumentBuilderFactory documentBuilderFactory;
private final List<Document> documents = new ArrayList<Document>();
private ComponentDefinitionRegistry registry;
private NamespaceHandlerRegistry.NamespaceHandlerSet handlers;
private String idPrefix = "component-";
private final Set<String> ids = new HashSet<String>();
private int idCounter;
private String defaultTimeout;
private String defaultAvailability;
private String defaultActivation;
private Set<URI> namespaces;
private final Builder builder = new MetadataBuilder();
public Parser() {}
public Parser(String idPrefix) {
this.idPrefix = idPrefix;
}
/**
* Parse an input stream for blueprint xml.
* @param inputStream The data to parse. The caller is responsible for closing the stream afterwards.
* @throws Exception on parse error
*/
public void parse(InputStream inputStream) throws Exception {
InputSource inputSource = new InputSource(inputStream);
DocumentBuilder builder = getDocumentBuilderFactory().newDocumentBuilder();
Document doc = builder.parse(inputSource);
documents.add(doc);
}
/**
* Parse blueprint xml referred to by a list of URLs
* @param urls URLs to blueprint xml to parse
* @throws Exception on parse error
*/
public void parse(List<URL> urls) throws Exception {
// Create document builder factory
// Load documents
for (URL url : urls) {
InputStream inputStream = url.openStream();
try {
parse (inputStream);
} finally {
inputStream.close();
}
}
}
public Set<URI> getNamespaces() {
if (this.namespaces == null) {
Set<URI> namespaces = new LinkedHashSet<URI>();
for (Document doc : documents) {
findNamespaces(namespaces, doc);
}
this.namespaces = namespaces;
}
return this.namespaces;
}
private void findNamespaces(Set<URI> namespaces, Node node) {
if (node instanceof Element || node instanceof Attr) {
String ns = node.getNamespaceURI();
if (ns != null && !isBlueprintNamespace(ns) && !isIgnorableAttributeNamespace(ns)) {
namespaces.add(URI.create(ns));
}else if ( ns == null && //attributes from blueprint are unqualified as per schema.
node instanceof Attr &&
SCOPE_ATTRIBUTE.equals(node.getNodeName()) &&
((Attr)node).getOwnerElement() != null && //should never occur from parsed doc.
BLUEPRINT_NAMESPACE.equals(((Attr)node).getOwnerElement().getNamespaceURI()) &&
BEAN_ELEMENT.equals(((Attr)node).getOwnerElement().getLocalName()) ){
//Scope attribute is special case, as may contain namespace usage within its value.
URI scopeNS = getNamespaceForAttributeValue(node);
if(scopeNS!=null){
namespaces.add(scopeNS);
}
}
}
NamedNodeMap nnm = node.getAttributes();
if(nnm!=null){
for(int i = 0; i< nnm.getLength() ; i++){
findNamespaces(namespaces, nnm.item(i));
}
}
NodeList nl = node.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
findNamespaces(namespaces, nl.item(i));
}
}
public void populate(NamespaceHandlerRegistry.NamespaceHandlerSet handlers,
ComponentDefinitionRegistry registry) {
this.handlers = handlers;
this.registry = registry;
if (this.documents == null) {
throw new IllegalStateException("Documents should be parsed before populating the registry");
}
// Parse components
for (Document doc : this.documents) {
loadComponents(doc);
}
}
public void validate(Schema schema) {
try {
Validator validator = schema.newValidator();
for (Document doc : this.documents) {
validator.validate(new DOMSource(doc));
}
} catch (Exception e) {
throw new ComponentDefinitionException("Unable to validate xml", e);
}
}
private void loadComponents(Document doc) {
defaultTimeout = TIMEOUT_DEFAULT;
defaultAvailability = AVAILABILITY_DEFAULT;
defaultActivation = ACTIVATION_DEFAULT;
Element root = doc.getDocumentElement();
if (!isBlueprintNamespace(root.getNamespaceURI()) ||
!nodeNameEquals(root, BLUEPRINT_ELEMENT)) {
throw new ComponentDefinitionException("Root element must be {" + BLUEPRINT_NAMESPACE + "}" + BLUEPRINT_ELEMENT + " element");
}
// Parse global attributes
if (root.hasAttribute(DEFAULT_ACTIVATION_ATTRIBUTE)) {
defaultActivation = root.getAttribute(DEFAULT_ACTIVATION_ATTRIBUTE);
}
if (root.hasAttribute(DEFAULT_TIMEOUT_ATTRIBUTE)) {
defaultTimeout = root.getAttribute(DEFAULT_TIMEOUT_ATTRIBUTE);
}
if (root.hasAttribute(DEFAULT_AVAILABILITY_ATTRIBUTE)) {
defaultAvailability = root.getAttribute(DEFAULT_AVAILABILITY_ATTRIBUTE);
}
// Parse custom attributes
handleCustomAttributes(root.getAttributes(), null);
// Parse elements
// Break into 2 loops to ensure we scan the blueprint elements before
// This is needed so that when we process the custom element, we know
// the component definition registry has populated all blueprint components.
NodeList nl = root.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element element = (Element) node;
String namespaceUri = element.getNamespaceURI();
if (isBlueprintNamespace(namespaceUri)) {
parseBlueprintElement(element);
}
}
}
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element element = (Element) node;
String namespaceUri = element.getNamespaceURI();
if (!isBlueprintNamespace(namespaceUri)) {
Metadata component = parseCustomElement(element, null);
if (component != null) {
if (!(component instanceof ComponentMetadata)) {
throw new ComponentDefinitionException("Expected a ComponentMetadata to be returned when parsing element " + element.getNodeName());
}
registry.registerComponentDefinition((ComponentMetadata) component);
}
}
}
}
}
public <T> T parseElement(Class<T> type, ComponentMetadata enclosingComponent, Element element) {
if (BeanArgument.class.isAssignableFrom(type)) {
return type.cast(parseBeanArgument(enclosingComponent, element));
} else if (BeanProperty.class.isAssignableFrom(type)) {
return type.cast(parseBeanProperty(enclosingComponent, element));
} else if (MapEntry.class.isAssignableFrom(type)) {
return type.cast(parseMapEntry(element, enclosingComponent, null, null));
} else if (MapMetadata.class.isAssignableFrom(type)) {
return type.cast(parseMap(element, enclosingComponent));
} else if (BeanMetadata.class.isAssignableFrom(type)) {
return type.cast(parseBeanMetadata(element, enclosingComponent == null));
} else if (NullMetadata.class.isAssignableFrom(type)) {
return type.cast(NullMetadata.NULL);
} else if (CollectionMetadata.class.isAssignableFrom(type)) {
return type.cast(parseCollection(Collection.class, element, enclosingComponent));
} else if (PropsMetadata.class.isAssignableFrom(type)) {
return type.cast(parseProps(element));
} else if (ReferenceMetadata.class.isAssignableFrom(type)) {
return type.cast(parseReference(element, enclosingComponent == null));
} else if (ReferenceListMetadata.class.isAssignableFrom(type)) {
return type.cast(parseRefList(element, enclosingComponent == null));
} else if (ServiceMetadata.class.isAssignableFrom(type)) {
return type.cast(parseService(element, enclosingComponent == null));
} else if (IdRefMetadata.class.isAssignableFrom(type)) {
return type.cast(parseIdRef(element));
} else if (RefMetadata.class.isAssignableFrom(type)) {
return type.cast(parseRef(element));
} else if (ValueMetadata.class.isAssignableFrom(type)) {
return type.cast(parseValue(element, null));
} else if (ReferenceListener.class.isAssignableFrom(type)) {
return type.cast(parseServiceListener(element, enclosingComponent));
} else if (Metadata.class.isAssignableFrom(type)) {
return type.cast(parseValueGroup(element, enclosingComponent, null, true));
} else {
throw new ComponentDefinitionException("Unknown type to parse element: " + type.getName());
}
}
private void parseBlueprintElement(Element element) {
if (nodeNameEquals(element, DESCRIPTION_ELEMENT)) {
// Ignore description
} else if (nodeNameEquals(element, TYPE_CONVERTERS_ELEMENT)) {
parseTypeConverters(element);
} else if (nodeNameEquals(element, BEAN_ELEMENT)) {
ComponentMetadata component = parseBeanMetadata(element, true);
registry.registerComponentDefinition(component);
} else if (nodeNameEquals(element, SERVICE_ELEMENT)) {
ComponentMetadata service = parseService(element, true);
registry.registerComponentDefinition(service);
} else if (nodeNameEquals(element, REFERENCE_ELEMENT)) {
ComponentMetadata reference = parseReference(element, true);
registry.registerComponentDefinition(reference);
} else if (nodeNameEquals(element, REFERENCE_LIST_ELEMENT) ) {
ComponentMetadata references = parseRefList(element, true);
registry.registerComponentDefinition(references);
} else {
throw new ComponentDefinitionException("Unknown element " + element.getNodeName() + " in namespace " + BLUEPRINT_NAMESPACE);
}
}
private void parseTypeConverters(Element element) {
NodeList nl = element.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element e = (Element) node;
Object target = null;
if (isBlueprintNamespace(e.getNamespaceURI())) {
if (nodeNameEquals(e, BEAN_ELEMENT)) {
target = parseBeanMetadata(e, true);
} else if (nodeNameEquals(e, REF_ELEMENT)) {
String componentName = e.getAttribute(COMPONENT_ID_ATTRIBUTE);
target = builder.newRef().componentId(componentName);
} else if (nodeNameEquals(e, REFERENCE_ELEMENT)) {
target = parseReference(e, true);
}
} else {
target = parseCustomElement(e, null);
}
if (!(target instanceof Target)) {
throw new ComponentDefinitionException("Metadata parsed for element " + e.getNodeName() + " can not be used as a type converter");
}
registry.registerTypeConverter((Target) target);
}
}
}
/**
* Takes an Attribute Node containing a namespace prefix qualified attribute value, and resolves the namespace using the DOM Node.<br>
*
* @param attrNode The DOM Node with the qualified attribute value.
* @return The URI if one is resolvable, or null if the attr is null, or not namespace prefixed. (or not a DOM Attribute Node)
* @throws ComponentDefinitionException if the namespace prefix in the attribute value cannot be resolved.
*/
private URI getNamespaceForAttributeValue(Node attrNode) throws ComponentDefinitionException {
URI uri = null;
if(attrNode!=null && (attrNode instanceof Attr)){
Attr attr = (Attr)attrNode;
String attrValue = attr.getValue();
if(attrValue!=null && attrValue.indexOf(":")!=-1){
String parts[] = attrValue.split(":");
String uriStr = attr.getOwnerElement().lookupNamespaceURI(parts[0]);
if(uriStr!=null){
uri = URI.create(uriStr);
}else{
throw new ComponentDefinitionException("Unsupported attribute namespace prefix "+parts[0]+" "+attr);
}
}
}
return uri;
}
/**
* Tests if a scope attribute value is a custom scope, and if so invokes
* the appropriate namespace handler, passing the blueprint scope node.
* <p>
* Currently this tests for custom scope by looking for the presence of
* a ':' char within the scope attribute value. This is valid as long as
* the blueprint schema continues to restrict that custom scopes should
* require that characters presence.
* <p>
*
* @param scope Value of scope attribute
* @param bean DOM element for bean associated to this scope
* @return Metadata as processed by NS Handler.
* @throws ComponentDefinitionException if an undeclared prefix is used,
* if a namespace handler is unavailable for a resolved prefix,
* or if the resolved prefix results as the blueprint namespace.
*/
private ComponentMetadata handleCustomScope(Node scope, Element bean, ComponentMetadata metadata){
URI scopeNS = getNamespaceForAttributeValue(scope);
if(scopeNS!=null && !BLUEPRINT_NAMESPACE.equals(scopeNS.toString())){
NamespaceHandler nsHandler = getNamespaceHandler(scopeNS);
ParserContextImpl context = new ParserContextImpl(this, registry, metadata, scope);
metadata = nsHandler.decorate(scope, metadata, context);
}else if(scopeNS!=null){
throw new ComponentDefinitionException("Custom scopes cannot use the blueprint namespace "+scope);
}
return metadata;
}
private ComponentMetadata parseBeanMetadata(Element element, boolean topElement) {
MutableBeanMetadata<?> metadata = builder.newBean();
if (topElement) {
metadata.id(getId(element));
if (element.hasAttribute(SCOPE_ATTRIBUTE)) {
metadata.scope(element.getAttribute(SCOPE_ATTRIBUTE));
if (metadata.getScope().equals(BeanMetadata.SCOPE_PROTOTYPE)) {
if (element.hasAttribute(ACTIVATION_ATTRIBUTE)) {
if (element.getAttribute(ACTIVATION_ATTRIBUTE).equals(ACTIVATION_EAGER)) {
throw new ComponentDefinitionException("A <bean> with a prototype scope can not have an eager activation");
}
}
metadata.activation(ComponentMetadata.ACTIVATION_LAZY);
} else {
metadata.activation(parseActivation(element));
}
} else {
metadata.activation(parseActivation(element));
}
} else {
metadata.activation(ComponentMetadata.ACTIVATION_LAZY);
}
if (element.hasAttribute(CLASS_ATTRIBUTE)) {
metadata.className(element.getAttribute(CLASS_ATTRIBUTE));
}
if (element.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
metadata.dependsOn(parseList(element.getAttribute(DEPENDS_ON_ATTRIBUTE)));
}
if (element.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
metadata.initMethod(element.getAttribute(INIT_METHOD_ATTRIBUTE));
}
if (element.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {
metadata.destroyMethod(element.getAttribute(DESTROY_METHOD_ATTRIBUTE));
}
if (element.hasAttribute(FACTORY_REF_ATTRIBUTE)) {
metadata.factoryComponent(builder.newRef().componentId(element.getAttribute(FACTORY_REF_ATTRIBUTE)));
}
if (element.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
metadata.factoryMethod(element.getAttribute(FACTORY_METHOD_ATTRIBUTE));
}
// Do some validation
if (metadata.getClassName() == null && metadata.getFactoryComponent() == null) {
throw new ComponentDefinitionException("Bean class or factory-ref must be specified");
}
if (metadata.getFactoryComponent() != null && metadata.getFactoryMethod() == null) {
throw new ComponentDefinitionException("factory-method is required when factory-component is set");
}
if (MetadataUtil.isPrototypeScope(metadata) && metadata.getDestroyMethod() != null) {
throw new ComponentDefinitionException("destroy-method must not be set for a <bean> with a prototype scope");
}
// Parse elements
NodeList nl = element.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element e = (Element) node;
if (isBlueprintNamespace(node.getNamespaceURI())) {
if (nodeNameEquals(node, ARGUMENT_ELEMENT)) {
metadata.addArgument(parseBeanArgument(metadata, e));
} else if (nodeNameEquals(node, PROPERTY_ELEMENT)) {
metadata.addProperty(parseBeanProperty(metadata, e));
}
}
}
}
MetadataUtil.validateBeanArguments(metadata.getArguments());
ComponentMetadata m = metadata;
// Parse custom scopes
m = handleCustomScope(element.getAttributeNode(SCOPE_ATTRIBUTE), element, m);
// Parse custom attributes
m = handleCustomAttributes(element.getAttributes(), m);
// Parse custom elements;
m = handleCustomElements(element, m);
return m;
}
public BeanProperty parseBeanProperty(ComponentMetadata enclosingComponent, Element element) {
String name = element.hasAttribute(NAME_ATTRIBUTE) ? element.getAttribute(NAME_ATTRIBUTE) : null;
Metadata value = parseArgumentOrPropertyValue(element, enclosingComponent);
return builder.newBeanProperty().name(name).value(value);
}
private BeanArgument parseBeanArgument(ComponentMetadata enclosingComponent, Element element) {
int index = element.hasAttribute(INDEX_ATTRIBUTE) ? Integer.parseInt(element.getAttribute(INDEX_ATTRIBUTE)) : -1;
String type = element.hasAttribute(TYPE_ATTRIBUTE) ? element.getAttribute(TYPE_ATTRIBUTE) : null;
Metadata value = parseArgumentOrPropertyValue(element, enclosingComponent);
return builder.newBeanArgument().value(value).valueType(type).index(index);
}
private ComponentMetadata parseService(Element element, boolean topElement) {
MutableServiceMetadata<?> service = builder.newService();
boolean hasInterfaceNameAttribute = false;
if (topElement) {
service.id(getId(element));
service.activation(parseActivation(element));
} else {
service.activation(ComponentMetadata.ACTIVATION_LAZY);
}
if (element.hasAttribute(INTERFACE_ATTRIBUTE)) {
service.interfaces(Collections.singletonList(element.getAttribute(INTERFACE_ATTRIBUTE)));
hasInterfaceNameAttribute = true;
}
if (element.hasAttribute(REF_ATTRIBUTE)) {
service.serviceComponent(builder.newRef().componentId(element.getAttribute(REF_ATTRIBUTE)));
}
if (element.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
service.dependsOn(parseList(element.getAttribute(DEPENDS_ON_ATTRIBUTE)));
}
String autoExport = element.hasAttribute(AUTO_EXPORT_ATTRIBUTE) ? element.getAttribute(AUTO_EXPORT_ATTRIBUTE) : AUTO_EXPORT_DEFAULT;
if (AUTO_EXPORT_DISABLED.equals(autoExport)) {
service.autoExport(ServiceMetadata.AUTO_EXPORT_DISABLED);
} else if (AUTO_EXPORT_INTERFACES.equals(autoExport)) {
service.autoExport(ServiceMetadata.AUTO_EXPORT_INTERFACES);
} else if (AUTO_EXPORT_CLASS_HIERARCHY.equals(autoExport)) {
service.autoExport(ServiceMetadata.AUTO_EXPORT_CLASS_HIERARCHY);
} else if (AUTO_EXPORT_ALL.equals(autoExport)) {
service.autoExport(ServiceMetadata.AUTO_EXPORT_ALL_CLASSES);
} else {
throw new ComponentDefinitionException("Illegal value (" + autoExport + ") for " + AUTO_EXPORT_ATTRIBUTE + " attribute");
}
String ranking = element.hasAttribute(RANKING_ATTRIBUTE) ? element.getAttribute(RANKING_ATTRIBUTE) : RANKING_DEFAULT;
try {
service.ranking(Integer.parseInt(ranking));
} catch (NumberFormatException e) {
throw new ComponentDefinitionException("Attribute " + RANKING_ATTRIBUTE + " must be a valid integer (was: " + ranking + ")");
}
// Parse elements
NodeList nl = element.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element e = (Element) node;
if (isBlueprintNamespace(e.getNamespaceURI())) {
if (nodeNameEquals(e, INTERFACES_ELEMENT)) {
if (hasInterfaceNameAttribute) {
throw new ComponentDefinitionException("Only one of " + INTERFACE_ATTRIBUTE + " attribute or " + INTERFACES_ELEMENT + " element must be used");
}
service.interfaces(parseInterfaceNames(e));
} else if (nodeNameEquals(e, SERVICE_PROPERTIES_ELEMENT)) {
List<MapEntry> entries = parseServiceProperties(e, service).getEntries();
service.serviceProperties(entries);
} else if (nodeNameEquals(e, REGISTRATION_LISTENER_ELEMENT)) {
service.addRegistrationListener(parseRegistrationListener(e, service));
} else if (nodeNameEquals(e, BEAN_ELEMENT)) {
if (service.getServiceComponent() != null) {
throw new ComponentDefinitionException("Only one of " + REF_ATTRIBUTE + " attribute, " + BEAN_ELEMENT + " element, " + REFERENCE_ELEMENT + " element or " + REF_ELEMENT + " element can be set");
}
service.serviceComponent((Target) parseBeanMetadata(e, false));
} else if (nodeNameEquals(e, REF_ELEMENT)) {
if (service.getServiceComponent() != null) {
throw new ComponentDefinitionException("Only one of " + REF_ATTRIBUTE + " attribute, " + BEAN_ELEMENT + " element, " + REFERENCE_ELEMENT + " element or " + REF_ELEMENT + " element can be set");
}
String component = e.getAttribute(COMPONENT_ID_ATTRIBUTE);
if (component == null || component.length() == 0) {
throw new ComponentDefinitionException("Element " + REF_ELEMENT + " must have a valid " + COMPONENT_ID_ATTRIBUTE + " attribute");
}
service.serviceComponent(builder.newRef().componentId(component));
} else if (nodeNameEquals(e, REFERENCE_ELEMENT)) {
if (service.getServiceComponent() != null) {
throw new ComponentDefinitionException("Only one of " + REF_ATTRIBUTE + " attribute, " + BEAN_ELEMENT + " element, " + REFERENCE_ELEMENT + " element or " + REF_ELEMENT + " element can be set");
}
service.serviceComponent((Target) parseReference(e, false));
}
}
}
}
// Check service
if (service.getServiceComponent() == null) {
throw new ComponentDefinitionException("One of " + REF_ATTRIBUTE + " attribute, " + BEAN_ELEMENT + " element, " + REFERENCE_ELEMENT + " element or " + REF_ELEMENT + " element must be set");
}
// Check interface
if (service.getAutoExport() == ServiceMetadata.AUTO_EXPORT_DISABLED && service.getInterfaces().isEmpty()) {
throw new ComponentDefinitionException(INTERFACE_ATTRIBUTE + " attribute or " + INTERFACES_ELEMENT + " element must be set when " + AUTO_EXPORT_ATTRIBUTE + " is set to " + AUTO_EXPORT_DISABLED);
}
// Check for non-disabled auto-exports and interfaces
if (service.getAutoExport() != ServiceMetadata.AUTO_EXPORT_DISABLED && !service.getInterfaces().isEmpty()) {
throw new ComponentDefinitionException(INTERFACE_ATTRIBUTE + " attribute or " + INTERFACES_ELEMENT + " element must not be set when " + AUTO_EXPORT_ATTRIBUTE + " is set to anything else than " + AUTO_EXPORT_DISABLED);
}
ComponentMetadata s = service;
// Parse custom attributes
s = handleCustomAttributes(element.getAttributes(), s);
// Parse custom elements;
s = handleCustomElements(element, s);
return s;
}
private CollectionMetadata parseArray(Element element, ComponentMetadata enclosingComponent) {
return parseCollection(Object[].class, element, enclosingComponent);
}
private CollectionMetadata parseList(Element element, ComponentMetadata enclosingComponent) {
return parseCollection(List.class, element, enclosingComponent);
}
private CollectionMetadata parseSet(Element element, ComponentMetadata enclosingComponent) {
return parseCollection(Set.class, element, enclosingComponent);
}
private CollectionMetadata parseCollection(Class collectionType, Element element, ComponentMetadata enclosingComponent) {
// Parse attributes
String valueType = element.hasAttribute(VALUE_TYPE_ATTRIBUTE) ? element.getAttribute(VALUE_TYPE_ATTRIBUTE) : null;
// Parse elements
List<Metadata> list = new ArrayList<Metadata>();
NodeList nl = element.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Metadata val = parseValueGroup((Element) node, enclosingComponent, null, true);
list.add(val);
}
}
return builder.newCollection()
.collectionClass(collectionType)
.valueType(valueType)
.values(list);
}
public PropsMetadata parseProps(Element element) {
// Parse elements
List<MapEntry> entries = new ArrayList<MapEntry>();
NodeList nl = element.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element e = (Element) node;
if (isBlueprintNamespace(e.getNamespaceURI()) && nodeNameEquals(e, PROP_ELEMENT)) {
entries.add(parseProperty(e));
}
}
}
return builder.newProps().entries(entries);
}
private MapEntry parseProperty(Element element) {
// Parse attributes
if (!element.hasAttribute(KEY_ATTRIBUTE)) {
throw new ComponentDefinitionException(KEY_ATTRIBUTE + " attribute is required");
}
String value;
if (element.hasAttribute(VALUE_ATTRIBUTE)) {
value = element.getAttribute(VALUE_ATTRIBUTE);
} else {
value = getTextValue(element);
}
String key = element.getAttribute(KEY_ATTRIBUTE);
return builder.newMapEntry()
.key(builder.newValue().stringValue(key))
.value(builder.newValue().stringValue(value));
}
public MapMetadata parseMap(Element element, ComponentMetadata enclosingComponent) {
// Parse attributes
String keyType = element.hasAttribute(KEY_TYPE_ATTRIBUTE) ? element.getAttribute(KEY_TYPE_ATTRIBUTE) : null;
String valueType = element.hasAttribute(VALUE_TYPE_ATTRIBUTE) ? element.getAttribute(VALUE_TYPE_ATTRIBUTE) : null;
// Parse elements
List<MapEntry> entries = new ArrayList<MapEntry>();
NodeList nl = element.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element e = (Element) node;
if (nodeNameEquals(e, ENTRY_ELEMENT)) {
entries.add(parseMapEntry(e, enclosingComponent, null, null));
}
}
}
return builder.newMap()
.keyType(keyType)
.valueType(valueType)
.entries(entries);
}
private MapEntry parseMapEntry(Element element, ComponentMetadata enclosingComponent, String keyType, String valueType) {
// Parse attributes
String key = element.hasAttribute(KEY_ATTRIBUTE) ? element.getAttribute(KEY_ATTRIBUTE) : null;
String keyRef = element.hasAttribute(KEY_REF_ATTRIBUTE) ? element.getAttribute(KEY_REF_ATTRIBUTE) : null;
String value = element.hasAttribute(VALUE_ATTRIBUTE) ? element.getAttribute(VALUE_ATTRIBUTE) : null;
String valueRef = element.hasAttribute(VALUE_REF_ATTRIBUTE) ? element.getAttribute(VALUE_REF_ATTRIBUTE) : null;
// Parse elements
NonNullMetadata keyValue = null;
Metadata valValue = null;
NodeList nl = element.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element e = (Element) node;
if (nodeNameEquals(e, KEY_ELEMENT)) {
keyValue = parseMapKeyEntry(e, enclosingComponent, keyType);
} else {
valValue = parseValueGroup(e, enclosingComponent, valueType, true);
}
}
}
// Check key
if (keyValue != null && (key != null || keyRef != null) || (keyValue == null && key == null && keyRef == null)) {
throw new ComponentDefinitionException("Only and only one of " + KEY_ATTRIBUTE + " attribute, " + KEY_REF_ATTRIBUTE + " attribute or " + KEY_ELEMENT + " element must be set");
} else if (keyValue == null && key != null) {
keyValue = builder.newValue().type(keyType).stringValue(key);
} else if (keyValue == null /*&& keyRef != null*/) {
keyValue = builder.newRef().componentId(keyRef);
}
// Check value
if (valValue != null && (value != null || valueRef != null) || (valValue == null && value == null && valueRef == null)) {
throw new ComponentDefinitionException("Only and only one of " + VALUE_ATTRIBUTE + " attribute, " + VALUE_REF_ATTRIBUTE + " attribute or sub element must be set");
} else if (valValue == null && value != null) {
valValue = builder.newValue().type(valueType).stringValue(value);
} else if (valValue == null /*&& valueRef != null*/) {
valValue = builder.newRef().componentId(valueRef);
}
return builder.newMapEntry().key(keyValue).value(valValue);
}
private NonNullMetadata parseMapKeyEntry(Element element, ComponentMetadata enclosingComponent, String keyType) {
NonNullMetadata keyValue = null;
NodeList nl = element.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element e = (Element) node;
if (keyValue != null) {
// TODO: throw an exception
}
keyValue = (NonNullMetadata) parseValueGroup(e, enclosingComponent, keyType, false);
break;
}
}
if (keyValue == null) {
// TODO: throw an exception
}
return keyValue;
}
public MapMetadata parseServiceProperties(Element element, ComponentMetadata enclosingComponent) {
// TODO: need to handle this better
MapMetadata map = parseMap(element, enclosingComponent);
handleCustomElements(element, enclosingComponent);
return map;
}
public RegistrationListener parseRegistrationListener(Element element, ComponentMetadata enclosingComponent) {
MutableRegistrationListener<?> listener = builder.newRegistrationListener();
Metadata listenerComponent = null;
// Parse attributes
if (element.hasAttribute(REF_ATTRIBUTE)) {
listenerComponent = builder.newRef().componentId(element.getAttribute(REF_ATTRIBUTE));
}
String registrationMethod = null;
if (element.hasAttribute(REGISTRATION_METHOD_ATTRIBUTE)) {
registrationMethod = element.getAttribute(REGISTRATION_METHOD_ATTRIBUTE);
listener.registrationMethod(registrationMethod);
}
String unregistrationMethod = null;
if (element.hasAttribute(UNREGISTRATION_METHOD_ATTRIBUTE)) {
unregistrationMethod = element.getAttribute(UNREGISTRATION_METHOD_ATTRIBUTE);
listener.unregistrationMethod(unregistrationMethod);
}
if (registrationMethod == null && unregistrationMethod == null) {
throw new ComponentDefinitionException("One of " + REGISTRATION_METHOD_ATTRIBUTE + " or " + UNREGISTRATION_METHOD_ATTRIBUTE + " must be set");
}
// Parse elements
NodeList nl = element.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element e = (Element) node;
if (isBlueprintNamespace(e.getNamespaceURI())) {
if (nodeNameEquals(e, REF_ELEMENT)) {
if (listenerComponent != null) {
throw new ComponentDefinitionException("Only one of " + REF_ATTRIBUTE + " attribute, " + REF_ELEMENT + ", " + BEAN_ELEMENT + ", " + REFERENCE_ELEMENT + ", " + SERVICE_ELEMENT + " or custom element can be set");
}
String component = e.getAttribute(COMPONENT_ID_ATTRIBUTE);
if (component == null || component.length() == 0) {
throw new ComponentDefinitionException("Element " + REF_ELEMENT + " must have a valid " + COMPONENT_ID_ATTRIBUTE + " attribute");
}
listenerComponent = builder.newRef().componentId(component);
} else if (nodeNameEquals(e, BEAN_ELEMENT)) {
if (listenerComponent != null) {
throw new ComponentDefinitionException("Only one of " + REF_ATTRIBUTE + " attribute, " + REF_ELEMENT + ", " + BEAN_ELEMENT + ", " + REFERENCE_ELEMENT + ", " + SERVICE_ELEMENT + " or custom element can be set");
}
listenerComponent = parseBeanMetadata(e, false);
} else if (nodeNameEquals(e, REFERENCE_ELEMENT)) {
if (listenerComponent != null) {
throw new ComponentDefinitionException("Only one of " + REF_ATTRIBUTE + " attribute, " + REF_ELEMENT + ", " + BEAN_ELEMENT + ", " + REFERENCE_ELEMENT + ", " + SERVICE_ELEMENT + " or custom element can be set");
}
listenerComponent = parseReference(e, false);
} else if (nodeNameEquals(e, SERVICE_ELEMENT)) {
if (listenerComponent != null) {
throw new ComponentDefinitionException("Only one of " + REF_ATTRIBUTE + " attribute, " + REF_ELEMENT + ", " + BEAN_ELEMENT + ", " + REFERENCE_ELEMENT + ", " + SERVICE_ELEMENT + " or custom element can be set");
}
listenerComponent = parseService(e, false);
}
} else {
if (listenerComponent != null) {
throw new ComponentDefinitionException("Only one of " + REF_ATTRIBUTE + " attribute, " + REF_ELEMENT + ", " + BEAN_ELEMENT + ", " + REFERENCE_ELEMENT + ", " + SERVICE_ELEMENT + " or custom element can be set");
}
listenerComponent = parseCustomElement(e, enclosingComponent);
}
}
}
if (listenerComponent == null) {
throw new ComponentDefinitionException("One of " + REF_ATTRIBUTE + " attribute, " + REF_ELEMENT + ", " + BEAN_ELEMENT + ", " + REFERENCE_ELEMENT + ", " + SERVICE_ELEMENT + " or custom element must be set");
}
listener.listenerComponent((Target) listenerComponent);
return listener;
}
private ComponentMetadata parseReference(Element element, boolean topElement) {
MutableReferenceMetadata<?> reference = builder.newReference();
if (topElement) {
reference.id(getId(element));
}
parseReference(element, reference, topElement);
String timeout = element.hasAttribute(TIMEOUT_ATTRIBUTE) ? element.getAttribute(TIMEOUT_ATTRIBUTE) : this.defaultTimeout;
try {
reference.timeout(Long.parseLong(timeout));
} catch (NumberFormatException e) {
throw new ComponentDefinitionException("Attribute " + TIMEOUT_ATTRIBUTE + " must be a valid long (was: " + timeout + ")");
}
ComponentMetadata r = reference;
// Parse custom attributes
r = handleCustomAttributes(element.getAttributes(), r);
// Parse custom elements;
r = handleCustomElements(element, r);
return r;
}
public String getDefaultTimeout() {
return defaultTimeout;
}
public String getDefaultAvailability() {
return defaultAvailability;
}
public String getDefaultActivation() {
return defaultActivation;
}
private ComponentMetadata parseRefList(Element element, boolean topElement) {
MutableReferenceListMetadata<?> references = builder.newRefList();
if (topElement) {
references.id(getId(element));
}
if (element.hasAttribute(MEMBER_TYPE_ATTRIBUTE)) {
String memberType = element.getAttribute(MEMBER_TYPE_ATTRIBUTE);
if (USE_SERVICE_OBJECT.equals(memberType)) {
references.memberType(ReferenceListMetadata.USE_SERVICE_OBJECT);
} else if (USE_SERVICE_REFERENCE.equals(memberType)) {
references.memberType(ReferenceListMetadata.USE_SERVICE_REFERENCE);
}
} else {
references.memberType(ReferenceListMetadata.USE_SERVICE_OBJECT);
}
parseReference(element, references, topElement);
ComponentMetadata r = references;
// Parse custom attributes
r = handleCustomAttributes(element.getAttributes(), r);
// Parse custom elements;
r = handleCustomElements(element, r);
return r;
}
private void parseReference(Element element, MutableServiceReferenceMetadata<?,?> reference, boolean topElement) {
// Parse attributes
if (topElement) {
reference.activation(parseActivation(element));
} else {
reference.activation(ComponentMetadata.ACTIVATION_LAZY);
}
if (element.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
reference.dependsOn(parseList(element.getAttribute(DEPENDS_ON_ATTRIBUTE)));
}
if (element.hasAttribute(INTERFACE_ATTRIBUTE)) {
reference.serviceInterface(element.getAttribute(INTERFACE_ATTRIBUTE));
}
if (element.hasAttribute(FILTER_ATTRIBUTE)) {
reference.filter(element.getAttribute(FILTER_ATTRIBUTE));
}
if (element.hasAttribute(COMPONENT_NAME_ATTRIBUTE)) {
reference.componentName(element.getAttribute(COMPONENT_NAME_ATTRIBUTE));
}
String availability = element.hasAttribute(AVAILABILITY_ATTRIBUTE) ? element.getAttribute(AVAILABILITY_ATTRIBUTE) : defaultAvailability;
if (AVAILABILITY_MANDATORY.equals(availability)) {
reference.availability(ServiceReferenceMetadata.AVAILABILITY_MANDATORY);
} else if (AVAILABILITY_OPTIONAL.equals(availability)) {
reference.availability(ServiceReferenceMetadata.AVAILABILITY_OPTIONAL);
} else {
throw new ComponentDefinitionException("Illegal value for " + AVAILABILITY_ATTRIBUTE + " attribute: " + availability);
}
// Parse elements
NodeList nl = element.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element e = (Element) node;
if (isBlueprintNamespace(e.getNamespaceURI())) {
if (nodeNameEquals(e, REFERENCE_LISTENER_ELEMENT)) {
reference.addReferenceListener(parseServiceListener(e, reference));
}
}
}
}
}
private ReferenceListener parseServiceListener(Element element, ComponentMetadata enclosingComponent) {
MutableReferenceListener<?> listener = builder.newReferenceListener();
Metadata listenerComponent = null;
// Parse attributes
if (element.hasAttribute(REF_ATTRIBUTE)) {
listenerComponent = builder.newRef().componentId(element.getAttribute(REF_ATTRIBUTE));
}
String bindMethodName = null;
String unbindMethodName = null;
if (element.hasAttribute(BIND_METHOD_ATTRIBUTE)) {
bindMethodName = element.getAttribute(BIND_METHOD_ATTRIBUTE);
listener.bindMethod(bindMethodName);
}
if (element.hasAttribute(UNBIND_METHOD_ATTRIBUTE)) {
unbindMethodName = element.getAttribute(UNBIND_METHOD_ATTRIBUTE);
listener.unbindMethod(unbindMethodName);
}
if (bindMethodName == null && unbindMethodName == null) {
throw new ComponentDefinitionException("One of " + BIND_METHOD_ATTRIBUTE + " or " + UNBIND_METHOD_ATTRIBUTE + " must be set");
}
// Parse elements
NodeList nl = element.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element e = (Element) node;
if (isBlueprintNamespace(e.getNamespaceURI())) {
if (nodeNameEquals(e, REF_ELEMENT)) {
if (listenerComponent != null) {
throw new ComponentDefinitionException("Only one of " + REF_ATTRIBUTE + " attribute, " + REF_ELEMENT + ", " + BLUEPRINT_ELEMENT + ", " + REFERENCE_ELEMENT + ", " + SERVICE_ELEMENT + " or custom element can be set");
}
String component = e.getAttribute(COMPONENT_ID_ATTRIBUTE);
if (component == null || component.length() == 0) {
throw new ComponentDefinitionException("Element " + REF_ELEMENT + " must have a valid " + COMPONENT_ID_ATTRIBUTE + " attribute");
}
listenerComponent = builder.newRef().componentId(component);
} else if (nodeNameEquals(e, BEAN_ELEMENT)) {
if (listenerComponent != null) {
throw new ComponentDefinitionException("Only one of " + REF_ATTRIBUTE + " attribute, " + REF_ELEMENT + ", " + BLUEPRINT_ELEMENT + ", " + REFERENCE_ELEMENT + ", " + SERVICE_ELEMENT + " or custom element can be set");
}
listenerComponent = parseBeanMetadata(e, false);
} else if (nodeNameEquals(e, REFERENCE_ELEMENT)) {
if (listenerComponent != null) {
throw new ComponentDefinitionException("Only one of " + REF_ATTRIBUTE + " attribute, " + REF_ELEMENT + ", " + BLUEPRINT_ELEMENT + ", " + REFERENCE_ELEMENT + ", " + SERVICE_ELEMENT + " or custom element can be set");
}
listenerComponent = parseReference(e, false);
} else if (nodeNameEquals(e, SERVICE_ELEMENT)) {
if (listenerComponent != null) {
throw new ComponentDefinitionException("Only one of " + REF_ATTRIBUTE + " attribute, " + REF_ELEMENT + ", " + BLUEPRINT_ELEMENT + ", " + REFERENCE_ELEMENT + ", " + SERVICE_ELEMENT + " or custom element can be set");
}
listenerComponent = parseService(e, false);
}
} else {
if (listenerComponent != null) {
throw new ComponentDefinitionException("Only one of " + REF_ATTRIBUTE + " attribute, " + REF_ELEMENT + ", " + BLUEPRINT_ELEMENT + ", " + REFERENCE_ELEMENT + ", " + SERVICE_ELEMENT + " or custom element can be set");
}
listenerComponent = parseCustomElement(e, enclosingComponent);
}
}
}
if (listenerComponent == null) {
throw new ComponentDefinitionException("One of " + REF_ATTRIBUTE + " attribute, " + REF_ELEMENT + ", " + BLUEPRINT_ELEMENT + ", " + REFERENCE_ELEMENT + ", " + SERVICE_ELEMENT + " or custom element must be set");
}
listener.listenerComponent((Target) listenerComponent);
return listener;
}
public List<String> parseInterfaceNames(Element element) {
List<String> interfaceNames = new ArrayList<String>();
NodeList nl = element.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element e = (Element) node;
if (nodeNameEquals(e, VALUE_ELEMENT)) {
String v = getTextValue(e).trim();
if (interfaceNames.contains(v)) {
throw new ComponentDefinitionException("The element " + INTERFACES_ELEMENT + " should not contain the same interface twice");
}
interfaceNames.add(getTextValue(e));
} else {
throw new ComponentDefinitionException("Unsupported element " + e.getNodeName() + " inside an " + INTERFACES_ELEMENT + " element");
}
}
}
return interfaceNames;
}
private Metadata parseArgumentOrPropertyValue(Element element, ComponentMetadata enclosingComponent) {
Metadata [] values = new Metadata[3];
if (element.hasAttribute(REF_ATTRIBUTE)) {
values[0] = builder.newRef().componentId(element.getAttribute(REF_ATTRIBUTE));
}
if (element.hasAttribute(VALUE_ATTRIBUTE)) {
values[1] = builder.newValue().stringValue(element.getAttribute(VALUE_ATTRIBUTE));
}
NodeList nl = element.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element e = (Element) node;
if (isBlueprintNamespace(node.getNamespaceURI()) && nodeNameEquals(node, DESCRIPTION_ELEMENT)) {
// Ignore description elements
} else {
values[2] = parseValueGroup(e, enclosingComponent, null, true);
break;
}
}
}
Metadata value = null;
for (Metadata v : values) {
if (v != null) {
if (value == null) {
value = v;
} else {
throw new ComponentDefinitionException("Only one of " + REF_ATTRIBUTE + " attribute, " + VALUE_ATTRIBUTE + " attribute or sub element must be set");
}
}
}
if (value == null) {
throw new ComponentDefinitionException("One of " + REF_ATTRIBUTE + " attribute, " + VALUE_ATTRIBUTE + " attribute or sub element must be set");
}
return value;
}
private Metadata parseValueGroup(Element element, ComponentMetadata enclosingComponent, String collectionType, boolean allowNull) {
if (isBlueprintNamespace(element.getNamespaceURI())) {
if (nodeNameEquals(element, BEAN_ELEMENT)) {
return parseBeanMetadata(element, false);
} else if (nodeNameEquals(element, REFERENCE_ELEMENT)) {
return parseReference(element, false);
} else if (nodeNameEquals(element, SERVICE_ELEMENT)) {
return parseService(element, false);
} else if (nodeNameEquals(element, REFERENCE_LIST_ELEMENT) ) {
return parseRefList(element, false);
} else if (nodeNameEquals(element, NULL_ELEMENT) && allowNull) {
return NullMetadata.NULL;
} else if (nodeNameEquals(element, VALUE_ELEMENT)) {
return parseValue(element, collectionType);
} else if (nodeNameEquals(element, REF_ELEMENT)) {
return parseRef(element);
} else if (nodeNameEquals(element, IDREF_ELEMENT)) {
return parseIdRef(element);
} else if (nodeNameEquals(element, LIST_ELEMENT)) {
return parseList(element, enclosingComponent);
} else if (nodeNameEquals(element, SET_ELEMENT)) {
return parseSet(element, enclosingComponent);
} else if (nodeNameEquals(element, MAP_ELEMENT)) {
return parseMap(element, enclosingComponent);
} else if (nodeNameEquals(element, PROPS_ELEMENT)) {
return parseProps(element);
} else if (nodeNameEquals(element, ARRAY_ELEMENT)) {
return parseArray(element, enclosingComponent);
} else {
throw new ComponentDefinitionException("Unknown blueprint element " + element.getNodeName());
}
} else {
return parseCustomElement(element, enclosingComponent);
}
}
private ValueMetadata parseValue(Element element, String collectionType) {
String type;
if (element.hasAttribute(TYPE_ATTRIBUTE)) {
type = element.getAttribute(TYPE_ATTRIBUTE);
} else {
type = collectionType;
}
return builder.newValue().stringValue(getTextValue(element)).type(type);
}
private RefMetadata parseRef(Element element) {
String component = element.getAttribute(COMPONENT_ID_ATTRIBUTE);
if (component == null || component.length() == 0) {
throw new ComponentDefinitionException("Element " + REF_ELEMENT + " must have a valid " + COMPONENT_ID_ATTRIBUTE + " attribute");
}
return builder.newRef().componentId(component);
}
private Metadata parseIdRef(Element element) {
String component = element.getAttribute(COMPONENT_ID_ATTRIBUTE);
if (component == null || component.length() == 0) {
throw new ComponentDefinitionException("Element " + IDREF_ELEMENT + " must have a valid " + COMPONENT_ID_ATTRIBUTE + " attribute");
}
return builder.newIdRef().componentId(component);
}
private int parseActivation(Element element) {
String initialization = element.hasAttribute(ACTIVATION_ATTRIBUTE) ? element.getAttribute(ACTIVATION_ATTRIBUTE) : defaultActivation;
if (ACTIVATION_EAGER.equals(initialization)) {
return ComponentMetadata.ACTIVATION_EAGER;
} else if (ACTIVATION_LAZY.equals(initialization)) {
return ComponentMetadata.ACTIVATION_LAZY;
} else {
throw new ComponentDefinitionException("Attribute " + ACTIVATION_ATTRIBUTE + " must be equal to " + ACTIVATION_EAGER + " or " + ACTIVATION_LAZY);
}
}
private ComponentMetadata handleCustomAttributes(NamedNodeMap attributes, ComponentMetadata enclosingComponent) {
if (attributes != null) {
for (int i = 0; i < attributes.getLength(); i++) {
Node node = attributes.item(i);
//attr is custom if it has a namespace, and it isnt blueprint, or the xmlns ns.
//blueprint ns would be an error, as blueprint attrs are unqualified.
if (node instanceof Attr &&
node.getNamespaceURI() != null &&
!isBlueprintNamespace(node.getNamespaceURI()) &&
!isIgnorableAttributeNamespace(node.getNamespaceURI()) ) {
enclosingComponent = decorateCustomNode(node, enclosingComponent);
}
}
}
return enclosingComponent;
}
private ComponentMetadata handleCustomElements(Element element, ComponentMetadata enclosingComponent) {
NodeList nl = element.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
if (!isBlueprintNamespace(node.getNamespaceURI())) {
enclosingComponent = decorateCustomNode(node, enclosingComponent);
}
}
}
return enclosingComponent;
}
private ComponentMetadata decorateCustomNode(Node node, ComponentMetadata enclosingComponent) {
NamespaceHandler handler = getNamespaceHandler(node);
ParserContextImpl context = new ParserContextImpl(this, registry, enclosingComponent, node);
return handler.decorate(node, enclosingComponent, context);
}
private Metadata parseCustomElement(Element element, ComponentMetadata enclosingComponent) {
NamespaceHandler handler = getNamespaceHandler(element);
ParserContextImpl context = new ParserContextImpl(this, registry, enclosingComponent, element);
return handler.parse(element, context);
}
private NamespaceHandler getNamespaceHandler(Node node) {
URI ns = URI.create(node.getNamespaceURI());
return getNamespaceHandler(ns);
}
private NamespaceHandler getNamespaceHandler(URI uri) {
if (handlers == null) {
throw new ComponentDefinitionException("Unsupported node (namespace handler registry is not set): " + uri);
}
NamespaceHandler handler = this.handlers.getNamespaceHandler(uri);
if (handler == null) {
throw new ComponentDefinitionException("Unsupported node namespace: " + uri);
}
return handler;
}
public String generateId() {
String id;
do {
id = "." + idPrefix + ++idCounter;
} while (ids.contains(id));
ids.add(id);
return id;
}
public String getId(Element element) {
String id;
if (element.hasAttribute(ID_ATTRIBUTE)) {
id = element.getAttribute(ID_ATTRIBUTE);
ids.add(id);
} else {
id = generateId();
}
return id;
}
public static boolean isBlueprintNamespace(String ns) {
return BLUEPRINT_NAMESPACE.equals(ns);
}
/**
* Test if this namespace uri does not require a Namespace Handler.<p>
* <li> XMLConstants.RELAXNG_NS_URI
* <li> XMLConstants.W3C_XML_SCHEMA_INSTANCE_NS_URI
* <li> XMLConstants.W3C_XML_SCHEMA_NS_URI
* <li> XMLConstants.W3C_XPATH_DATATYPE_NS_URI
* <li> XMLConstants.W3C_XPATH_DATATYPE_NS_URI
* <li> XMLConstants.XML_DTD_NS_URI
* <li> XMLConstants.XML_NS_URI
* <li> XMLConstants.XMLNS_ATTRIBUTE_NS_URI
* @param ns URI to be tested.
* @return true if the uri does not require a namespace handler.
*/
public static boolean isIgnorableAttributeNamespace(String ns) {
return XMLConstants.RELAXNG_NS_URI.equals(ns) ||
XMLConstants.W3C_XML_SCHEMA_INSTANCE_NS_URI.equals(ns) ||
XMLConstants.W3C_XML_SCHEMA_NS_URI.equals(ns) ||
XMLConstants.W3C_XPATH_DATATYPE_NS_URI.equals(ns) ||
XMLConstants.W3C_XPATH_DATATYPE_NS_URI.equals(ns) ||
XMLConstants.XML_DTD_NS_URI.equals(ns) ||
XMLConstants.XML_NS_URI.equals(ns) ||
XMLConstants.XMLNS_ATTRIBUTE_NS_URI.equals(ns);
}
private static boolean nodeNameEquals(Node node, String name) {
return (name.equals(node.getNodeName()) || name.equals(node.getLocalName()));
}
private static List<String> parseList(String list) {
String[] items = list.split(" ");
List<String> set = new ArrayList<String>();
for (String item : items) {
item = item.trim();
if (item.length() > 0) {
set.add(item);
}
}
return set;
}
private static String getTextValue(Element element) {
StringBuffer value = new StringBuffer();
NodeList nl = element.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node item = nl.item(i);
if ((item instanceof CharacterData && !(item instanceof Comment)) || item instanceof EntityReference) {
value.append(item.getNodeValue());
}
}
return value.toString();
}
private static DocumentBuilderFactory getDocumentBuilderFactory() {
if (documentBuilderFactory == null) {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setNamespaceAware(true);
documentBuilderFactory = dbf;
}
return documentBuilderFactory;
}
}