| /* |
| * 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.components.modules.input; |
| |
| import java.util.Iterator; |
| import java.util.Map; |
| |
| import org.apache.avalon.framework.component.ComponentException; |
| import org.apache.avalon.framework.component.ComponentManager; |
| import org.apache.avalon.framework.component.ComponentSelector; |
| import org.apache.avalon.framework.component.Composable; |
| import org.apache.avalon.framework.configuration.Configuration; |
| import org.apache.avalon.framework.configuration.ConfigurationException; |
| import org.apache.avalon.framework.thread.ThreadSafe; |
| |
| /** |
| * AbstractMetaModule gives you the infrastructure for easily |
| * deploying more "meta" InputModules i.e. InputModules that are |
| * composed of other InputModules. In order to get at the Logger, use |
| * getLogger(). |
| * |
| * @author <a href="mailto:haul@apache.org">Christian Haul</a> |
| * @author <a href="mailto:jefft@apache.org">Jeff Turner</a> |
| * @version CVS $Id$ |
| */ |
| public abstract class AbstractMetaModule extends AbstractInputModule |
| implements Composable { |
| |
| /** The component manager instance */ |
| protected ComponentManager manager; |
| |
| /** The cached InputModule-Selector */ |
| protected ComponentSelector inputSelector = null; |
| |
| /** The cached default InputModule */ |
| protected InputModule input = null; |
| |
| /** The default InputModule name / shorthand. Defaults to 'request-param' */ |
| protected String defaultInput = "request-param"; // default to request parameters |
| |
| /** The default InputModule configuration */ |
| protected Configuration inputConf = null; // will become an empty configuration object |
| // during configure() so why bother here... |
| |
| /** Is this instance initialized? */ |
| protected boolean initialized = false; |
| |
| /* Constants */ |
| |
| protected final static String INPUT_MODULE_SELECTOR = InputModule.ROLE+"Selector"; |
| |
| /* Operation codes */ |
| private final static int OP_GET = 0; |
| private final static int OP_VALUES = 1; |
| private final static int OP_NAMES = 2; |
| private final static String[] OPNAME = new String[] {"GET_VALUE", "GET_VALUES", "GET_NAMES"}; |
| |
| |
| /** |
| * Set the current <code>ComponentManager</code> instance used by this |
| * <code>Composable</code>. |
| */ |
| public void compose(ComponentManager manager) throws ComponentException { |
| |
| this.manager=manager; |
| } |
| |
| |
| /** |
| * Initialize the meta module with exactly one other input |
| * module. Since "meta" modules require references to components |
| * of the same role, initialization cannot be done in initialize() |
| * when also implementing ThreadSafe since at that point the |
| * component selector is not yet initialized it would trigger the |
| * creation of a new one resulting in an endless loop of |
| * initializations. Therefore, every module needs to call this |
| * method when it first requires access to another module if the |
| * module itself has not been initialized. Override this method |
| * and dispose() to keep references to more than one module. |
| */ |
| public synchronized void lazy_initialize() { |
| |
| try { |
| // obtain input modules |
| if (!this.initialized) { |
| this.inputSelector=(ComponentSelector) this.manager.lookup(INPUT_MODULE_SELECTOR); |
| if (this.inputSelector != null && this.inputSelector instanceof ThreadSafe) { |
| |
| if (this.defaultInput != null) { |
| this.input = obtainModule(this.defaultInput); |
| } |
| |
| } else if (!(this.inputSelector instanceof ThreadSafe) ) { |
| this.manager.release(this.inputSelector); |
| this.inputSelector = null; |
| } |
| |
| this.initialized = true; |
| } |
| } catch (Exception e) { |
| if (getLogger().isWarnEnabled()) |
| getLogger().error("A problem occurred setting up input modules :'" + e.getMessage(), e); |
| } |
| } |
| |
| |
| /** |
| * Dispose exactly one cached InputModule. To work on more than |
| * one, override this method and initialize(). |
| */ |
| public void dispose() { |
| |
| if (this.inputSelector != null) { |
| if (this.input != null) |
| this.inputSelector.release(this.input); |
| this.manager.release(this.inputSelector); |
| } |
| } |
| |
| |
| /** |
| * Obtain a permanent reference to an InputModule. |
| */ |
| protected InputModule obtainModule(String type) { |
| ComponentSelector inputSelector = this.inputSelector; |
| InputModule module = null; |
| try { |
| if (inputSelector == null) { |
| inputSelector=(ComponentSelector) this.manager.lookup(INPUT_MODULE_SELECTOR); |
| } |
| if (inputSelector.hasComponent(type)) { |
| if (type != null && inputSelector.hasComponent(type)) { |
| module = (InputModule) inputSelector.select(type); |
| } |
| if (!(module instanceof ThreadSafe) ) { |
| inputSelector.release(module); |
| module = null; |
| } |
| } |
| if (type != null && module == null) |
| if (getLogger().isWarnEnabled()) |
| getLogger().warn("A problem occurred setting up '" + type |
| + "': Selector is not null, Component is " |
| + (inputSelector.hasComponent(type)? "known" : "unknown")); |
| |
| } catch (ComponentException ce) { |
| if (getLogger().isWarnEnabled()) |
| getLogger().warn("Could not obtain selector for InputModules: "+ce.getMessage()); |
| } finally { |
| if (this.inputSelector == null) |
| this.manager.release(inputSelector); |
| // FIXME: Is it OK to keep a reference to the module when we release the selector? |
| } |
| |
| return module; |
| } |
| |
| |
| /** |
| * release a permanent reference to an InputModule. |
| */ |
| protected void releaseModule(InputModule module) { |
| ComponentSelector inputSelector = this.inputSelector; |
| if (module != null) { |
| try { |
| // FIXME: Is it OK to release a module when we have released the selector before? |
| if (inputSelector == null) |
| inputSelector=(ComponentSelector) this.manager.lookup(INPUT_MODULE_SELECTOR); |
| |
| inputSelector.release(module); |
| module = null; |
| |
| } catch (ComponentException ce) { |
| if (getLogger().isWarnEnabled()) |
| getLogger().warn("Could not obtain selector for InputModules: "+ce.getMessage()); |
| } finally { |
| if (this.inputSelector == null) |
| this.manager.release(inputSelector); |
| } |
| } |
| } |
| |
| /** |
| * Get names of available attributes in the specified (usually statically |
| * assigned) Input Module. |
| * @see InputModule#getAttributeNames(Configuration, Map) |
| */ |
| protected Iterator getNames(Map objectModel, |
| InputModule staticMod, String staticModName, Configuration staticModConf) |
| throws ConfigurationException { |
| |
| return (Iterator) this.get(OP_NAMES, null, objectModel, staticMod, staticModName, staticModConf, null, null, null); |
| } |
| |
| /** |
| * Get names of available attributes in one of the specified Input Modules |
| * (static or dynamic, dynamic preferred). Dynamic IM may be |
| * <code>null</code>. |
| * @see InputModule#getAttributeNames(Configuration, Map) |
| */ |
| protected Iterator getNames(Map objectModel, |
| InputModule staticMod, String staticModName, Configuration staticModConf, |
| InputModule dynamicMod, String dynamicModName, Configuration dynamicModConf) |
| throws ConfigurationException { |
| |
| return (Iterator) this.get(OP_NAMES, null, objectModel, staticMod, staticModName, staticModConf, dynamicMod, dynamicModName, dynamicModConf); |
| } |
| |
| protected Object getValue(String attr, Map objectModel, ModuleHolder holder) throws ConfigurationException{ |
| return this.getValue(attr, objectModel, holder.input, holder.name, holder.config); |
| } |
| |
| protected Object getValue(String attr, Map objectModel, ModuleHolder staticHolder, ModuleHolder dynamicHolder) throws ConfigurationException{ |
| return this.getValue(attr, objectModel, staticHolder.input, staticHolder.name, dynamicHolder.config); |
| } |
| |
| protected Object[] getValues(String attr, Map objectModel, ModuleHolder holder) throws ConfigurationException{ |
| return this.getValues(attr, objectModel, holder.input, holder.name, holder.config); |
| } |
| |
| protected Object[] getValues(String attr, Map objectModel, ModuleHolder staticHolder, ModuleHolder dynamicHolder) throws ConfigurationException{ |
| return this.getValues(attr, objectModel, staticHolder.input, staticHolder.name, dynamicHolder.config); |
| } |
| |
| /** |
| * Get an attribute's value from a (usually statically assigned) Input |
| * Module. |
| * @see InputModule#getAttribute(String, Configuration, Map) |
| */ |
| protected Object getValue(String attr, Map objectModel, |
| InputModule staticMod, String staticModName, Configuration staticModConf) |
| throws ConfigurationException { |
| |
| return this.get(OP_GET, attr, objectModel, staticMod, staticModName, staticModConf, null, null, null); |
| } |
| |
| |
| /** |
| * Get attribute's value in one of the specified Input Modules |
| * (static or dynamic, dynamic preferred). Dynamic IM may be |
| * <code>null</code>. |
| * @see InputModule#getAttribute(String, Configuration, Map) |
| */ |
| protected Object getValue(String attr, Map objectModel, |
| InputModule staticMod, String staticModName, Configuration staticModConf, |
| InputModule dynamicMod, String dynamicModName, Configuration dynamicModConf) |
| throws ConfigurationException { |
| |
| return this.get(OP_GET, attr, objectModel, staticMod, staticModName, staticModConf, dynamicMod, dynamicModName, dynamicModConf); |
| } |
| |
| /** |
| * Get an attribute's values from a (usually statically assigned) Input |
| * Module. |
| * @see InputModule#getAttributeValues(String, Configuration, Map) |
| */ |
| protected Object[] getValues(String attr, Map objectModel, |
| InputModule staticMod, String staticModName, Configuration staticModConf) |
| throws ConfigurationException { |
| |
| return (Object[]) this.get(OP_VALUES, attr, objectModel, staticMod, staticModName, staticModConf, null, null, null); |
| } |
| |
| /** |
| * Get attribute's values in one of the specified Input Modules |
| * (static or dynamic, dynamic preferred). Dynamic IM may be |
| * <code>null</code>. |
| * @see InputModule#getAttributeValues(String, Configuration, Map) |
| */ |
| protected Object[] getValues(String attr, Map objectModel, |
| InputModule staticMod, String staticModName, Configuration staticModConf, |
| InputModule dynamicMod, String dynamicModName, Configuration dynamicModConf) |
| throws ConfigurationException { |
| |
| return (Object[]) this.get(OP_VALUES, attr, objectModel, staticMod, staticModName, staticModConf, dynamicMod, dynamicModName, dynamicModConf); |
| } |
| |
| |
| /** |
| * Encapsulates use of an InputModule. Does all the lookups and so on. |
| * The second module (dynamic) is preferred if it has an non null name. If |
| * an exception is encountered, a warn message is printed and null is |
| * returned. |
| * @param op Operation to perform ({@link #OP_GET}, {@link #OP_NAMES}, {@link #OP_VALUES}). |
| * |
| * @return Either an Object, an Object[], or an Iterator, depending on <code>op</code> param. |
| */ |
| private Object get(int op, String attr, Map objectModel, |
| InputModule staticMod, String staticModName, Configuration staticModConf, |
| InputModule dynamicMod, String dynamicModName, Configuration dynamicModConf) |
| throws ConfigurationException { |
| |
| ComponentSelector cs = this.inputSelector; |
| Object value = null; |
| String name = null; |
| InputModule input = null; |
| Configuration conf = null; |
| boolean release = false; |
| |
| try { |
| if (cs == null) { |
| try { |
| cs = (ComponentSelector) this.manager.lookup(INPUT_MODULE_SELECTOR); |
| } catch (ComponentException e) { |
| throw new ConfigurationException("Could not find MetaModule's module selector", e); |
| } |
| } |
| |
| boolean useDynamic; |
| if (dynamicMod == null && dynamicModName == null) { |
| useDynamic = false; |
| input = staticMod; |
| name = staticModName; |
| conf = staticModConf; |
| } else { |
| useDynamic = true; |
| input = dynamicMod; |
| name = dynamicModName; |
| conf = dynamicModConf; |
| } |
| |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("MetaModule performing op "+OPNAME[op]+" on " + |
| (useDynamic?"dynamically":"statically") + " " + |
| (input==null?"created":"assigned") + |
| " module '"+name+"', using config "+dynamicModConf); |
| } |
| |
| if (input == null) { |
| if (cs.hasComponent(name)) { |
| release = true; |
| try { |
| input = (InputModule) cs.select(name); |
| } catch (ComponentException e) { |
| throw new ConfigurationException( |
| "MetaModule unable to create "+ |
| (useDynamic ? "dynamically" : "statically")+ |
| " specified internal module '"+name+"'", e); |
| } |
| } else { |
| throw new ConfigurationException("MetaModule: No such InputModule: "+name); |
| } |
| } |
| |
| switch (op) { |
| case OP_GET: |
| value = input.getAttribute(attr, conf, objectModel); |
| break; |
| case OP_VALUES: |
| value = input.getAttributeValues(attr, conf, objectModel); |
| break; |
| case OP_NAMES: |
| value = input.getAttributeNames(conf, objectModel); |
| break; |
| } |
| |
| if (getLogger().isDebugEnabled()) |
| getLogger().debug("using "+name+" as "+input+" for "+op+" ("+attr+") and "+conf+" gives "+value); |
| |
| } finally { |
| if (release) |
| cs.release(input); |
| |
| if (this.inputSelector == null) |
| this.manager.release(cs); |
| } |
| |
| return value; |
| } |
| |
| } |
