Examples of org.apache.avalon.framework.component.ComponentSelector

Package org.apache.avalon.framework.component

Examples of org.apache.avalon.framework.component.ComponentSelector

org.apache.avalon.framework.component.ComponentSelector
A ComponentSelector selects Components based on a hint. The contract is that all the Components implement the same role.
A role is better understood by the analogy of a play. There are many different roles in a script. Any actor or actress can play any given part and you get the same results (phrases said, movements made, etc.). The exact nuances of the performance is different.

Below is a list of things that might be considered the same role:
- XMLInputAdapter and PropertyInputAdapter
- FileGenerator and SQLGenerator
The ComponentSelector does not specify the methodology of getting the Component, merely the interface used to get it. Therefore the ComponentSelector can be implemented with a factory pattern, an object pool, or a simple Hashtable.

Deprecated: Use {@link org.apache.avalon.framework.service.ServiceSelector} instead.
@see org.apache.avalon.framework.component.Component @see org.apache.avalon.framework.component.Composable @see org.apache.avalon.framework.component.ComponentManager @author Avalon Development Team @version CVS $Revision: 1.21 $ $Date: 2004/02/11 14:34:24 $


    /**
     * 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 "+(inputSelector!=null?"not ":"")
                                     +"null, Component is "
                                     +(inputSelector!=null && inputSelector.hasComponent(type)?"known":"unknown"));
            
        } catch (ComponentException ce) {
            if (getLogger().isWarnEnabled())
                getLogger().warn("Could not obtain selector for InputModules: "+ce.getMessage());
        } finally {

View Full Code Here


    /**
     * 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());

View Full Code Here

    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 {
                    if (getLogger().isWarnEnabled())
                        getLogger().warn("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);
        }

View Full Code Here

        // general setup
        String parameterName = param.getParameter("parameter-name",this.defaultParameterName);
        boolean useGetValues = param.getParameterAsBoolean("use-getValues",this.useGetValues);
        InputModule input = null;
        OutputModule output = null;
        ComponentSelector inputSelector = null;
        ComponentSelector outputSelector = null;


        try {
            if (getLogger().isDebugEnabled()) getLogger().debug("start...");
            // obtain input and output components
            inputSelector=(ComponentSelector) this.manager.lookup(INPUT_MODULE_SELECTOR); 
            if (inputName != null && inputSelector != null && inputSelector.hasComponent(inputName)){
                input = (InputModule) inputSelector.select(inputName);
            }
            outputSelector=(ComponentSelector) this.manager.lookup(OUTPUT_MODULE_SELECTOR); 
            if (outputName != null && outputSelector != null && outputSelector.hasComponent(outputName)){
                output = (OutputModule) outputSelector.select(outputName);
            }




            if (input != null  && output != null) {
                if (getLogger().isDebugEnabled()) getLogger().debug("got input and output modules");
                // do something


                if (parameterName == null) {
                    if (getLogger().isDebugEnabled()) getLogger().debug("reading all parameter values");
                    // for a test, read all parameters from input and write them to outout
                    // get names first, then (one) value per name
                    Iterator iter = input.getAttributeNames(this.inputConf,objectModel);
                    while (iter.hasNext()) {
                        parameterName = (String) iter.next();
                        Object value = input.getAttribute(parameterName, this.inputConf, objectModel);
                        output.setAttribute(this.outputConf, objectModel, parameterName, value);
                        
                        if (getLogger().isDebugEnabled()) 
                            getLogger().debug("["+parameterName+"] = ["+value+"]");
                    }
                        // ------------------------------------------------------------------------
                } else {


                    if (useGetValues) {
                        // get all existing values
                        Object[] value = input.getAttributeValues(parameterName, this.inputConf, objectModel);
                        output.setAttribute(this.outputConf, objectModel, parameterName, value);
                        
                        if (getLogger().isDebugEnabled()) 
                            for (int i=0; i<value.length; i++)
                                getLogger().debug("["+parameterName+"["+i+"]] = ["+value[i]+"]");
                        // ------------------------------------------------------------------------


                    } else {
                        // get just one parameter value
                        if (getLogger().isDebugEnabled()) 
                            getLogger().debug("reading parameter values for "+parameterName);
                        
                        Object value = input.getAttribute(parameterName, this.inputConf, objectModel);
                        output.setAttribute(this.outputConf, objectModel, parameterName, value);
                        
                        if (getLogger().isDebugEnabled()) getLogger().debug("["+parameterName+"] = ["+value+"]");
                        // ------------------------------------------------------------------------
                    }
                }
                output.commit(this.outputConf,objectModel);
                if (getLogger().isDebugEnabled()) getLogger().debug("done commit");
                // done
            }




        } catch (Exception e) {
            throw e;
        } finally {
            // release components
            if (getLogger().isDebugEnabled()) getLogger().debug("releasing components");
            if (outputSelector != null) {
                if (output != null) 
                    outputSelector.release(output);
                this.manager.release(outputSelector);
            }
            if (inputSelector != null) {
                if (input != null)
                    inputSelector.release(input);

View Full Code Here

     * @param pattern Pattern for the matcher.
     * @param parameters Matcher parameters.
     */
    public final Map match(String type, String pattern, Parameters parameters) throws PatternException {


        ComponentSelector selector = null;
        Matcher matcher = null;
        SourceResolver resolver = null;


        Map result = null;
        try {
            selector = (ComponentSelector) this.manager.lookup(Matcher.ROLE +
                "Selector");
            assertNotNull("Test lookup of matcher selector", selector);


            resolver = (SourceResolver) this.manager.lookup(SourceResolver.ROLE);
            assertNotNull("Test lookup of source resolver", resolver);


            assertNotNull("Test if matcher name is not null", type);
            matcher = (Matcher) selector.select(type);
            assertNotNull("Test lookup of matcher", matcher);


            result = matcher.match(pattern, objectmodel, parameters);


        } catch (ComponentException ce) {
            getLogger().error("Could not retrieve matcher", ce);
            fail("Could not retrieve matcher: " + ce.toString());
        } finally {
            if (matcher != null) {
                selector.release(matcher);
            }
            this.manager.release(selector);
            this.manager.release(resolver);
        }
        return result;

View Full Code Here

     * @param source Source for the action.
     * @param parameters Action parameters.
     */
    public final Map act(String type, String source, Parameters parameters) throws Exception {


        ComponentSelector selector = null;
        Action action = null;
        SourceResolver resolver = null;


        Map result = null;
        try {
            selector = (ComponentSelector) this.manager.lookup(Action.ROLE +
                "Selector");
            assertNotNull("Test lookup of action selector", selector);


            resolver = (SourceResolver) this.manager.lookup(SourceResolver.ROLE);
            assertNotNull("Test lookup of source resolver", resolver);


            assertNotNull("Test if action name is not null", type);
            action = (Action) selector.select(type);
            assertNotNull("Test lookup of action", action);


            result = action.act(redirector, new SourceResolverAdapter(resolver, this.manager),
                                objectmodel, source, parameters);


        } catch (ComponentException ce) {
            getLogger().error("Could not retrieve action", ce);
            fail("Could not retrieve action: " + ce.toString());
        } finally {
            if (action != null) {
                selector.release(action);
            }
            this.manager.release(selector);
            this.manager.release(resolver);
        }
        return result;

View Full Code Here

     * @param parameters Generator parameters.
     */
    public final Document generate(String type, String source, Parameters parameters) 
        throws IOException, SAXException, ProcessingException {


        ComponentSelector selector = null;
        Generator generator = null;
        SourceResolver resolver = null;
        SAXParser parser = null;


        Document document = null;
        try {
            selector = (ComponentSelector) this.manager.lookup(Generator.ROLE +
                "Selector");
            assertNotNull("Test lookup of generator selector", selector);


            resolver = (SourceResolver) this.manager.lookup(SourceResolver.ROLE);
            assertNotNull("Test lookup of source resolver", resolver);


            parser = (SAXParser) this.manager.lookup(SAXParser.ROLE);
            assertNotNull("Test lookup of parser", parser);


            assertNotNull("Test if generator name is not null", type);


            generator = (Generator) selector.select(type);
            assertNotNull("Test lookup of generator", generator);


            generator.setup(new SourceResolverAdapter(resolver, this.manager),
                            objectmodel, source, parameters);


            DOMBuilder builder = new DOMBuilder();
            generator.setConsumer(new WhitespaceFilter(builder));


            generator.generate();


            document = builder.getDocument();


            assertNotNull("Test for generator document", document);


        } catch (ComponentException ce) {
            getLogger().error("Could not retrieve generator", ce);
            fail("Could not retrieve generator: " + ce.toString());
        } finally {
            if (generator != null) {
                selector.release(generator);
            }
            this.manager.release(selector);
            this.manager.release(resolver);
            this.manager.release((Component) parser);
        }

View Full Code Here

     * @param input Input document.
     */ 
    public final Document transform(String type, String source, Parameters parameters, Document input) 
        throws SAXException, ProcessingException, IOException {


        ComponentSelector selector = null;
        Transformer transformer = null;
        SourceResolver resolver = null;
        SAXParser parser = null;
        Source inputsource = null;


        assertNotNull("Test for component manager", this.manager);


        Document document = null;
        try {
            selector = (ComponentSelector) this.manager.lookup(Transformer.ROLE+
                "Selector");
            assertNotNull("Test lookup of transformer selector", selector);


            resolver = (SourceResolver) this.manager.lookup(SourceResolver.ROLE);
            assertNotNull("Test lookup of source resolver", resolver);


            parser = (SAXParser) this.manager.lookup(SAXParser.ROLE);
            assertNotNull("Test lookup of parser", parser);




            assertNotNull("Test if transformer name is not null", type);
            transformer = (Transformer) selector.select(type);
            assertNotNull("Test lookup of transformer", transformer);


            transformer.setup(new SourceResolverAdapter(resolver, this.manager),
                                  objectmodel, source, parameters);


            DOMBuilder builder = new DOMBuilder();
            transformer.setConsumer(new WhitespaceFilter(builder));


            assertNotNull("Test if input document is not null", input);
            DOMStreamer streamer = new DOMStreamer(transformer);
            streamer.stream(input);


            document = builder.getDocument();
            assertNotNull("Test for transformer document", document);


        } catch (ComponentException ce) {
            getLogger().error("Could not retrieve transformer", ce);
            ce.printStackTrace();
            fail("Could not retrieve transformer:"+ce.toString());
        } finally {
            if (transformer!=null)
                selector.release(transformer);


            if (selector!=null)
                this.manager.release(selector);


            if (inputsource!=null)

View Full Code Here

     * @return Serialized data.
     */
    public final byte[] serialize(String type, Parameters parameters,
                                  Document input) throws SAXException, IOException{


        ComponentSelector selector = null;
        Serializer serializer = null;
        SourceResolver resolver = null;
        Source inputsource = null;


        assertNotNull("Test for component manager", this.manager);


        ByteArrayOutputStream document = null;


        try {
            selector = (ComponentSelector) this.manager.lookup(Serializer.ROLE+
                "Selector");
            assertNotNull("Test lookup of serializer selector", selector);


            resolver = (SourceResolver) this.manager.lookup(SourceResolver.ROLE);
            assertNotNull("Test lookup of source resolver", resolver);


            assertNotNull("Test if serializer name is not null", type);
            serializer = (Serializer) selector.select(type);
            assertNotNull("Test lookup of serializer", serializer);


            document = new ByteArrayOutputStream();
            serializer.setOutputStream(document);


            assertNotNull("Test if input document is not null", input);
            DOMStreamer streamer = new DOMStreamer(serializer);


            streamer.stream(input);
        } catch (ComponentException ce) {
            getLogger().error("Could not retrieve serializer", ce);
            fail("Could not retrieve serializer:"+ce.toString());
        } finally {
            if (serializer!=null) {
                selector.release(serializer);
            }


            if (selector!=null) {
                this.manager.release(selector);
            }

View Full Code Here

     * exist in this source's component manager.
     */
    public ContentHandler getContentHandler() throws SAXException, ProcessingException {


        Serializer serializer;
        ComponentSelector selector;


        String serializerName = this.isHTMLContent() ? "html" : "xml";


        // Get the serializer
        try {
            selector =
                (ComponentSelector)this.manager.lookup(Serializer.ROLE + "Selector");
            serializer = (Serializer)selector.select(serializerName);
        } catch(ComponentException ce) {
            throw new ProcessingException("Cannot get '" + serializerName + "' serializer");
        }


        try {
            return new WritingPipe(getOutputStream(), selector, serializer);
        } catch(IOException ioe) {
            selector.release(serializer);
            throw new ProcessingException("Cannot open stream for " + this.getSystemId(), ioe);
        }
    }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.apache.avalon.framework.component.ComponentSelector

org.apache.avalon.excalibur.monitor.test.MonitorTestCase

org.apache.cocoon.AbstractCompositeTestCase

org.apache.cocoon.acting.AbstractActionTestCase

org.apache.cocoon.acting.modular.DatabaseAction

org.apache.cocoon.acting.modular.DatabaseAddAction

org.apache.cocoon.acting.modular.TestAction

org.apache.cocoon.acting.PrincipalMultiAction

org.apache.cocoon.components.flow.javascript.JSCocoon

org.apache.cocoon.components.modules.input.AbstractMetaModule

org.apache.cocoon.components.modules.input.CollectionMetaModule

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.