001: /*****************************************************************************
002: * Copyright (C) NanoContainer Organization. All rights reserved. *
003: * ------------------------------------------------------------------------- *
004: * The software in this package is published under the terms of the BSD *
005: * style license a copy of which has been included with this distribution in *
006: * the LICENSE.txt file. *
007: * *
008: * Original code by Paul Hammant *
009: *****************************************************************************/package org.nanocontainer.reflection;
010:
011: import java.io.Serializable;
012: import org.nanocontainer.NanoPicoContainer;
013: import org.picocontainer.ComponentMonitor;
014: import org.picocontainer.MutablePicoContainer;
015: import org.picocontainer.PicoContainer;
016: import org.picocontainer.defaults.ComponentAdapterFactory;
017: import org.picocontainer.defaults.ComponentMonitorStrategy;
018: import org.picocontainer.defaults.DefaultComponentAdapterFactory;
019: import org.picocontainer.defaults.DefaultPicoContainer;
020: import org.picocontainer.defaults.LifecycleStrategy;
021:
022: /**
023: * This is a MutablePicoContainer that also supports soft composition. i.e. assembly by class name rather that class
024: * reference.
025: * <p>
026: * In terms of implementation it adopts the behaviour of DefaultPicoContainer and DefaultNanoContainer.</p>
027: *
028: * @author Paul Hammant
029: * @author Mauro Talevi
030: * @author Michael Rimov
031: * @version $Revision: 2964 $
032: */
033: public class DefaultNanoPicoContainer extends AbstractNanoPicoContainer
034: implements NanoPicoContainer, Serializable,
035: ComponentMonitorStrategy {
036:
037: public DefaultNanoPicoContainer(ClassLoader classLoader,
038: ComponentAdapterFactory caf, PicoContainer parent) {
039: super (new DefaultPicoContainer(caf, parent), classLoader);
040: }
041:
042: public DefaultNanoPicoContainer(ClassLoader classLoader,
043: PicoContainer parent) {
044: super (new DefaultPicoContainer(
045: new DefaultComponentAdapterFactory(), parent),
046: classLoader);
047: }
048:
049: public DefaultNanoPicoContainer(ClassLoader classLoader,
050: PicoContainer parent, ComponentMonitor componentMonitor) {
051: super (new DefaultPicoContainer(
052: new DefaultComponentAdapterFactory(componentMonitor),
053: parent), classLoader);
054: }
055:
056: public DefaultNanoPicoContainer(ComponentAdapterFactory caf) {
057: super (new DefaultPicoContainer(caf, null),
058: DefaultNanoPicoContainer.class.getClassLoader());
059: }
060:
061: public DefaultNanoPicoContainer(PicoContainer pc) {
062: super (new DefaultPicoContainer(pc),
063: DefaultNanoPicoContainer.class.getClassLoader());
064: }
065:
066: public DefaultNanoPicoContainer(ClassLoader classLoader) {
067: super (new DefaultPicoContainer(), classLoader);
068: }
069:
070: public DefaultNanoPicoContainer() {
071: super (new DefaultPicoContainer(),
072: DefaultNanoPicoContainer.class.getClassLoader());
073: }
074:
075: /**
076: * Constructor that provides the same control over the nanocontainer lifecycle strategies
077: * as {@link DefaultPicoContainer(ComponentAdapterFactory, LifecycleStrategy, PicoContainer)}.
078: * @param componentAdapterFactory ComponentAdapterFactory
079: * @param lifecycleStrategyForInstanceRegistrations LifecycleStrategy
080: * @param parent PicoContainer may be null if there is no parent.
081: * @param cl the Classloader to use. May be null, in which case DefaultNanoPicoContainer.class.getClassLoader()
082: * will be called instead.
083: */
084: public DefaultNanoPicoContainer(
085: ComponentAdapterFactory componentAdapterFactory,
086: LifecycleStrategy lifecycleStrategyForInstanceRegistrations,
087: PicoContainer parent, ClassLoader cl) {
088:
089: super (new DefaultPicoContainer(componentAdapterFactory,
090: lifecycleStrategyForInstanceRegistrations, parent),
091: //Use a default classloader if none is specified.
092: (cl != null) ? cl : DefaultNanoPicoContainer.class
093: .getClassLoader());
094: }
095:
096: /**
097: * Copy Constructor. Makes a new DefaultNanoPicoContainer with the same
098: * attributes - ClassLoader, child PicoContainer type, ComponentAdapterFactory -
099: * as the parent.
100: * <p><tt>Note:</tt> This constructor is protected because are existing scripts
101: * that call <tt>new DefaultNanoPicoContainer(PicoContainer)</tt>, and they get this
102: * constructor instead (which has different behavior).</p>
103: * @param parent The object to copy.
104: */
105: protected DefaultNanoPicoContainer(
106: final DefaultNanoPicoContainer parent) {
107: super (parent.getDelegate().makeChildContainer(), parent
108: .getComponentClassLoader());
109: MutablePicoContainer parentDelegate = parent.getDelegate();
110: parentDelegate.removeChildContainer(getDelegate());
111: parentDelegate.addChildContainer(this );
112: }
113:
114: protected AbstractNanoPicoContainer createChildContainer() {
115: return new DefaultNanoPicoContainer(this );
116: }
117:
118: public void changeMonitor(ComponentMonitor monitor) {
119: ((ComponentMonitorStrategy) getDelegate())
120: .changeMonitor(monitor);
121: }
122:
123: public ComponentMonitor currentMonitor() {
124: return ((ComponentMonitorStrategy) getDelegate())
125: .currentMonitor();
126: }
127:
128: }
|