/*
* 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.cocoon.forms.binding;
import java.util.ArrayList;
import java.util.Stack;
import org.apache.avalon.framework.activity.Disposable;
import org.apache.avalon.framework.activity.Initializable;
import org.apache.avalon.framework.configuration.Configurable;
import org.apache.avalon.framework.configuration.Configuration;
import org.apache.avalon.framework.configuration.ConfigurationException;
import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.logger.AbstractLogEnabled;
import org.apache.avalon.framework.logger.Logger;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.avalon.framework.service.Serviceable;
import org.apache.avalon.framework.thread.ThreadSafe;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceResolver;
import org.apache.cocoon.components.LifecycleHelper;
import org.apache.cocoon.forms.CacheManager;
import org.apache.cocoon.forms.binding.library.Library;
import org.apache.cocoon.forms.binding.library.LibraryException;
import org.apache.cocoon.forms.binding.library.LibraryManager;
import org.apache.cocoon.forms.binding.library.LibraryManagerImpl;
import org.apache.cocoon.forms.datatype.DatatypeManager;
import org.apache.cocoon.forms.util.DomHelper;
import org.apache.cocoon.forms.util.SimpleServiceSelector;
import org.apache.cocoon.util.location.LocationAttributes;
import org.apache.commons.lang.exception.NestableRuntimeException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.xml.sax.InputSource;
/**
* JXPathBindingManager provides an implementation of {@link BindingManager}by
* usage of the <a href="http://jakarta.apache.org/commons/jxpath/index.html">
* JXPath package </a>.
*
* @version $Id$
*/
public class JXPathBindingManager extends AbstractLogEnabled
implements BindingManager, Contextualizable, Serviceable,
Configurable, Initializable, Disposable, ThreadSafe {
private static final String PREFIX = "CocoonFormBinding:";
protected ServiceManager manager;
protected DatatypeManager datatypeManager;
private Configuration configuration;
protected SimpleServiceSelector bindingBuilderSelector;
private CacheManager cacheManager;
private Context avalonContext;
protected LibraryManagerImpl libraryManager;
/**
* Java 1.3 logger access method.
* <br>
* Access to {#getLogger} from inner class on Java 1.3 causes NoSuchMethod error.
*/
protected Logger getMyLogger() {
return getLogger();
}
public void contextualize(Context context) throws ContextException {
this.avalonContext = context;
}
public void service(ServiceManager manager) throws ServiceException {
this.manager = manager;
this.datatypeManager = (DatatypeManager) manager.lookup(DatatypeManager.ROLE);
this.cacheManager = (CacheManager) manager.lookup(CacheManager.ROLE);
}
public void configure(Configuration configuration)
throws ConfigurationException {
this.configuration = configuration;
}
public void initialize() throws Exception {
bindingBuilderSelector = new SimpleServiceSelector("binding", JXPathBindingBuilderBase.class);
LifecycleHelper.setupComponent(bindingBuilderSelector,
getLogger(),
this.avalonContext,
this.manager,
configuration.getChild("bindings"));
libraryManager = new LibraryManagerImpl();
libraryManager.setBindingManager(this);
LifecycleHelper.setupComponent(libraryManager,
getLogger(),
this.avalonContext,
this.manager,
configuration.getChild("library"));
}
public Binding createBinding(Source source) throws BindingException {
Binding binding = (Binding) this.cacheManager.get(source, PREFIX);
if (binding != null && !binding.isValid()) {
binding = null; //invalidate
}
if (binding == null) {
try {
// Retrieve the input source of the binding file
InputSource is = new InputSource(source.getInputStream());
is.setSystemId(source.getURI());
Document doc = DomHelper.parse(is, this.manager);
binding = createBinding(doc.getDocumentElement());
this.cacheManager.set(binding, source, PREFIX);
} catch (BindingException e) {
throw e;
} catch (Exception e) {
throw new BindingException("Error creating binding from " + source.getURI(), e);
}
}
return binding;
}
public Binding createBinding(String bindingURI) throws BindingException {
SourceResolver sourceResolver = null;
Source source = null;
try {
try {
sourceResolver = (SourceResolver) manager.lookup(SourceResolver.ROLE);
source = sourceResolver.resolveURI(bindingURI);
} catch (Exception e) {
throw new BindingException("Error resolving binding source: " + bindingURI);
}
return createBinding(source);
} finally {
if (source != null) {
sourceResolver.release(source);
}
if (sourceResolver != null) {
manager.release(sourceResolver);
}
}
}
public Binding createBinding(Element bindingElement) throws BindingException {
Binding binding = null;
if (BindingManager.NAMESPACE.equals(bindingElement.getNamespaceURI())) {
binding = getBuilderAssistant().getBindingForConfigurationElement(bindingElement);
((JXPathBindingBase) binding).enableLogging(getLogger());
if (getLogger().isDebugEnabled()) {
getLogger().debug("Creation of new binding finished. " + binding);
}
} else {
if (getLogger().isDebugEnabled()) {
getLogger().debug("Root Element of said binding file is in wrong namespace.");
}
}
return binding;
}
public Assistant getBuilderAssistant() {
return new Assistant();
}
public void dispose() {
if (this.bindingBuilderSelector != null) {
this.bindingBuilderSelector.dispose();
this.bindingBuilderSelector = null;
}
this.manager.release(this.datatypeManager);
this.datatypeManager = null;
this.manager.release(this.cacheManager);
this.cacheManager = null;
this.manager = null;
}
/**
* Assistant Inner class discloses enough features to the created
* childBindings to recursively
*
* This patterns was chosen to prevent Inversion Of Control between this
* factory and its builder classes (that could be provided by third
* parties.)
*/
public class Assistant {
private BindingBuilderContext context = new BindingBuilderContext();
private Stack contextStack = new Stack();
private JXPathBindingBuilderBase getBindingBuilder(String bindingType)
throws BindingException {
try {
return (JXPathBindingBuilderBase) bindingBuilderSelector.select(bindingType);
} catch (ServiceException e) {
throw new BindingException("Cannot handle binding element '" + bindingType + "'.", e);
}
}
/**
* Creates a {@link Binding} following the specification in the
* provided config element.
*/
public JXPathBindingBase getBindingForConfigurationElement(Element configElm)
throws BindingException {
String bindingType = configElm.getLocalName();
JXPathBindingBuilderBase bindingBuilder = getBindingBuilder(bindingType);
boolean flag = false;
if (context.getLocalLibrary() == null) {
// FIXME Use newLibrary()?
Library lib = new Library(libraryManager, getBuilderAssistant());
lib.enableLogging(getMyLogger());
context.setLocalLibrary(lib);
lib.setSourceURI(LocationAttributes.getURI(configElm));
flag = true;
}
if (context.getLocalLibrary() != null && configElm.hasAttribute("extends")) {
try {
context.setSuperBinding(context.getLocalLibrary().getBinding(configElm.getAttribute("extends")));
} catch (LibraryException e) {
// throw new RuntimeException("Error extending binding! (at "+DomHelper.getLocation(configElm)+")", e);
throw new NestableRuntimeException("Error extending binding! (at " + DomHelper.getLocation(configElm) + ")", e);
}
} else {
context.setSuperBinding(null);
}
JXPathBindingBase childBinding = bindingBuilder.buildBinding(configElm, this);
if (flag && childBinding != null) {
childBinding.setEnclosingLibrary(context.getLocalLibrary());
}
// this might get called unnecessarily, but solves issues with the libraries
if (childBinding != null) {
childBinding.enableLogging(getMyLogger());
}
return childBinding;
}
private JXPathBindingBase[] mergeBindings(JXPathBindingBase[] existing, JXPathBindingBase[] extra) {
if (existing == null || existing.length == 0) {
return extra;
}
if (extra == null || extra.length == 0) {
return existing;
}
// have to do it the stupid painter way..
ArrayList list = new ArrayList(existing.length);
for (int i = 0; i < existing.length; i++) {
list.add(existing[i]);
}
for (int i = 0; i < extra.length; i++) {
if (extra[i].getId() == null) {
list.add(extra[i]);
} else {
// try to replace existing one
boolean match = false;
for(int j=0; j<list.size(); j++) {
if(extra[i].getId().equals(((JXPathBindingBase)list.get(j)).getId())) {
list.set(j,extra[i]);
match = true;
break; // stop searching
}
}
// if no match, just add
if (!match) {
list.add(extra[i]);
}
}
}
return (JXPathBindingBase[])list.toArray(new JXPathBindingBase[list.size()]);
}
/**
* proxy for compatibility
*
*/
public JXPathBindingBase[] makeChildBindings(Element parentElement) throws BindingException {
return makeChildBindings(parentElement,new JXPathBindingBase[0]);
}
/**
* Makes an array of childBindings for the child-elements of the
* provided configuration element.
*/
public JXPathBindingBase[] makeChildBindings(Element parentElement, JXPathBindingBase[] existingBindings)
throws BindingException {
if (existingBindings == null) {
existingBindings = new JXPathBindingBase[0];
}
if (parentElement != null) {
Element[] childElements = DomHelper.getChildElements(
parentElement, BindingManager.NAMESPACE);
if (childElements.length > 0) {
JXPathBindingBase[] childBindings = new JXPathBindingBase[childElements.length];
for (int i = 0; i < childElements.length; i++) {
pushContext();
context.setSuperBinding(null);
String id = DomHelper.getAttribute(childElements[i], "id", null);
String path = DomHelper.getAttribute(childElements[i], "path", null);
if (context.getLocalLibrary() != null && childElements[i].getAttribute("extends") != null) {
try {
context.setSuperBinding(context.getLocalLibrary().getBinding(childElements[i].getAttribute("extends")));
if (context.getSuperBinding() == null) {
// not found in library
context.setSuperBinding(getBindingByIdOrPath(id, path, existingBindings));
}
} catch (LibraryException e) {
throw new BindingException("Error extending binding! (at "+DomHelper.getLocation(childElements[i])+")",e);
}
}
childBindings[i] = getBindingForConfigurationElement(childElements[i]);
popContext();
}
return mergeBindings(existingBindings,childBindings);
}
}
return existingBindings;
}
private JXPathBindingBase getBindingByIdOrPath(String id, String path, JXPathBindingBase[] bindings) {
String name = id;
if (name == null) {
name = "Context:"+path;
}
for (int i = 0; i < bindings.length; i++) {
if (name.equals(bindings[i].getId())) {
return bindings[i];
}
}
return null;
}
public DatatypeManager getDatatypeManager() {
return datatypeManager;
}
public ServiceManager getServiceManager() {
return manager;
}
public LibraryManager getLibraryManager() {
return libraryManager;
}
public BindingBuilderContext getContext() {
return this.context;
}
private void pushContext() {
BindingBuilderContext c = new BindingBuilderContext(context);
contextStack.push(context);
context = c;
}
private void popContext() {
if (!contextStack.empty()) {
context = (BindingBuilderContext) contextStack.pop();
} else {
context = new BindingBuilderContext();
}
}
}
}