|
1 package jfun.yan.containers;
2
3 import java.util.ArrayList  ;
4 import java.util.HashMap ;
5 import java.util.List ;
6
7 import jfun.yan.Component;
8 import jfun.yan.ComponentMap;
9 import jfun.yan.Registrar;
10 import jfun.yan.UnresolvedComponentException;
11 import jfun.yan.YanException;
12 import jfun.yan.factory.Factory;
13
14
15
36 public class ImmutablePreferredContainer extends jfun.yan.containers.SimpleContainer {
37 private final HashMap typecache = new HashMap ();
38 private final HashMap typescache = new HashMap ();
39 private final HashMap boolcache = new HashMap ();
40 public ImmutablePreferredContainer(Registrar reg) {
41 super(reg);
42 }
43 public synchronized <T> Component<T> getComponentOfType(Class <T> type) {
44 Component<T> c = (Component<T>)typecache.get(type);
45 if(c==null){
46 c = super.getComponentOfType(type);
47 if(c!=null){
48 typecache.put(type, c);
49 }
50 }
51 return c;
52 }
53 public synchronized boolean containsType(Class type) {
54 if(boolcache.containsKey(type))
55 return true;
56 if(typecache.containsKey(type))
57 return true;
58 if(typescache.containsKey(type)){
59 return true;
60 }
61 final boolean ret = super.containsType(type);
62 if(ret){
63 boolcache.put(type, Boolean.valueOf(true));
64 }
65 return ret;
66 }
67 public synchronized <T> List <Component<T>> getComponentsOfType(Class <T> type) {
68 List <Component<T>> ret = (List <Component<T>>)typescache.get(type);
69 if(ret==null){
70 final Component<T> c = (Component<T>)typecache.get(type);
71 if(c==null){
72 ret = super.getComponentsOfType(type);
73 }
74 else{
75 ret = new ArrayList <Component<T>>(1);
76 ret.add(c);
77 }
78 typescache.put(type, ret);
79 }
80 return ret;
81 }
82 private final HashMap type_factory_cache = new HashMap ();
83 private final HashMap key_factory_cache = new HashMap ();
84 public Factory getFactory(Object key, ComponentMap cmap) throws UnresolvedComponentException, YanException {
85 if(cmap == this){
86 return getFactory(key);
87 }
88 else return super.getFactory(key, cmap);
89 }
90 public synchronized Factory getFactory(Object key){
91 Factory result = (Factory)key_factory_cache.get(key);
92 if(result==null){
93 result = super.getFactory(key);
94 key_factory_cache.put(key, result);
95 }
96 return result;
97 }
98 public <T> Factory<T> getFactoryOfType(Class <T> type, ComponentMap cmap){
99 if(cmap==this){
100 return getFactoryOfType(type);
101 }
102 else return super.getFactoryOfType(type, cmap);
103 }
104 public synchronized <T> Factory<T> getFactoryOfType(Class <T> type){
105 Factory<T> result = (Factory<T>)type_factory_cache.get(type);
106 if(result==null){
107 result = super.getFactoryOfType(type);
108 type_factory_cache.put(type, result);
109 }
110 return result;
111 }
112 public Object getInstance(Object key, ComponentMap cmap) {
113 if(cmap==this){
114 return getInstance(key);
115 }
116 else return super.getInstance(key, cmap);
117 }
118 public Object getInstance(Object key) {
119 return getFactory(key).create();
120 }
121 public <T> T getInstanceOfType(Class <T> type, ComponentMap cmap) {
122 if(cmap==this){
123 return getInstanceOfType(type);
124 }
125 else return super.getInstanceOfType(type, cmap);
126 }
127 public <T> T getInstanceOfType(Class <T> type) {
128 return getFactoryOfType(type).create();
129 }
130
131 public void registerComponent(Object key, Component cc) {
132 clearCache();
133 super.registerComponent(key, cc);
134 }
135
136 public void unregisterComponent(Object key) {
137 clearCache();
138 super.unregisterComponent(key);
139 }
140
141 public void unregisterComponentsOfType(Class type) {
142 clearCache();
143 super.unregisterComponentsOfType(type);
144 }
145 private synchronized void clearCache(){
146 typecache.clear();
147 typescache.clear();
148 boolcache.clear();
149 key_factory_cache.clear();
150 type_factory_cache.clear();
151 }
152
153 }
154 |
Popular Tags |
Java API By Example, From Geeks To Geeks.