|
1
8
14 package jfun.yan.containers;
15
16 import java.util.Collection  ;
17 import java.util.List ;
18 import java.util.Map ;
19 import java.util.Set ;
20
21 import jfun.yan.AmbiguousComponentResolutionException;
22 import jfun.yan.Component;
23 import jfun.yan.ComponentInstantiationException;
24 import jfun.yan.ComponentMap;
25 import jfun.yan.Container;
26 import jfun.yan.Creator;
27 import jfun.yan.CyclicDependencyException;
28 import jfun.yan.Dependency;
29 import jfun.yan.Registrar;
30 import jfun.yan.UnresolvedComponentException;
31 import jfun.yan.UnsatisfiedComponentException;
32 import jfun.yan.YanException;
33 import jfun.yan.factory.Factory;
34
35
45 public class DelegatingContainer implements Container {
46 private final Container yan;
47
48 public Factory getFactory(Object key, ComponentMap cmap) throws UnresolvedComponentException, YanException {
49 return yan.getFactory(key, cmap);
50 }
51
52 public Factory getFactory(Object key) throws UnresolvedComponentException, YanException {
53 return yan.getFactory(key);
54 }
55
56 public <T> Factory<T> getFactoryOfType(Class <T> type, ComponentMap cmap) throws AmbiguousComponentResolutionException, UnresolvedComponentException, YanException {
57 return yan.getFactoryOfType(type, cmap);
58 }
59
60 public <T> Factory<T> getFactoryOfType(Class <T> type) throws AmbiguousComponentResolutionException, UnresolvedComponentException, YanException {
61 return yan.getFactoryOfType(type);
62 }
63
64 public void getInstances(Map store, ComponentMap cmap) throws ComponentInstantiationException, CyclicDependencyException, UnresolvedComponentException, UnsatisfiedComponentException, YanException {
65 yan.getInstances(store, cmap);
66 }
67
68 public void getInstances(Map store) throws ComponentInstantiationException, CyclicDependencyException, UnresolvedComponentException, UnsatisfiedComponentException, YanException {
69 yan.getInstances(store, this);
70 }
71
72 public <T> T instantiateComponent(Object key, Creator<T> cc) throws AmbiguousComponentResolutionException, ComponentInstantiationException, CyclicDependencyException, UnresolvedComponentException, UnsatisfiedComponentException, YanException {
73 return yan.instantiateComponent(key, cc);
74 }
75
76 public <T> T instantiateComponent(Creator<T> cc)
77 throws AmbiguousComponentResolutionException,
78 ComponentInstantiationException, CyclicDependencyException,
79 UnresolvedComponentException, UnsatisfiedComponentException, YanException {
80 return yan.instantiateComponent(cc);
81 }
82
83
87 protected final Container getDelegateTarget(){
88 return yan;
89 }
90
94 public DelegatingContainer(final Container yan) {
95 this.yan = yan;
96 }
97
98 public boolean equals(Object obj) {
99 if(obj instanceof DelegatingContainer){
100 final DelegatingContainer dy2 = (DelegatingContainer)obj;
101 return yan.equals(dy2.yan);
102 }
103 else return yan.equals(obj);
104 }
105
106 public boolean containsKey(Object key) {
107 return yan.containsKey(key);
108 }
109
110 public boolean containsType(Class type) {
111 return yan.containsType(type);
112 }
113
114 public Component getComponent(Object key) {
115 return yan.getComponent(key);
116 }
117 public <T> Component<T> getComponentOfType(Class <T> type) {
118 return yan.getComponentOfType(type);
119 }
120 public Collection getComponents() {
121 return yan.getComponents();
122 }
123 public <T> List <Component<T>> getComponentsOfType(Class <T> type) {
124 return yan.getComponentsOfType(type);
125 }
126 public Class getComponentType(Object key) {
127 return yan.getComponentType(key);
128 }
129 public Object getInstance(Object key) {
130 return yan.getInstance(key, this);
131 }
132 public Object getInstance(Object key, ComponentMap cmap) {
133 return yan.getInstance(key, cmap);
134 }
135 public <T> T getInstanceOfType(Class <T> type) {
136 return yan.getInstanceOfType(type, this);
137 }
138 public <T> T getInstanceOfType(Class <T> type, ComponentMap cmap) {
139 return yan.getInstanceOfType(type, cmap);
140 }
141 public List getInstances() {
142 return yan.getInstances(this);
143 }
144 public List getInstances(ComponentMap cmap) {
145 return yan.getInstances(cmap);
146 }
147 public <T> List <T> getInstancesOfType(Class <T> type) {
148 return yan.getInstancesOfType(type, this);
149 }
150 public <T> List <T> getInstancesOfType(Class <T> type, ComponentMap cmap) {
151 return yan.getInstancesOfType(type, cmap);
152 }
153 public Dependency getDependency(Object key) {
154 return yan.getDependency(key, this);
155 }
156 public Dependency getDependency(Object key, ComponentMap cmap) {
157 return yan.getDependency(key, cmap);
158 }
159 public Dependency getDependencyOfType(Class type) {
160 return yan.getDependencyOfType(type, this);
161 }
162 public Dependency getDependencyOfType(Class type, ComponentMap cmap) {
163 return yan.getDependencyOfType(type, cmap);
164 }
165 public int hashCode() {
166 return yan.hashCode();
167 }
168 public Container inherit(Registrar parent) {
169 return yan.inherit(parent);
170 }
171 public Set keys() {
172 return yan.keys();
173 }
174 public void registerComponent(Component cc) {
175 yan.registerComponent(cc);
176 }
177 public void registerComponent(Object key, Component cc) {
178 yan.registerComponent(key, cc);
179 }
180 public void registerConstructor(Class c) {
181 yan.registerConstructor(c);
182 }
183 public void registerConstructor(Class c, Class [] param_types) {
184 yan.registerConstructor(c, param_types);
185 }
186 public void registerConstructor(Object key, Class c) {
187 yan.registerConstructor(key, c);
188 }
189 public void registerConstructor(Object key, Class c, Class [] param_types) {
190 yan.registerConstructor(key, c, param_types);
191 }
192 public void registerStaticMethod(Class c, String name) {
193 yan.registerStaticMethod(c, name);
194 }
195 public void registerStaticMethod(Class c, String name, Class [] param_types) {
196 yan.registerStaticMethod(c, name, param_types);
197 }
198 public void registerStaticMethod(Object key, Class c, String name) {
199 yan.registerStaticMethod(key, c, name);
200 }
201 public void registerStaticMethod(Object key, Class c, String name,
202 Class [] param_types) {
203 yan.registerStaticMethod(key, c, name, param_types);
204 }
205 public void registerValue(Object v) {
206 yan.registerValue(v);
207 }
208 public void registerValue(Object key, Object v) {
209 yan.registerValue(key, v);
210 }
211 public String toString() {
212 return yan.toString();
213 }
214 public void unregisterComponent(Object key) {
215 yan.unregisterComponent(key);
216 }
217 public void unregisterComponentsOfType(Class type) {
218 yan.unregisterComponentsOfType(type);
219 }
220 public void verify() {
221 yan.verify();
222 }
223 public void verify(ComponentMap cmap) {
224 yan.verify(cmap);
225 }
226 public Class verifyComponent(Component cc) {
227 return yan.verifyComponent(cc);
228 }
229 public Class verifyKey(Object key) {
230 return yan.verifyKey(key);
231 }
232 public Class verifyType(Class type) {
233 return yan.verifyType(type);
234 }
235 }
236 |
Popular Tags |
Java API By Example, From Geeks To Geeks.