001 /*****************************************************************************
002 * Copyright (C) PicoContainer 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 Jon Tirsen *
009 *****************************************************************************/
010
011 package org.picocontainer.behaviors;
012
013 import java.io.Serializable;
014 import java.lang.reflect.Type;
015
016 import org.picocontainer.ComponentAdapter;
017 import org.picocontainer.ComponentMonitor;
018 import org.picocontainer.Behavior;
019 import org.picocontainer.PicoContainer;
020 import org.picocontainer.PicoCompositionException;
021 import org.picocontainer.PicoVisitor;
022 import org.picocontainer.ComponentMonitorStrategy;
023 import org.picocontainer.LifecycleStrategy;
024
025 /**
026 * <p>
027 * Component adapter which decorates another adapter.
028 * </p>
029 * <p>
030 * This adapter supports a {@link org.picocontainer.ComponentMonitorStrategy component monitor strategy}
031 * and will propagate change of monitor to the delegate if the delegate itself
032 * support the monitor strategy.
033 * </p>
034 * <p>
035 * This adapter also supports a {@link Behavior lifecycle manager} and a
036 * {@link org.picocontainer.LifecycleStrategy lifecycle strategy} if the delegate does.
037 * </p>
038 *
039 * @author Jon Tirsen
040 * @author Aslak Hellesoy
041 * @author Mauro Talevi
042 */
043 public abstract class AbstractBehavior<T> implements Behavior<T>, ComponentMonitorStrategy,
044 LifecycleStrategy, Serializable {
045
046 protected final ComponentAdapter<T> delegate;
047
048
049 public AbstractBehavior(ComponentAdapter<T> delegate) {
050 this.delegate = delegate;
051 }
052
053 public Object getComponentKey() {
054 return delegate.getComponentKey();
055 }
056
057 public Class<T> getComponentImplementation() {
058 return delegate.getComponentImplementation();
059 }
060
061 public T getComponentInstance(PicoContainer container) throws PicoCompositionException {
062 return getComponentInstance(container, NOTHING.class);
063 }
064
065 public T getComponentInstance(PicoContainer container, Type into) throws PicoCompositionException {
066 return (T) delegate.getComponentInstance(container, into);
067 }
068
069 public void verify(PicoContainer container) throws PicoCompositionException {
070 delegate.verify(container);
071 }
072
073 public final ComponentAdapter<T> getDelegate() {
074 return delegate;
075 }
076
077 @SuppressWarnings("unchecked")
078 public final <U extends ComponentAdapter> U findAdapterOfType(Class<U> componentAdapterType) {
079 if (componentAdapterType.isAssignableFrom(this.getClass())) {
080 return (U) this;
081 } else if (componentAdapterType.isAssignableFrom(delegate.getClass())) {
082 return (U) delegate;
083 } else {
084 return delegate.findAdapterOfType(componentAdapterType);
085 }
086 }
087
088 public void accept(PicoVisitor visitor) {
089 visitor.visitComponentAdapter(this);
090 delegate.accept(visitor);
091 }
092
093 /**
094 * Delegates change of monitor if the delegate supports
095 * a component monitor strategy.
096 * {@inheritDoc}
097 */
098 public void changeMonitor(ComponentMonitor monitor) {
099 if ( delegate instanceof ComponentMonitorStrategy ){
100 ((ComponentMonitorStrategy)delegate).changeMonitor(monitor);
101 }
102 }
103
104 /**
105 * Returns delegate's current monitor if the delegate supports
106 * a component monitor strategy.
107 * {@inheritDoc}
108 * @throws PicoCompositionException if no component monitor is found in delegate
109 */
110 public ComponentMonitor currentMonitor() {
111 if ( delegate instanceof ComponentMonitorStrategy ){
112 return ((ComponentMonitorStrategy)delegate).currentMonitor();
113 }
114 throw new PicoCompositionException("No component monitor found in delegate");
115 }
116
117 /**
118 * Invokes delegate start method if the delegate is a Behavior
119 * {@inheritDoc}
120 */
121 public void start(PicoContainer container) {
122 if ( delegate instanceof Behavior){
123 ((Behavior<?>)delegate).start(container);
124 }
125 }
126
127 /**
128 * Invokes delegate stop method if the delegate is a Behavior
129 * {@inheritDoc}
130 */
131 public void stop(PicoContainer container) {
132 if ( delegate instanceof Behavior){
133 ((Behavior<?>)delegate).stop(container);
134 }
135 }
136
137 /**
138 * Invokes delegate dispose method if the delegate is a Behavior
139 * {@inheritDoc}
140 */
141 public void dispose(PicoContainer container) {
142 if ( delegate instanceof Behavior){
143 ((Behavior<?>)delegate).dispose(container);
144 }
145 }
146
147 /**
148 * Invokes delegate hasLifecycle method if the delegate is a Behavior
149 * {@inheritDoc}
150 */
151 public boolean componentHasLifecycle() {
152 if (delegate instanceof Behavior){
153 return ((Behavior<?>)delegate).componentHasLifecycle();
154 }
155 return false;
156 }
157
158 public boolean isStarted() {
159 if (delegate instanceof Behavior){
160 return ((Behavior<?>)delegate).isStarted();
161 }
162 return false;
163 }
164
165 // ~~~~~~~~ LifecycleStrategy ~~~~~~~~
166
167 /**
168 * Invokes delegate start method if the delegate is a LifecycleStrategy
169 * {@inheritDoc}
170 */
171 public void start(Object component) {
172 if ( delegate instanceof LifecycleStrategy ){
173 ((LifecycleStrategy)delegate).start(component);
174 }
175 }
176
177 /**
178 * Invokes delegate stop method if the delegate is a LifecycleStrategy
179 * {@inheritDoc}
180 */
181 public void stop(Object component) {
182 if ( delegate instanceof LifecycleStrategy ){
183 ((LifecycleStrategy)delegate).stop(component);
184 }
185 }
186
187 /**
188 * Invokes delegate dispose method if the delegate is a LifecycleStrategy
189 * {@inheritDoc}
190 */
191 public void dispose(Object component) {
192 if ( delegate instanceof LifecycleStrategy ){
193 ((LifecycleStrategy)delegate).dispose(component);
194 }
195 }
196
197 /**
198 * Invokes delegate hasLifecycle(Class) method if the delegate is a LifecycleStrategy
199 * {@inheritDoc}
200 */
201 public boolean hasLifecycle(Class<?> type) {
202 return delegate instanceof LifecycleStrategy && ((LifecycleStrategy) delegate).hasLifecycle(type);
203 }
204
205 public String toString() {
206 return getDescriptor() + ":" + delegate.toString();
207 }
208 }
209