Coverage Report

Coverage Report - org.webmacro.engine.IntrospectionUtils

Classes in this File

Line Coverage

Branch Coverage

Complexity

IntrospectionUtils

48%

18/37

39%

23/58

10.25

 /*
  * Copyright (C) 1998-2000 Semiotek Inc.  All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted under the terms of either of the following
  * Open Source licenses:
  *
  * The GNU General Public License, version 2, or any later version, as
  * published by the Free Software Foundation
  * (http://www.fsf.org/copyleft/gpl.html);
  *
  *  or
  *
  * The Semiotek Public License (http://webmacro.org/LICENSE.)
  *
  * This software is provided "as is", with NO WARRANTY, not even the
  * implied warranties of fitness to purpose, or merchantability. You
  * assume all risks and liabilities associated with its use.
  *
  * See www.webmacro.org for more information on the WebMacro project.
  */
 package org.webmacro.engine;
 
 /**
  *
  * @author  Keats
  * @since May 25, 2002
  */
 public final class IntrospectionUtils
 {
 
     /** Deny instantiation */
     private IntrospectionUtils ()
     {
     }
 
     static boolean matches (Class[] sig, Class[] args)
     {
         if (args.length != sig.length)
             return false;
 
         try
         {
             for (int i = 0; i < sig.length; i++)
             {
                 Class s = sig[i];
                 Class a = args[i];
                 if (s.isPrimitive())
                 {
                     if ((s == Integer.TYPE && a == Integer.class) ||
                             (s == Boolean.TYPE && a == Boolean.class) ||
                             (s == Character.TYPE && a == Character.class) ||
                             (s == Long.TYPE && a == Long.class) ||
                             (s == Short.TYPE && a == Short.class) ||
                             (s == Double.TYPE && a == Double.class) ||
                             (s == Float.TYPE && a == Float.class) ||
                             (s == Void.TYPE && a == Void.class) ||
                             (s == Byte.TYPE && a == Byte.class))
                         continue;
                     else
                         return false;
                 }
                 else if (a == null || s.isAssignableFrom(a))
                     continue;
                 else
                     return false;
             }
         }
         catch (NullPointerException e)
         {
             return false; // XXX: block nulls, isAssignableFrom throws this
         }
         return true;
     }
 
     static public Class[] createTypesFromArgs (Object[] args)
     {
         Class[] types = new Class[args.length];
         for (int i = 0; i < args.length; i++)
         {
             try
             {
                 types[i] = args[i].getClass();
             }
             catch (NullPointerException e)
             {
                 types[i] = null;
             }
         }
         return types;
     }
 
     /** Attempt to instantiate a class with the supplied args. */
     static public Object instantiate (Class c, Object[] args)
             throws Exception
     {
         Object o = null;
         if (args == null || args.length == 0)
         {
             o = c.newInstance(); // no arg constructor
         }
         else
         {
             // try each constructor with the right number of args,
             // until one works or all have failed
             java.lang.reflect.Constructor[] cons = c.getConstructors();
             for (int i = 0; i < cons.length; i++)
             {
                 if (cons[i].getParameterTypes().length == args.length)
                 {
                     // try to instantiate using this constructor
                     try
                     {
                         o = cons[i].newInstance(args);
                         break; // if successful, we're done!
                     }
                     catch (Exception e)
                     {
                       // ignore this failure, try the next one
                     }
                 }
             }
             if (o == null)
             {
                 throw new InstantiationException(
                         "Unable to construct object of type " + c.getName()
                         + " using the supplied arguments: "
                         + java.util.Arrays.asList(args).toString());
             }
         }
         return o;
     }
 }

1		/*
2		* Copyright (C) 1998-2000 Semiotek Inc. All Rights Reserved.
3		*
4		* Redistribution and use in source and binary forms, with or without
5		* modification, are permitted under the terms of either of the following
6		* Open Source licenses:
7		*
8		* The GNU General Public License, version 2, or any later version, as
9		* published by the Free Software Foundation
10		* (http://www.fsf.org/copyleft/gpl.html);
11		*
12		* or
13		*
14		* The Semiotek Public License (http://webmacro.org/LICENSE.)
15		*
16		* This software is provided "as is", with NO WARRANTY, not even the
17		* implied warranties of fitness to purpose, or merchantability. You
18		* assume all risks and liabilities associated with its use.
19		*
20		* See www.webmacro.org for more information on the WebMacro project.
21		*/
22		package org.webmacro.engine;
23
24		/**
25		*
26		* @author Keats
27		* @since May 25, 2002
28		*/
29		public final class IntrospectionUtils
30		{
31
32		/** Deny instantiation */
33		private IntrospectionUtils ()
34	0	{
35	0	}
36
37		static boolean matches (Class[] sig, Class[] args)
38		{
39	352	if (args.length != sig.length)
40	13	return false;
41
42		try
43		{
44	547	for (int i = 0; i < sig.length; i++)
45		{
46	210	Class s = sig[i];
47	210	Class a = args[i];
48	210	if (s.isPrimitive())
49		{
50	24	if ((s == Integer.TYPE && a == Integer.class) \|\|
51		(s == Boolean.TYPE && a == Boolean.class) \|\|
52		(s == Character.TYPE && a == Character.class) \|\|
53		(s == Long.TYPE && a == Long.class) \|\|
54		(s == Short.TYPE && a == Short.class) \|\|
55		(s == Double.TYPE && a == Double.class) \|\|
56		(s == Float.TYPE && a == Float.class) \|\|
57		(s == Void.TYPE && a == Void.class) \|\|
58		(s == Byte.TYPE && a == Byte.class))
59	0	continue;
60		else
61	1	return false;
62		}
63	186	else if (a == null \|\| s.isAssignableFrom(a))
64	175	continue;
65		else
66	1	return false;
67		}
68		}
69	0	catch (NullPointerException e)
70		{
71	0	return false; // XXX: block nulls, isAssignableFrom throws this
72	337	}
73	337	return true;
74		}
75
76		static public Class[] createTypesFromArgs (Object[] args)
77		{
78	53	Class[] types = new Class[args.length];
79	106	for (int i = 0; i < args.length; i++)
80		{
81		try
82		{
83	53	types[i] = args[i].getClass();
84		}
85	0	catch (NullPointerException e)
86		{
87	0	types[i] = null;
88	53	}
89		}
90	53	return types;
91		}
92
93		/** Attempt to instantiate a class with the supplied args. */
94		static public Object instantiate (Class c, Object[] args)
95		throws Exception
96		{
97	0	Object o = null;
98	0	if (args == null \|\| args.length == 0)
99		{
100	0	o = c.newInstance(); // no arg constructor
101		}
102		else
103		{
104		// try each constructor with the right number of args,
105		// until one works or all have failed
106	0	java.lang.reflect.Constructor[] cons = c.getConstructors();
107	0	for (int i = 0; i < cons.length; i++)
108		{
109	0	if (cons[i].getParameterTypes().length == args.length)
110		{
111		// try to instantiate using this constructor
112		try
113		{
114	0	o = cons[i].newInstance(args);
115	0	break; // if successful, we're done!
116		}
117	0	catch (Exception e)
118		{
119		// ignore this failure, try the next one
120		}
121		}
122		}
123	0	if (o == null)
124		{
125	0	throw new InstantiationException(
126		"Unable to construct object of type " + c.getName()
127		+ " using the supplied arguments: "
128		+ java.util.Arrays.asList(args).toString());
129		}
130		}
131	0	return o;
132		}
133		}