KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > jfun > yan > xml > MyUtil


1 package jfun.yan.xml;
2
3
4 import java.io.IOException JavaDoc;
5 import java.io.InputStream JavaDoc;
6 import java.lang.reflect.Array JavaDoc;
7 import java.util.HashMap JavaDoc;
8 import java.util.HashSet JavaDoc;
9 import java.util.List JavaDoc;
10 import java.util.Locale JavaDoc;
11 import java.util.Set JavaDoc;
12
13 import jfun.util.Misc;
14 import jfun.util.dict.Dict;
15 import jfun.yan.Component;
16 import jfun.yan.Components;
17 import jfun.yan.Creator;
18 import jfun.yan.ParameterBinder;
19 import jfun.yan.PropertyBinder;
20 import jfun.yan.function.Signature;
21 import jfun.yan.util.Utils;
22 import jfun.yan.util.resource.ResourceLoader;
23
24
25 import org.xml.sax.Locator JavaDoc;
26
27 class MyUtil {
28   static boolean isRefName(String JavaDoc name){
29     if(name.length()>0){
30       if(name.charAt(0)!='$') return false;
31       if(name.length()>1){
32         final char c1 = name.charAt(1);
33         return c1!='$' && Character.isJavaIdentifierPart(c1);
34       }
35       else return true;
36     }
37     return false;
38   }
39   static Location toLocation(Locator JavaDoc loc){
40     return new Location(loc.getSystemId(), loc.getLineNumber(), loc.getColumnNumber());
41   }
42   static Set JavaDoc getNameSet(String JavaDoc[] names){
43     final HashSet JavaDoc result = new HashSet JavaDoc(names.length);
44     for(int i=0; i<names.length; i++){
45       result.add(names[i]);
46     }
47     return result;
48   }
49   private static final HashMap JavaDoc primitives = getPrimitiveTypes();
50   private static HashMap JavaDoc getPrimitiveTypes(){
51     final HashMap JavaDoc types = new HashMap JavaDoc();
52     types.put("int", int.class);
53     types.put("short", short.class);
54     types.put("byte", byte.class);
55     types.put("char", char.class);
56     types.put("boolean", boolean.class);
57     types.put("long", long.class);
58     types.put("float", float.class);
59     types.put("double", double.class);
60     return types;
61   }
62   static Class JavaDoc getArrayType(Class JavaDoc type){
63     return Misc.getArrayType(type);
64   }
65   static void assertAttributes(Tag tag, Set JavaDoc table){
66     final Attributes attrs = tag.getAttributes();
67     for(int i=0;i<attrs.size();i++){
68       final String JavaDoc name = attrs.getKey(i);
69       if(!table.contains(name)){
70         throw new ConfigurationException("attribute "+name+" not supported for "
71             +tag.getName(),
72             tag.getLocation());
73       }
74     }
75   }
76   static Class JavaDoc getClass(ClassLoader JavaDoc cloader, String JavaDoc typename)
77   throws ClassNotFoundException JavaDoc{
78     if(typename.endsWith("[]")){
79       return getArrayType(
80           getClass(cloader, typename.substring(0, typename.length()-2))
81       );
82     }
83     Class JavaDoc type = (Class JavaDoc)primitives.get(typename);
84     if(type!=null) return type;
85     return cloader.loadClass(typename);
86   }
87   private static Class JavaDoc getCastType(ClassLoader JavaDoc cloader, Attributes attrs, Location loc){
88     final String JavaDoc typename = attrs.getVal(Constants.TYPE);
89     if(typename != null){
90       try{
91         final Class JavaDoc type = getClass(cloader, typename.trim());
92         return type;
93       }
94       catch(ClassNotFoundException JavaDoc e){
95         throw new ConfigurationException("class " + typename+" not found",
96             loc);
97       }
98     }
99     return null;
100   }
101   static SingletonMode getSingletonStrategy(
102       String JavaDoc singleton, Location loc, SingletonMode def){
103     if(singleton==null){
104       return def;
105     }
106     else{
107       singleton = singleton.trim().toLowerCase(Locale.US);
108       if(singleton.equals("thread")){
109         return Modes.thread_local_singleton;
110       }
111       else{
112         Boolean JavaDoc yesno = NutsUtils.toBoolean(singleton);
113         if(yesno==null){
114           throw new ConfigurationException("unrecognized value for singleton: "+singleton,
115               loc);
116         }
117         if(yesno.booleanValue()){
118           return Modes.simple_singleton;
119         }
120         else return null;
121       }
122     }
123   }
124   /*
125   static ComponentDecorator getSingletonStrategy(
126       Attributes attrs,
127       Location loc, ComponentDecorator def){
128     String singleton = attrs.getVal(Constants.SINGLETON);
129   }*/

130   /*
131   private static void assertMethodName(Component c, String mname,
132       Location loc){
133     final Class type = c.getType();
134     if(type!=null){
135       try{
136         type.getMethod(mname, null);
137       }
138       catch(NoSuchMethodException e){
139         throw new ConfigurationException("lifecycle method "
140             + mname + " not defined by "+ Misc.getTypeName(type),
141             loc);
142       }
143     }
144   }*/

145   private static Set JavaDoc wirenames = getNameSet(new String JavaDoc[]{
146      Constants.BYNAME, Constants.BYTYPE, Constants.BYQUALIFIEDNAME,
147      Constants.TRUE, Constants.FALSE, Constants.YES, Constants.NO,
148      Constants.ON, Constants.OFF, Constants.AUTODETECT,
149   });
150   private static Set JavaDoc propmodes = getNameSet(new String JavaDoc[]{
151       Constants.BYNAME, Constants.BYQUALIFIEDNAME
152   });
153   static ParameterBinder getParamWiring(String JavaDoc autowire, AutoWiringMap custom_wirings,
154       Location loc, ParameterBinder def){
155     if(autowire!=null){
156       autowire = autowire.trim().toLowerCase(Locale.US);
157       ParameterBinder custom = custom_wirings.getParameterWiringMode(autowire);
158       if(custom!=null) return custom;
159       if(propmodes.contains(autowire)){
160         //this is byname or byqualified name, we skip.
161
return Modes.params_bytype;
162       }
163       if(Constants.BYTYPE.equals(autowire) || Constants.AUTODETECT.equals(autowire)){
164         return Modes.params_bytype;
165       }
166       else{
167         final Boolean JavaDoc tmp = NutsUtils.toBoolean(autowire);
168         if(tmp!=null){
169           if(tmp.booleanValue()){
170             return Modes.params_bytype;
171           }
172           else return null;
173         }
174         else if(custom_wirings.getPropertyWiringMode(autowire)==null){
175           throw new ConfigurationException("unrecognized autowire mode: "+autowire,
176             loc);
177         }
178       }
179     }
180     return def;
181   }
182   private static final HashMap JavaDoc auto_resolutions = getResolutionNames();
183   private static final HashMap JavaDoc manual_names = getManualNames();
184   private static HashMap JavaDoc getManualNames(){
185     final HashMap JavaDoc result = new HashMap JavaDoc();
186     result.put(Constants.OFF, Boolean.valueOf(false));
187     result.put(Constants.FALSE, Boolean.valueOf(false));
188     result.put(Constants.NO, Boolean.valueOf(false));
189     result.put(Constants.NONE, Boolean.valueOf(false));
190     return result;
191   }
192
193   private static HashMap JavaDoc getResolutionNames(){
194     final HashMap JavaDoc result = new HashMap JavaDoc();
195     final PropertyBinder bytype = Modes.props_bytype;
196     result.put(Constants.BYNAME, Modes.props_byname);
197     result.put(Constants.BYTYPE, bytype);
198     result.put(Constants.AUTODETECT, Modes.props_autodetect);
199     //result.put(Constants.ON, bytype);
200
//result.put(Constants.TRUE, bytype);
201
//result.put(Constants.YES, bytype);
202
result.put(Constants.BYQUALIFIEDNAME, Modes.props_byqualifiedname);
203     return result;
204   }
205   public static PropertyBinder getPropWiring(String JavaDoc autowire,
206       AutoWiringMap custom_wirings, Location loc, PropertyBinder def){
207     if(autowire!=null){
208       autowire = autowire.trim().toLowerCase(Locale.US);
209       PropertyBinder custom = custom_wirings.getPropertyWiringMode(autowire);
210       if(custom!=null) return custom;
211       
212       if(manual_names.containsKey(autowire)){
213         return null;
214       }
215       final PropertyBinder result = (PropertyBinder)auto_resolutions.get(autowire);
216       if(result != null) return result;
217       else if(custom_wirings.getParameterWiringMode(autowire)!=null){
218           throw new ConfigurationException("unrecognized autowire mode: "+autowire,
219               loc);
220       }
221     }
222     return def;
223   }
224   static ParameterBinder autocast(final ParameterBinder binder,
225       final Location loc, final Converter conv){
226     if(binder==null) return null;
227     return new ParameterBinder(){
228       public String JavaDoc toString(){
229         return binder.toString();
230       }
231       public Creator bind(Signature src, int ind, Class JavaDoc type) {
232         return cast(type, Components.adapt(binder.bind(src, ind, type)),
233             loc, conv);
234       }
235     };
236   }
237   static PropertyBinder autocast(final PropertyBinder binder,
238       final Location loc, final Converter conv){
239     if(binder==null) return null;
240     return new PropertyBinder(){
241       public String JavaDoc toString(){
242         return binder.toString();
243       }
244       public Creator bind(Class JavaDoc component_type, Object JavaDoc key, Class JavaDoc type) {
245         return cast(type, Components.adapt(binder.bind(component_type, key, type)),
246             loc, conv);
247       }
248     };
249   }
250   static ComponentDecorator getComponentDecorator(
251       Runtime JavaDoc runtime,
252       final Location loc,
253       final Class JavaDoc castto, final ComponentDecorator singleton,
254       final ParameterBinder wiring, final boolean sync,
255       final Converter conv){
256     /*
257     final Class castto = getCastType(runtime.getClassloader(), attrs, loc);
258     final String wirename = attrs.getVal(Constants.AUTOWIRE);
259     if(wirename!=null && !wirenames.contains(wirename)){
260       throw new ConfigurationException("unknown autowire strategy: "+wirename,
261           loc);
262     }
263     final ParameterBinder wiring = getParamWiring(wirename,
264         loc, def_strategy.getParameterWiring());
265     //final boolean sealed = isSeal(autowire);
266     final ComponentDecorator singleton = getSingletonStrategy(attrs, loc,
267         def_strategy.getSingletonMode());
268     //final DefaultLifecycleManager manager = runtime.getLifecycleManager();
269     */

270     return new SingletonMode(){
271       /*
272       public Class transform(Class type){
273         if(castto!=null) return castto;
274         else return type;
275       }*/

276       public Component decorate(Component c){
277         if(sync){
278           c = c.synchronize();
279         }
280         if(castto!=null)
281           c = cast(castto, c, loc, conv);//c.subsume(castto);
282
if(wiring!=null){
283           c = c.bindArguments(autocast(wiring, loc, conv));
284         }
285         if(singleton!=null){
286           c = singleton.decorate(c);
287         }
288         /*
289         final String initializer = attrs.getVal(Constants.INITIALIZER);
290         if(initializer != null){
291           assertMethodName(c, initializer, loc);
292           Class realtype = c.isConcrete()?c.getType():null;
293           c = c.followedBy(
294               Components.invokingMethod(realtype, initializer, null, false));
295         }
296         //we do initialization before wiring. So skip the default lifecycle manager
297         //for initializers.
298         final DefaultLifecycleManager.DefaultLifecycle lifecycle = manager.newLifecycle();
299
300         final String disposer = attrs.getVal(Constants.DISPOSER);
301         if(disposer != null){
302           assertMethodName(c, disposer, loc);
303           lifecycle.disposer(disposer);
304         }
305         final String starter = attrs.getVal(Constants.STARTER);
306         if(starter != null){
307           assertMethodName(c, starter, loc);
308           lifecycle.starter(starter);
309         }
310         final String stopper = attrs.getVal(Constants.STOPPER);
311         if(stopper != null){
312           assertMethodName(c, stopper, loc);
313           lifecycle.stopper(stopper);
314         }
315         c = lifecycle.manage(c);*/

316         return c;
317       }
318     };
319   }
320   static Component wrapComponent(Component c, Runtime JavaDoc runtime,
321       final Location loc, Class JavaDoc casttype, ComponentDecorator singleton,
322       ParameterBinder autowire, boolean sync,
323       Converter conv){
324     return getComponentDecorator(runtime, loc, casttype, singleton, autowire, sync,
325         conv)
326       .decorate(c).label(loc);
327   }
328   static InputStream JavaDoc readResource(ResourceLoader loader, String JavaDoc resourcename)
329   throws IOException JavaDoc{
330     final InputStream JavaDoc in = loader.getResourceAsStream(resourcename);
331     if(in == null){
332       throw new IllegalArgumentException JavaDoc("cannot find resuorce: "+resourcename);
333     }
334     return in;
335   }
336   static String JavaDoc getMandatory(Tag tag, String JavaDoc name){
337     final String JavaDoc result = tag.getAttribute(name);
338     if(result==null)
339       throw new ConfigurationException("<"+tag.getName()+"> - missing mandatory attribute: "
340           + name
341           ,tag.getLocation());
342     return result;
343   }
344   static String JavaDoc getAttribute(Tag tag, String JavaDoc name1, String JavaDoc name2){
345     final String JavaDoc val1 = tag.getAttribute(name1);
346     final String JavaDoc val2 = tag.getAttribute(name2);
347     if(val1!=null && val2!=null){
348       throw new ConfigurationException("<"+tag.getName()+"> - "
349           +name1 + " and " + name2 + " are both specified, while only one is expected."
350           ,tag.getLocation());
351     }
352     return val1==null?val2:val1;
353   }
354   static String JavaDoc getEagerMode(Tag tag){
355     return getAttribute(tag, Constants.EAGER_INSTANTIATED,
356         Constants.EAGER_INSTANTIATED2);
357   }
358   /*
359   static ComponentBinder wrapBinder(final ComponentBinder binder, Runtime runtime, final Attributes attrs,
360       final Location loc){
361     final ComponentTransformer trans = getComponentTransformer(runtime, attrs, loc);
362     return new ComponentBinder(){
363       public Creator bind(Object v)
364       throws Throwable{
365         return trans.transform(Components.adapt(binder.bind(v)));
366       }
367       public Class bindType(Class type){
368         return trans.transform(binder.bindType(type));
369       }
370       public Verifiable verify(Class type){
371         final Verifiable veri = binder.verify(type);
372         return new Verifiable(){
373           public Class verify(Dependency dep)
374           throws IrresolveableArgumentException, ParameterTypeMismatchException, AmbiguousComponentResolutionException, YanException {
375             return trans.transform(veri.verify(dep));
376           }
377         };
378       }
379     };
380   }
381   static Binder wrapBinder(final Binder binder,Runtime runtime, final Attributes attrs,
382       final Location loc){
383     if(binder instanceof ComponentBinder){
384       return wrapBinder((ComponentBinder)binder, runtime, attrs, loc);
385     }
386     else{
387       final ComponentTransformer trans = getComponentTransformer(runtime, attrs, loc);
388       return new Binder(){
389         public Creator bind(Object v)
390         throws Throwable{
391           return trans.transform(Components.adapt(binder.bind(v)));
392         }
393       };
394     }
395   }
396   private static boolean isSeal(String autowire){
397     if(autowire==null) return true;
398     autowire = autowire.toLowerCase(Locale.US);
399     final Boolean is_autowire = StringUtil.toBoolean(autowire);
400     if(is_autowire!=null){
401       return !is_autowire.booleanValue();
402     }
403     else return false;
404   }*/

405   static Stmt typedValue(final Class JavaDoc type, final Object JavaDoc val, final Location loc,
406       final Converter converter){
407     return new Stmt(){
408       public Object JavaDoc run(Dict frame, Runtime JavaDoc runtime){
409         return converter.convert(type, val, loc);
410       }
411       public Class JavaDoc getType(){
412         return type;
413       }
414       public Location getLocation(){
415         return loc;
416       }
417       public String JavaDoc toString(){return ""+val;}
418     };
419 }
420   static Stmt value(final Object JavaDoc v, final Location loc){
421     final Class JavaDoc type = v==null?Object JavaDoc.class:v.getClass();
422     return new Stmt(){
423       public Object JavaDoc run(Dict frame, Runtime JavaDoc runtime){
424         return v;
425       }
426       public Class JavaDoc getType(){
427         return type;
428       }
429       public Location getLocation(){
430         return loc;
431       }
432       public String JavaDoc toString(){return ""+v;}
433     };
434   }
435   static ContinuationEscapeException getEscapeException(Throwable JavaDoc e){
436     for(Throwable JavaDoc cur = e;;){
437       if(cur instanceof ContinuationEscapeException){
438         return (ContinuationEscapeException)cur;
439       }
440       final Throwable JavaDoc cause = cur.getCause();
441       if(cause==null || cause==cur) return null;
442       cur = cause;
443     }
444   }
445   private static Component convert(final Class JavaDoc target_type, Component c,
446       final Location loc, final Converter converter){
447     return c.map(new jfun.yan.Map(){
448       public Object JavaDoc map(Object JavaDoc v){
449         return converter.convert(target_type, v, loc);
450       }
451     }).cast(target_type);
452   }
453   static Component cast(final Class JavaDoc target_type, Component c,
454       final Location loc, final Converter converter){
455     final Class JavaDoc type = c.getType();
456     if(type==null || Literal.class.isAssignableFrom(type)){
457       return convert(target_type, c, loc, converter);
458     }
459     else if(String JavaDoc.class.equals(type)){
460       if(target_type.isAssignableFrom(type)){
461         return c;
462       }
463       else{
464         return convert(target_type, c, loc, converter);
465       }
466     }
467     else return c.cast(target_type);
468   }
469   /**
470    * Convert a 1-element set.
471    * @param impltype the set implementation type.
472    * @param obj the only one element in the set.
473    * @return the set.
474    * @throws IllegalAccessException
475    * when the constructor of the implementation class is not public.
476    * @throws InstantiationException
477    * when the constructor fails.
478    */

479   public static Set JavaDoc toSet(Class JavaDoc impltype, Object JavaDoc obj)
480   throws IllegalAccessException JavaDoc, InstantiationException JavaDoc{
481     final Set JavaDoc set = Utils.createSet(impltype, 1);
482     set.add(obj);
483     return set;
484   }
485   /**
486    * Convert a 1-element list.
487    * @param impltype the list implementation type.
488    * @param obj the only one element in the list.
489    * @return the list.
490    * @throws IllegalAccessException
491    * when the constructor of the implementation class is not public.
492    * @throws InstantiationException
493    * when the constructor fails.
494    */

495   public static List JavaDoc toList(Class JavaDoc impltype, Object JavaDoc obj)
496   throws IllegalAccessException JavaDoc, InstantiationException JavaDoc{
497     final List JavaDoc list = Utils.createList(impltype, 1);
498     list.add(obj);
499     return list;
500   }
501   /**
502    * Create a 1-element array.
503    * @param elem_type the array element type.
504    * @param obj the actual element value.
505    * @return the array object.
506    */

507   public static Object JavaDoc toArray(Class JavaDoc elem_type, Object JavaDoc obj){
508     final Object JavaDoc arr = Array.newInstance(elem_type, 1);
509     Array.set(arr, 0, obj);
510     return arr;
511   }
512 }
513
Popular Tags