Java > Open Source Codes > org > codehaus > groovy > runtime > Invoker


1 /*
2  $Id: Invoker.java,v 1.65 2004/12/27 21:38:38 spullara Exp $
3
4  Copyright 2003 (C) James Strachan and Bob Mcwhirter. All Rights Reserved.
5
6  Redistribution and use of this software and associated documentation
7  ("Software"), with or without modification, are permitted provided
8  that the following conditions are met:
9
10  1. Redistributions of source code must retain copyright
11     statements and notices. Redistributions must also contain a
12     copy of this document.
13
14  2. Redistributions in binary form must reproduce the
15     above copyright notice, this list of conditions and the
16     following disclaimer in the documentation and/or other
17     materials provided with the distribution.
18
19  3. The name "groovy" must not be used to endorse or promote
20     products derived from this Software without prior written
21     permission of The Codehaus. For written permission,
22     please contact info@codehaus.org.
23
24  4. Products derived from this Software may not be called "groovy"
25     nor may "groovy" appear in their names without prior written
26     permission of The Codehaus. "groovy" is a registered
27     trademark of The Codehaus.
28
29  5. Due credit should be given to The Codehaus -
30     http://groovy.codehaus.org/
31
32  THIS SOFTWARE IS PROVIDED BY THE CODEHAUS AND CONTRIBUTORS
33  ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
34  NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
35  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
36  THE CODEHAUS OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
37  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
38  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
39  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
40  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
41  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
42  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
43  OF THE POSSIBILITY OF SUCH DAMAGE.
44
45  */
46 package org.codehaus.groovy.runtime;
47
48 import groovy.lang.*;
49 import org.apache.xml.serialize.OutputFormat;
50 import org.apache.xml.serialize.XMLSerializer;
51 import org.w3c.dom.Element ;
52 import org.w3c.dom.Node ;
53 import org.w3c.dom.NodeList ;
54
55 import java.io.File ;
56 import java.io.IOException ;
57 import java.io.StringWriter ;
58 import java.lang.reflect.Method ;
59 import java.security.AccessController ;
60 import java.security.PrivilegedAction ;
61 import java.util.*;
62 import java.util.regex.Matcher ;
63 import java.util.regex.Pattern ;
64
65 /**
66  * A helper class to invoke methods or extract properties on arbitrary Java objects dynamically
67  *
68  * @author <a HREF="mailto:james@coredevelopers.net">James Strachan</a>
69  * @version $Revision: 1.65 $
70  */
71 public class Invoker {
72
73     protected static final Object [] EMPTY_ARGUMENTS = {
74     };
75     protected static final Class [] EMPTY_TYPES = {
76     };
77
78     public MetaClassRegistry getMetaRegistry() {
79         return metaRegistry;
80     }
81
82     private MetaClassRegistry metaRegistry = new MetaClassRegistry();
83
84     public MetaClass getMetaClass(Object object) {
85         return metaRegistry.getMetaClass(object.getClass());
86     }
87
88     /**
89      * Invokes the given method on the object.
90      *
91      * @param object
92      * @param methodName
93      * @param arguments
94      * @return
95      */
96     public Object invokeMethod(Object object, String methodName, Object arguments) {
97         /*
98         System
99             .out
100             .println(
101                 "Invoker - Invoking method on object: "
102                     + object
103                     + " method: "
104                     + methodName
105                     + " arguments: "
106                     + InvokerHelper.toString(arguments));
107                     */
108
109         if (object == null) {
110             throw new NullPointerException ("Cannot invoke method: " + methodName + " on null object");
111         }
112
113         // if the object is a Class, call a static method from that class
114 if (object instanceof Class ) {
115             Class theClass = (Class ) object;
116             MetaClass metaClass = metaRegistry.getMetaClass(theClass);
117             return metaClass.invokeStaticMethod(object, methodName, asArray(arguments));
118         }
119         else // it's an instance
120 {
121             // if it's not an object implementing GroovyObject (thus not builder, nor a closure)
122 if (!(object instanceof GroovyObject)) {
123                 Class theClass = object.getClass();
124                 MetaClass metaClass = metaRegistry.getMetaClass(theClass);
125                 return metaClass.invokeMethod(object, methodName, asArray(arguments));
126             }
127             // it's an object implementing GroovyObject
128 else
129             {
130                 // if it's a closure, use the closure's invokeMethod()
131 if (object instanceof Closure) {
132                     Closure closure = (Closure) object;
133                     return closure.invokeMethod(methodName, arguments);
134                 }
135                 // it's some kind of wacky object that overrides invokeMethod() to do some groovy stuff
136 // (like a proxy, a builder, some custom funny object which controls the invokation mechanism)
137 else
138                 {
139                     GroovyObject groovy = (GroovyObject) object;
140                     try
141                     {
142                         // if there's a statically typed method or a GDK method
143 return groovy.getMetaClass().invokeMethod(object, methodName, arguments);
144                     }
145                     catch (MissingMethodException e)
146                     {
147                         if (e.getMethod().equals(methodName) && object.getClass() == e.getType()) {
148                             // in case there's nothing else, invoke the object's own invokeMethod()
149 return groovy.invokeMethod(methodName, arguments);
150                         } else {
151                             throw e;
152                         }
153                     }
154                 }
155             }
156         }
157     }
158
159     public Object invokeSuperMethod(Object object, String methodName, Object arguments) {
160         if (object == null) {
161             throw new NullPointerException ("Cannot invoke method: " + methodName + " on null object");
162         }
163
164         Class theClass = object.getClass();
165
166         MetaClass metaClass = metaRegistry.getMetaClass(theClass.getSuperclass());
167         return metaClass.invokeMethod(object, methodName, asArray(arguments));
168     }
169
170     public Object invokeStaticMethod(String type, String method, Object arguments) {
171         MetaClass metaClass = metaRegistry.getMetaClass(loadClass(type));
172         List argumentList = asList(arguments);
173         return metaClass.invokeStaticMethod(null, method, asArray(arguments));
174     }
175
176     public Object invokeConstructor(String type, Object arguments) {
177         //System.out.println("Invoking constructor of type: " + type);
178 return invokeConstructorOf(loadClass(type), arguments);
179     }
180
181     public Object invokeConstructorOf(Class type, Object arguments) {
182         MetaClass metaClass = metaRegistry.getMetaClass(type);
183         return metaClass.invokeConstructor(asArray(arguments));
184     }
185
186     /**
187      * Converts the given object into an array; if its an array then just
188      * cast otherwise wrap it in an array
189      */
190     public Object [] asArray(Object arguments) {
191         if (arguments == null) {
192             return EMPTY_ARGUMENTS;
193         }
194         if (arguments instanceof Tuple) {
195             Tuple tuple = (Tuple) arguments;
196             return tuple.toArray();
197         }
198         if (arguments instanceof Object []) {
199             return (Object []) arguments;
200         } else {
201             return new Object []{arguments};
202         }
203     }
204
205     public List asList(Object value) {
206         if (value == null) {
207             return Collections.EMPTY_LIST;
208         } else if (value instanceof List ) {
209             return (List ) value;
210         } else if (value.getClass().isArray()) {
211             return Arrays.asList((Object []) value);
212         } else if (value instanceof Enumeration) {
213             List answer = new ArrayList();
214             for (Enumeration e = (Enumeration) value; e.hasMoreElements();) {
215                 answer.add(e.nextElement());
216             }
217             return answer;
218         } else {
219             // lets assume its a collection of 1
220 return Collections.singletonList(value);
221         }
222     }
223
224     /**
225      * @param arguments
226      * @return
227      */
228     public Collection asCollection(Object value) {
229         if (value == null) {
230             return Collections.EMPTY_LIST;
231         } else if (value instanceof Collection) {
232             return (Collection) value;
233         } else if (value instanceof Map) {
234             Map map = (Map) value;
235             return map.entrySet();
236         } else if (value.getClass().isArray()) {
237             if (value.getClass().getComponentType().isPrimitive()) {
238                 return InvokerHelper.primitiveArrayToList(value);
239             }
240             return Arrays.asList((Object []) value);
241         } else if (value instanceof MethodClosure) {
242             MethodClosure method = (MethodClosure) value;
243             IteratorClosureAdapter adapter = new IteratorClosureAdapter(method.getDelegate());
244             method.call(adapter);
245             return adapter.asList();
246         } else if (value instanceof String ) {
247             return DefaultGroovyMethods.toList((String ) value);
248         } else if (value instanceof File ) {
249             try {
250                 return DefaultGroovyMethods.readLines((File ) value);
251             } catch (IOException e) {
252                 throw new GroovyRuntimeException("Error reading file: " + value, e);
253             }
254         } else {
255             // lets assume its a collection of 1
256 return Collections.singletonList(value);
257         }
258     }
259
260     public Iterator asIterator(Object value) {
261         if (value == null) {
262             return Collections.EMPTY_LIST.iterator();
263         }
264         if (value instanceof Iterator) {
265             return (Iterator) value;
266         }
267         if (value instanceof NodeList ) {
268             final NodeList nodeList = (NodeList ) value;
269             return new Iterator() {
270                 private int current = 0;
271
272                 public boolean hasNext() {
273                     return current < nodeList.getLength();
274                 }
275
276                 public Object next() {
277                     Node node = nodeList.item(current++);
278                     return node;
279                 }
280
281                 public void remove() {
282                     throw new UnsupportedOperationException ("Cannot remove() from an Enumeration");
283                 }
284             };
285         } else if (value instanceof Enumeration) {
286             final Enumeration enumeration = (Enumeration) value;
287             return new Iterator() {
288                 private Object last;
289
290                 public boolean hasNext() {
291                     return enumeration.hasMoreElements();
292                 }
293
294                 public Object next() {
295                     last = enumeration.nextElement();
296                     return last;
297                 }
298
299                 public void remove() {
300                     throw new UnsupportedOperationException ("Cannot remove() from an Enumeration");
301                 }
302             };
303         } else if (value instanceof Matcher ) {
304             final Matcher matcher = (Matcher ) value;
305             return new Iterator() {
306                 private boolean found = false;
307                 private boolean done = false;
308
309                 public boolean hasNext() {
310                     if (done)
311                         return false;
312                     if (!found) {
313                         found = matcher.find();
314                         if (!found)
315                             done = true;
316                     }
317                     return found;
318                 }
319
320                 public Object next() {
321                     if (!found) {
322                         if (!hasNext()) {
323                             throw new NoSuchElementException();
324                         }
325                     }
326                     found = false;
327                     return matcher.group();
328                 }
329
330                 public void remove() {
331                     throw new UnsupportedOperationException ();
332                 }
333             };
334         } else {
335             try {
336                 // lets try see if there's an iterator() method
337 final Method method = value.getClass().getMethod("iterator", EMPTY_TYPES);
338
339                 if (method != null) {
340                     AccessController.doPrivileged(new PrivilegedAction () {
341                         public Object run() {
342                             method.setAccessible(true);
343                             return null;
344                         }
345                     });
346
347                     return (Iterator) method.invoke(value, EMPTY_ARGUMENTS);
348                 }
349             } catch (Exception e) {
350                 // ignore
351 }
352         }
353         return asCollection(value).iterator();
354     }
355
356     /**
357      * @return true if the two objects are null or the objects are equal
358      */
359     public boolean objectsEqual(Object left, Object right) {
360         if (left == right) {
361             return true;
362         }
363         if (left != null) {
364             if (right == null) {
365                 return false;
366             }
367             if (left instanceof Comparable ) {
368                 return compareTo(left, right) == 0;
369             } else {
370                 return left.equals(right);
371             }
372         }
373         return false;
374     }
375
376     public String inspect(Object self) {
377         return format(self, true);
378     }
379
380     /**
381      * Compares the two objects handling nulls gracefully and performing numeric type coercion if required
382      */
383     public int compareTo(Object left, Object right) {
384         //System.out.println("Comparing: " + left + " to: " + right);
385 if (left == right) {
386             return 0;
387         }
388         if (left == null) {
389             return -1;
390         } else if (right == null) {
391             return 1;
392         }
393         if (left instanceof Comparable ) {
394             if (left instanceof Number ) {
395                 if (isValidCharacterString(right)) {
396                     return asCharacter((Number ) left).compareTo(asCharacter((String ) right));
397                 }
398                 return DefaultGroovyMethods.compareTo((Number ) left, asNumber(right));
399             } else if (left instanceof Character ) {
400                 if (isValidCharacterString(right)) {
401                     return ((Character ) left).compareTo(asCharacter((String ) right));
402                 } else if (right instanceof Number ) {
403                     return ((Character ) left).compareTo(asCharacter((Number ) right));
404                 }
405             } else if (right instanceof Number ) {
406                 if (isValidCharacterString(left)) {
407                     return asCharacter((String ) left).compareTo(asCharacter((Number ) right));
408                 }
409                 return DefaultGroovyMethods.compareTo(asNumber(left), (Number ) right);
410             } else if (left instanceof String && right instanceof Character ) {
411                 return ((String ) left).compareTo(right.toString());
412             }
413             Comparable comparable = (Comparable ) left;
414             return comparable.compareTo(right);
415         }
416         if (left.getClass().isArray()) {
417             Collection leftList = asCollection(left);
418             if (right.getClass().isArray()) {
419                 right = asCollection(right);
420             }
421             return ((Comparable ) leftList).compareTo(right);
422         }
423         /** todo we might wanna do some type conversion here */
424         throw new GroovyRuntimeException("Cannot compare values: " + left + " and " + right);
425     }
426
427     /**
428      * A helper method to provide some better toString() behaviour such as turning arrays
429      * into tuples
430      */
431     public String toString(Object arguments) {
432         return format(arguments, false);
433     }
434
435     /**
436      * A helper method to format the arguments types as a comma-separated list
437      */
438     public String toTypeString(Object [] arguments) {
439         if (arguments == null) {
440             return "null";
441         }
442         StringBuffer argBuf = new StringBuffer ();
443         for (int i = 0; i < arguments.length; i++) {
444             if (i > 0)
445                 argBuf.append(", ");
446             argBuf.append(arguments[i] != null ? arguments[i].getClass().getName() : "null");
447         }
448         return argBuf.toString();
449     }
450
451     protected String format(Object arguments, boolean verbose) {
452         if (arguments == null) {
453             return "null";
454         } else if (arguments.getClass().isArray()) {
455             return format(asCollection(arguments), verbose);
456         } else if (arguments instanceof Range) {
457             Range range = (Range) arguments;
458             if (verbose) {
459                 return range.inspect();
460             } else {
461                 return range.toString();
462             }
463         } else if (arguments instanceof List ) {
464             List list = (List ) arguments;
465             StringBuffer buffer = new StringBuffer ("[");
466             boolean first = true;
467             for (Iterator iter = list.iterator(); iter.hasNext();) {
468                 if (first) {
469                     first = false;
470                 } else {
471                     buffer.append(", ");
472                 }
473                 buffer.append(format(iter.next(), verbose));
474             }
475             buffer.append("]");
476             return buffer.toString();
477         } else if (arguments instanceof Map) {
478             Map map = (Map) arguments;
479             if (map.isEmpty()) {
480                 return "[:]";
481             }
482             StringBuffer buffer = new StringBuffer ("[");
483             boolean first = true;
484             for (Iterator iter = map.entrySet().iterator(); iter.hasNext();) {
485                 if (first) {
486                     first = false;
487                 } else {
488                     buffer.append(", ");
489                 }
490                 Map.Entry entry = (Map.Entry) iter.next();
491                 buffer.append(format(entry.getKey(), verbose));
492                 buffer.append(":");
493                 buffer.append(format(entry.getValue(), verbose));
494             }
495             buffer.append("]");
496             return buffer.toString();
497         } else if (arguments instanceof Element ) {
498             Element node = (Element ) arguments;
499             OutputFormat format = new OutputFormat(node.getOwnerDocument());
500             format.setOmitXMLDeclaration(true);
501             format.setIndenting(true);
502             format.setLineWidth(0);
503             format.setPreserveSpace(true);
504             StringWriter sw = new StringWriter ();
505             XMLSerializer serializer = new XMLSerializer(sw, format);
506             try {
507                 serializer.asDOMSerializer();
508                 serializer.serialize(node);
509             } catch (IOException e) {
510             }
511             return sw.toString();
512         } else if (arguments instanceof String ) {
513             if (verbose) {
514                 return "\"" + arguments + "\"";
515             } else {
516                 return (String ) arguments;
517             }
518         } else {
519             return arguments.toString();
520         }
521     }
522
523     /**
524      * Sets the property on the given object
525      *
526      * @param object
527      * @param property
528      * @param newValue
529      * @return
530      */
531     public void setProperty(Object object, String property, Object newValue) {
532         if (object == null) {
533             throw new GroovyRuntimeException("Cannot set property on null object");
534         } else if (object instanceof GroovyObject) {
535             GroovyObject pogo = (GroovyObject) object;
536             pogo.setProperty(property, newValue);
537         } else if (object instanceof Map) {
538             Map map = (Map) object;
539             map.put(property, newValue);
540         } else {
541             metaRegistry.getMetaClass(object.getClass()).setProperty(object, property, newValue);
542         }
543     }
544
545     /**
546      * Looks up the given property of the given object
547      *
548      * @param object
549      * @param property
550      * @return
551      */
552     public Object getProperty(Object object, String property) {
553         if (object == null) {
554             throw new NullPointerException ("Cannot get property: " + property + " on null object");
555         } else if (object instanceof GroovyObject) {
556             GroovyObject pogo = (GroovyObject) object;
557             return pogo.getProperty(property);
558         } else if (object instanceof Map) {
559             Map map = (Map) object;
560             return map.get(property);
561         } else {
562             return metaRegistry.getMetaClass(object.getClass()).getProperty(object, property);
563         }
564     }
565
566     public int asInt(Object value) {
567         if (value instanceof Number ) {
568             Number n = (Number ) value;
569             return n.intValue();
570         }
571         throw new GroovyRuntimeException("Could not convert object: " + value + " into an int");
572     }
573
574     public Number asNumber(Object value) {
575         if (value instanceof Number ) {
576             return (Number ) value;
577         } else if (value instanceof String ) {
578             String s = (String ) value;
579
580             if (s.length() == 1)
581                 return new Integer (s.charAt(0));
582             else
583                 return Double.valueOf(s);
584         } else if (value instanceof Character ) {
585             return new Integer (((Character ) value).charValue());
586         } else {
587             throw new GroovyRuntimeException("Could not convert object: " + value + " into a Number");
588         }
589     }
590
591     /**
592      * Attempts to load the given class via name using the current class loader
593      * for this code or the thread context class loader
594      */
595     protected Class loadClass(String type) {
596         try {
597             return getClass().getClassLoader().loadClass(type);
598         } catch (ClassNotFoundException e) {
599             try {
600                 return Thread.currentThread().getContextClassLoader().loadClass(type);
601             } catch (ClassNotFoundException e2) {
602                 try {
603                     return Class.forName(type);
604                 } catch (ClassNotFoundException e3) {
605                 }
606             }
607             throw new GroovyRuntimeException("Could not load type: " + type, e);
608         }
609     }
610
611     /**
612      * Find the right hand regex within the left hand string and return a matcher.
613      *
614      * @param left string to compare
615      * @param right regular expression to compare the string to
616      * @return
617      */
618     public Matcher objectFindRegex(Object left, Object right) {
619         String stringToCompare;
620         if (left instanceof String ) {
621             stringToCompare = (String ) left;
622         } else {
623             stringToCompare = toString(left);
624         }
625         String regexToCompareTo;
626         if (right instanceof String ) {
627             regexToCompareTo = (String ) right;
628         } else if (right instanceof Pattern ) {
629             Pattern pattern = (Pattern ) right;
630             return pattern.matcher(stringToCompare);
631         } else {
632             regexToCompareTo = toString(right);
633         }
634         Matcher matcher = Pattern.compile(regexToCompareTo).matcher(stringToCompare);
635         return matcher;
636     }
637
638     /**
639      * Find the right hand regex within the left hand string and return a matcher.
640      *
641      * @param left string to compare
642      * @param right regular expression to compare the string to
643      * @return
644      */
645     public boolean objectMatchRegex(Object left, Object right) {
646         Pattern pattern;
647         if (right instanceof Pattern ) {
648             pattern = (Pattern ) right;
649         } else {
650             pattern = Pattern.compile(toString(right));
651         }
652         String stringToCompare = toString(left);
653         Matcher matcher = pattern.matcher(stringToCompare);
654         RegexSupport.setLastMatcher(matcher);
655         return matcher.matches();
656     }
657
658     /**
659      * Compile a regular expression from a string.
660      *
661      * @param regex
662      * @return
663      */
664     public Pattern regexPattern(Object regex) {
665         return Pattern.compile(regex.toString());
666     }
667
668     public Object asType(Object object, Class type) {
669         if (object == null) {
670             return null;
671         }
672         if (type.isInstance(object)) {
673             return object;
674         }
675         if (type.equals(String .class)) {
676             return object.toString();
677         }
678         if (type.equals(Character .class)) {
679             if (object instanceof Number ) {
680                 return asCharacter((Number ) object);
681             } else {
682                 String text = object.toString();
683                 if (text.length() == 1) {
684                     return new Character (text.charAt(0));
685                 } else {
686                     throw new ClassCastException ("Cannot cast: " + text + " to a Character");
687                 }
688             }
689         }
690         if (Number .class.isAssignableFrom(type)) {
691             if (object instanceof Character ) {
692                 return new Integer (((Character ) object).charValue());
693             } else if (object instanceof String ) {
694                 String c = (String ) object;
695                 if (c.length() == 1) {
696                     return new Integer (c.charAt(0));
697                 } else {
698                     throw new ClassCastException ("Cannot cast: '" + c + "' to an Integer");
699                 }
700             }
701         }
702         if (object instanceof Number ) {
703             Number n = (Number ) object;
704             if (type.isPrimitive()) {
705                 if (type == byte.class) {
706                     return new Byte (n.byteValue());
707                 }
708                 if (type == char.class) {
709                     return new Character ((char) n.intValue());
710                 }
711                 if (type == short.class) {
712                     return new Short (n.shortValue());
713                 }
714                 if (type == int.class) {
715                     return new Integer (n.intValue());
716                 }
717                 if (type == long.class) {
718                     return new Long (n.longValue());
719                 }
720                 if (type == float.class) {
721                     return new Float (n.floatValue());
722                 }
723                 if (type == double.class) {
724                     Double answer = new Double (n.doubleValue());
725                     //throw a runtime exception if conversion would be out-of-range for the type.
726 if (!(n instanceof Double ) && (answer.doubleValue() == Double.NEGATIVE_INFINITY
727                             || answer.doubleValue() == Double.POSITIVE_INFINITY)) {
728                         throw new GroovyRuntimeException("Automatic coercion of " + n.getClass().getName()
729                                 + " value " + n + " to double failed. Value is out of range.");
730                     }
731                     return answer;
732                 }
733             } else {
734                 if (Number .class.isAssignableFrom(type)) {
735                     if (type == Byte .class) {
736                         return new Byte (n.byteValue());
737                     }
738                     if (type == Character .class) {
739                         return new Character ((char) n.intValue());
740                     }
741                     if (type == Short .class) {
742                         return new Short (n.shortValue());
743                     }
744                     if (type == Integer .class) {
745                         return new Integer (n.intValue());
746                     }
747                     if (type == Long .class) {
748                         return new Long (n.longValue());
749                     }
750                     if (type == Float .class) {
751                         return new Float (n.floatValue());
752                     }
753                     if (type == Double .class) {
754                         Double answer = new Double (n.doubleValue());
755                         //throw a runtime exception if conversion would be out-of-range for the type.
756 if (!(n instanceof Double ) && (answer.doubleValue() == Double.NEGATIVE_INFINITY
757                                 || answer.doubleValue() == Double.POSITIVE_INFINITY)) {
758                             throw new GroovyRuntimeException("Automatic coercion of " + n.getClass().getName()
759                                     + " value " + n + " to double failed. Value is out of range.");
760                         }
761                         return answer;
762                     }
763
764                 }
765             }
766         }
767         if (type == Boolean .class) {
768             return asBool(object) ? Boolean.TRUE : Boolean.FALSE;
769         }
770         return object;
771     }
772
773     public boolean asBool(Object object) {
774         if (object instanceof Boolean ) {
775             Boolean booleanValue = (Boolean ) object;
776             return booleanValue.booleanValue();
777         } else if (object instanceof Matcher ) {
778             Matcher matcher = (Matcher ) object;
779             RegexSupport.setLastMatcher(matcher);
780             return matcher.find();
781         } else if (object instanceof Collection) {
782             Collection collection = (Collection) object;
783             return !collection.isEmpty();
784         } else if (object instanceof Number ) {
785             Number n = (Number ) object;
786             return n.doubleValue() != 0;
787         } else {
788             return object != null;
789         }
790     }
791
792     protected Character asCharacter(Number value) {
793         return new Character ((char) value.intValue());
794     }
795
796     protected Character asCharacter(String text) {
797         return new Character (text.charAt(0));
798     }
799
800     /**
801      * @return true if the given value is a valid character string (i.e. has length of 1)
802      */
803     protected boolean isValidCharacterString(Object value) {
804         if (value instanceof String ) {
805             String s = (String ) value;
806             if (s.length() == 1) {
807                 return true;
808             }
809         }
810         return false;
811     }
812
813     public void removeMetaClass(Class clazz) {
814         getMetaRegistry().removeMetaClass(clazz);
815     }
816 }
817

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags