/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can obtain
* a copy of the License at https://glassfish.dev.java.net/public/CDDL+GPL.html
* or glassfish/bootstrap/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at glassfish/bootstrap/legal/LICENSE.txt.
* Sun designates this particular file as subject to the "Classpath" exception
* as provided by Sun in the GPL Version 2 section of the License file that
* accompanied this code. If applicable, add the following below the License
* Header, with the fields enclosed by brackets [] replaced by your own
* identifying information: "Portions Copyrighted [year]
* [name of copyright owner]"
*
* Contributor(s):
*
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
/*
* $Header: /cvs/glassfish/appserv-api/src/java/com/sun/appserv/management/util/misc/ClassUtil.java,v 1.2 2007/05/05 05:31:05 tcfujii Exp $
* $Revision: 1.2 $
* $Date: 2007/05/05 05:31:05 $
*/
package com.sun.appserv.management.util.misc;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.ClassLoader;
import java.util.Set;
import java.util.HashSet;
/*
Used internally.
*/
final class ClassToClassMapping
{
final Class mSrc;
final Class mDest;
public
ClassToClassMapping( Class src, Class dest )
{
mSrc = src;
mDest = dest;
}
}
/**
Provides a variety of useful utilities having to do with classes, types of
objects, etc.
*/
public final class ClassUtil
{
private
ClassUtil( )
{
// disallow instantiation
}
public static boolean
classIsAccessible( String name )
{
boolean accessible = false;
try
{
accessible = getClassFromName( name ) != null;
}
catch( ClassNotFoundException e )
{
}
return( accessible );
}
public static boolean
sigsEqual(
final Class[] sig1,
final Class[] sig2 )
{
boolean equal = sig1.length == sig2.length;
if ( equal )
{
for( int i = 0; i < sig1.length; ++i )
{
if ( sig1[ i ] != sig2[ i ] )
{
equal = false;
break;
}
}
}
return( equal );
}
/**
Test whether an Object is an array
@param o object to test
@return true if the object is an array, false otherwise.
*/
public static boolean
objectIsArray( Object o )
{
return( classIsArray( o.getClass() ) );
}
/**
Test whether a Class is an array
@param theClass class to test
@return true if the class is an array, false otherwise.
*/
public static boolean
classIsArray( Class theClass )
{
return( classnameIsArray( theClass.getName() ) );
}
/**
Test whether an Object is an array of primitive types
@param o object to test
@return true if the object is an array, false otherwise.
*/
public static boolean
objectIsPrimitiveArray( Object o )
{
return( getPrimitiveArrayTypeCode( o.getClass() ) != 0 );
}
/**
Test whether a classname is an array
@param classname classname string
@return true if the object is an array, false otherwise.
*/
public static boolean
classnameIsArray( String classname )
{
return( classname.startsWith( "[" ) );
}
/**
Strip the package name.
@param classname classname string
@return the classname, without its package
*/
public static String
stripPackageName( String classname )
{
final int lastDot = classname.lastIndexOf( "." );
if ( lastDot < 0 )
{
return( classname );
}
return( classname.substring( lastDot + 1, classname.length() ) );
}
/**
Test whether a classname is a primitive array
@param classname classname string
@return true if the object is a primitive array, false otherwise.
*/
public static boolean
classnameIsPrimitiveArray( String classname )
{
return( getPrimitiveArrayTypeCode( classname ) != 0 );
}
/**
Return the primitive element type code for an array of primitive types.
Same as getPrimitiveArrayTypeCode( theClass.getName() )
@param theClass the Class object
@return the element type code; otherwise (char)0
*/
public static char
getPrimitiveArrayTypeCode( Class theClass )
{
char typeCode = 0;
if ( classIsArray( theClass ) )
{
typeCode = getPrimitiveArrayTypeCode( theClass.getName() );
}
return( typeCode );
}
/**
Return the primitive element type code for an array of primitive types.
@param classname classname string
@return the element type code; otherwise (char)0
*/
public static char
getPrimitiveArrayTypeCode( String classname )
{
char typeCode = 0;
final int length = classname.length();
if ( classnameIsArray( classname ) &&
classname.charAt( length - 2 ) == '[' )
{
typeCode = classname.charAt( length - 1 );
switch( typeCode )
{
default: typeCode = 0; break;
case 'Z':
case 'B':
case 'C':
case 'S':
case 'I':
case 'J':
case 'F':
case 'D':
break;
}
}
return( typeCode );
}
/**
Get the classname for an array element.
@param classname classname string
@return the classname for the array element
*/
public static String
getArrayMemberClassName( String classname )
{
String result = null;
if ( ! classnameIsArray( classname ) )
{
throw new IllegalArgumentException( "not an array" );
}
final int classnameLength = classname.length();
if ( classnameIsPrimitiveArray( classname ) )
{
final char lastChar = classname.charAt(classnameLength -1 );
switch( lastChar )
{
default: throw new RuntimeException( "illegal primitive" );
// a simple type
case 'Z': result = "boolean"; break;
case 'B': result = "byte"; break;
case 'C': result = "char"; break;
case 'S': result = "short"; break;
case 'I': result = "int"; break;
case 'J': result = "long"; break;
case 'F': result = "float"; break;
case 'D': result = "double"; break;
}
}
else
{
// strip leading "[L" and trailing ";"
result = classname.substring( 2, classnameLength - 1 );
}
return( result );
}
/**
Class.forName does not work for primitive types, so we need to do it ourselves here.
*/
final static class ClassNameToClassMapping
{
String mName;
Class mClass;
ClassNameToClassMapping( String name, Class theClass )
{
mName = name;
mClass = theClass;
}
}
private static final ClassNameToClassMapping [] sPrimitiveNameToObjectClass =
new ClassNameToClassMapping []
{
new ClassNameToClassMapping( "int", int.class ),
new ClassNameToClassMapping( "long", long.class ),
new ClassNameToClassMapping( "short", short.class ),
new ClassNameToClassMapping( "byte", byte.class ),
new ClassNameToClassMapping( "boolean", boolean.class ),
new ClassNameToClassMapping( "float", float.class ),
new ClassNameToClassMapping( "double", double.class ),
new ClassNameToClassMapping( "char", char.class ),
new ClassNameToClassMapping( "void", void.class ),
};
public static Class<?>
classForName( String name )
throws ClassNotFoundException
{
Class<?> c = null;
try
{
c = Class.forName( name );
}
catch ( ClassNotFoundException e )
{
c = Class.forName( name, true, Thread.currentThread().getContextClassLoader() );
}
catch ( NoClassDefFoundError e )
{
c = Class.forName( name, true, Thread.currentThread().getContextClassLoader() );
}
return( c );
}
/**
Get a Class from a classname. Class.forName does not work for primitive types;
this methods returns the correct Class for any type.
@param classname classname string
@return the classname for the array element
*/
public static Class
getClassFromName( final String classname )
throws ClassNotFoundException
{
Class theClass = null;
if ( classname.startsWith( "[L" ))
{
// an array
theClass = classForName( classname );
}
else
{
final int numMappings = Array.getLength( sPrimitiveNameToObjectClass );
for( int i = 0; i < numMappings; ++i )
{
if ( sPrimitiveNameToObjectClass[ i ].mName.equals( classname ) )
{
theClass = sPrimitiveNameToObjectClass[ i ].mClass;
break;
}
}
if ( theClass == null )
{
theClass = classForName( classname );
}
}
return( theClass );
}
private static final ClassToClassMapping [] sPrimitiveClassToObjectClass =
new ClassToClassMapping []
{
new ClassToClassMapping( boolean.class, Boolean.class),
new ClassToClassMapping( byte.class, Byte.class ),
new ClassToClassMapping( char.class, Character.class ),
new ClassToClassMapping( short.class, Short.class ),
new ClassToClassMapping( int.class, Integer.class ),
new ClassToClassMapping( long.class, Long.class ),
new ClassToClassMapping( float.class, Float.class ),
new ClassToClassMapping( double.class, Double.class ),
};
/**
Map primitive class Classes to Object forms eg int.class to Integer.class
@param theClass the class to map
@return the corresponding Object class or the original Class if not a primitive.
*/
public static Class
PrimitiveClassToObjectClass( final Class theClass )
{
Class result = theClass;
final int numMappings = Array.getLength( sPrimitiveClassToObjectClass );
for( int i = 0; i < numMappings; ++i )
{
final ClassToClassMapping mapping = sPrimitiveClassToObjectClass[ i ];
if ( mapping.mSrc == theClass )
{
result = mapping.mDest;
break;
}
}
return( result );
}
/**
Map primitive class Classes to Object forms eg int.class to Integer.class
@param theClass the class to map
@return the corresponding Object class or the original Class if not a primitive.
*/
public static Class
ObjectClassToPrimitiveClass( final Class theClass )
{
Class result = theClass;
final int numMappings = Array.getLength( sPrimitiveClassToObjectClass );
for( int i = 0; i < numMappings; ++i )
{
final ClassToClassMapping mapping = sPrimitiveClassToObjectClass[ i ];
if ( mapping.mDest == theClass )
{
result = mapping.mSrc;
break;
}
}
return( result );
}
/**
Test whether a class is a primitive class.
@param theClass the class to test
@return true if it's a primitive class, false otherwise.
*/
public static boolean
IsPrimitiveClass( final Class theClass )
{
boolean isSimple = false;
final int numMappings = Array.getLength( sPrimitiveClassToObjectClass );
for( int i = 0; i < numMappings; ++i )
{
final ClassToClassMapping mapping = sPrimitiveClassToObjectClass[ i ];
if ( mapping.mSrc.equals( theClass ) )
{
isSimple = true;
break;
}
}
return( isSimple );
}
/**
Convert a primitive class letter to its corresponding class name.
@param primitive the primitive character code
@return the corresponding classname
*/
public static String
PrimitiveLetterToClassName( final char primitive)
{
String result = "" + primitive;
// see JavaDoc on Class.getName()
switch( primitive )
{
case 'B': result = "byte"; break;
case 'C': result = "char"; break;
case 'D': result = "double"; break;
case 'F': result = "float"; break;
case 'I': result = "int"; break;
case 'J': result = "long"; break;
case 'S': result = "short"; break;
case 'Z': result = "boolean";break;
}
return( result );
}
/**
Return the corresponding classes for each element in an Object[]
If an element is null, then its corresponding Class will also be null.
@param args an array of objects.
@return an array of classes
*/
public static String []
getTypes( final Object [] args )
{
if ( args == null )
return( null );
final int numArgs = Array.getLength( args );
final String [] types = new String [ numArgs ];
for( int i = 0; i < numArgs; ++i )
{
if ( args[ i ] == null )
{
types[ i ] = null;
}
else
{
types[ i ] = args[ i ].getClass().getName();
}
}
return( types );
}
/**
Return the corresponding classes for each classname.
If an element is null, then its corresponding Class will also be null.
@param classnames an array of classnames.
@return an array of classes
*/
public static Class[]
signatureFromClassnames( String[] classnames )
throws ClassNotFoundException
{
if ( classnames == null )
{
return( null );
}
final Class[] signature = new Class[ classnames.length ];
for ( int i = 0; i < signature.length; ++i )
{
signature[ i ] = getClassFromName( classnames[ i ] );
}
return( signature );
}
/**
Return the corresponding classes for each classname.
If an element is null, then its corresponding Class will also be null.
@param classes an array of classnames.
@return an array of classes
*/
public static String[]
classnamesFromSignature( Class[] classes )
{
final String[] classnames = new String[ classes.length ];
for ( int i = 0; i < classnames.length; ++i )
{
classnames[ i ] = classes[ i ].getName();
}
return( classnames );
}
/**
Get a "friendly" classname for a Class.
<p>
Calls getFriendlyClassname( theClass.getName() )
@param theClass the class for which the name should be gotten
@return the "friendly" name
*/
public static String
getFriendlyClassname( Class theClass )
{
return( getFriendlyClassname( theClass.getName() ) );
}
/**
Convert a Java class name string into a more user friendly string. Examples:
<p>
java.lang.String => String
java.lang.<type> => <type>;
[i => int[]
[Lfoo.bar.ClassName; => foo.bar.ClassName[]
<p>
The names returned correspond exactly to what a Java programmer would write, rather
than the internal JVM representation.
@param type
@return a friendlier string representing the type
*/
final static String javaLang = "java.lang.";
public static String
getFriendlyClassname( String type )
{
String result = type;
if ( type.startsWith( "[" ) )
{
// count how deep the array is
int depth = 0;
while ( type.charAt( depth ) == (int)'[' )
{
++depth;
}
// strip all the '[' characters
result = type.substring( depth, type.length() );
if ( result.startsWith( "L" ) && result.endsWith( ";" ) )
{
result = result.substring( 1, result.length() - 1 );
}
else if ( result.length() == 1 )
{
// a simple type
switch( result.charAt( 0 ) )
{
case 'Z': result = "boolean"; break;
case 'B': result = "byte"; break;
case 'C': result = "char"; break;
case 'S': result = "short"; break;
case 'I': result = "int"; break;
case 'J': result = "long"; break;
case 'F': result = "float"; break;
case 'D': result = "double"; break;
}
}
for( int i = 0; i < depth; ++i )
{
result = result + "[]";
}
}
if ( result.startsWith( javaLang ) )
{
result = result.substring( javaLang.length(), result.length() );
}
return( result );
}
/*
*/
public static int
getArrayDimensions( final Class theClass )
{
final String classname = theClass.getName();
int dim = 0;
while ( classname.charAt( dim ) == '[' )
{
++dim;
}
return( dim );
}
/*
*/
public static Class
getArrayElementClass( final Class arrayClass )
{
final String arrayClassName = arrayClass.getName();
if ( ! classnameIsArray( arrayClassName ) )
{
throw new IllegalArgumentException( "not an array" );
}
String name = arrayClassName;
// strip leading "["
name = name.substring( 1, name.length() );
if ( ! name.startsWith( "[" ) )
{
// element is not an array
if ( name.startsWith( "L" ) )
{
// an Object class; strip leading "L" and trailing ";"
name = name.substring( 1, name.length() - 1);
}
else if ( name.length() == 1 )
{
// may be a primitive type
name = PrimitiveLetterToClassName( name.charAt( 0 ) );
}
}
else
{
// element is an array; return it
}
Class theClass = null;
try
{
theClass = getClassFromName( name );
}
catch( ClassNotFoundException e )
{
assert( false );
}
return( theClass );
}
public static Class
getInnerArrayElementClass( final Class arrayClass )
throws ClassNotFoundException
{
Class elementClass = arrayClass;
do
{
elementClass = getArrayElementClass( elementClass );
}
while ( classIsArray( elementClass ) );
return( elementClass );
}
private static Object
InstantiateObject( final String theString )
throws Exception
{
Object result = null;
try
{
result = InstantiateNumber( theString );
}
catch( NumberFormatException e )
{
result = theString;
}
return( result );
}
/**
Return true if caller signature is compatible with callee.
@param callee the signature of the method to be called
@param argsSignature the signature of the argument list
*/
public static boolean
signaturesAreCompatible( final Class<?> [] callee, final Class<?> [] argsSignature )
{
boolean compatible = false;
if ( callee.length == argsSignature.length )
{
compatible = true;
for( int i = 0; i < callee.length; ++i )
{
if ( ! callee[ i ].isAssignableFrom( argsSignature[ i ] ) )
{
compatible = false;
break;
}
}
}
return( compatible );
}
/**
Find all methods that match the name.
*/
public static final Method
findMethod(
final Class theClass,
final String methodName,
final Class[] sig )
{
Method m = null;
try
{
m = theClass.getMethod( methodName, sig );
}
catch( NoSuchMethodException e )
{
// ok, doesn't exist
}
return( m );
}
/**
Find all methods that match the name.
*/
public static final Set<Method>
findMethods(
final Method[] candidates,
final String methodName )
{
final Set<Method> s = new HashSet<Method>();
for( int methodIdx = 0; methodIdx < candidates.length; ++methodIdx )
{
final Method method = candidates[ methodIdx ];
if ( method.getName().equals( methodName ) )
{
s.add( method );
}
}
return( s );
}
/**
Create a new object of the specified class using a constructor
that accepts the specified arguments.
@param theClass the Class of the desired Object
@param args the argument list for the constructor
*/
public static Object
InstantiateObject( final Class theClass, final Object [] args )
throws Exception
{
final Class [] signature = new Class [ args.length ];
for( int i = 0; i < signature.length; ++i )
{
signature[ i ] = args[ i ].getClass();
}
Constructor constructor = null;
try
{
// this will fail if a constructor takes an interface;
// the code below will then find a compatible constructor
constructor = theClass.getConstructor( signature );
}
catch( NoSuchMethodException e )
{
final Constructor [] constructors = theClass.getConstructors();
int numMatches = 0;
for( int i = 0; i < constructors.length; ++i )
{
final Constructor tempConstructor = constructors[ i ];
final Class [] tempSignature = tempConstructor.getParameterTypes();
if ( signaturesAreCompatible( tempSignature, signature ) )
{
++numMatches;
constructor = tempConstructor;
// keep going; there could be more than one valid match
}
}
// to succeed, there must be exactly one match
if ( numMatches != 1 )
{
throw e;
}
}
Object result = null;
try
{
result = constructor.newInstance( args );
}
catch( java.lang.reflect.InvocationTargetException e )
{
// InvocationTargetException wraps the real cause
final Throwable cause = e.getCause();
if ( cause instanceof Exception )
{
throw (Exception)cause;
}
else
{
// shouldn't happen, so we'll just rethrow it
throw e;
}
}
return( result );
}
/**
Create a new object of the specified class using a String constructor.
@param theClass the Class of the desired Object
@param theString the string for a String constructor
@return the resulting Object
*/
public static Object
InstantiateObject( final Class theClass, final String theString )
throws Exception
{
final Class [] signature = new Class [] { String.class };
final Constructor constructor = theClass.getConstructor( signature );
Object result = null;
try
{
result = constructor.newInstance( new Object[] { theString } );
}
catch( java.lang.reflect.InvocationTargetException e )
{
// InvocationTargetException wraps the real cause
Throwable cause = e.getCause();
if ( cause instanceof Exception )
{
throw (Exception)cause;
}
else
{
// shouldn't happen, so we'll just rethrow it
throw e;
}
}
return( result );
}
/**
Create a new number based on a String.
<p>
Don't get fancy here, simple precedence:
Integer, Long if no decimal point, use Long if won't fit in an Integer
Double if decimal point (for maximum precision)
@param theString String representation of the number
@return the resulting Object
*/
private static Object
InstantiateNumber( final String theString )
throws Exception
{
Object result = null;
if ( theString.indexOf( '.' ) >= 0 )
{
result = InstantiateObject( Double.class, theString );
}
else
{
try
{
result = InstantiateObject( Integer.class, theString );
}
catch( NumberFormatException e )
{
// perhaps it wouldn't fit; try it as a long
result = InstantiateObject( Long.class, theString );
}
}
return( result );
}
/**
Given a Class and a String, create a new instance with a constructor that accept
a String. Primitive types are instantiated as their equivalent Object forms.
@param theClass the class from which an instance should be instantiated
@param theString the string to be supplied to the constructor
@return the resulting Object
*/
public static Object
InstantiateFromString( final Class theClass, final String theString )
throws Exception
{
Object result = null;
// char and Character do not have a String constructor, so we must special-case it
if ( theClass == Object.class )
{
// special case, apply rules to create an object
result = InstantiateObject( theString );
}
else if ( theClass == Number.class )
{
// special case, apply rules to create a number
result = InstantiateNumber( theString );
}
else if ( theClass == Character.class || theClass == char.class)
{
if ( theString.length() != 1 )
{
throw new IllegalArgumentException( "not a character: " + theString );
}
result = new Character( theString.charAt( 0 ) );
}
else
{
final Class objectClass = PrimitiveClassToObjectClass( theClass );
result = InstantiateObject( objectClass, theString );
}
return( result );
}
/**
Given a Class, create a new instance with an empty constructor.
Primitive types are instantiated as their equivalent Object forms.
Any value is acceptable in the newly created object.
@param inClass the class from which an instance should be instantiated
@return the resulting Object
*/
public static Object
InstantiateDefault( final Class inClass )
throws Exception
{
Object result = null;
final Class objectClass = PrimitiveClassToObjectClass( inClass );
if ( Number.class.isAssignableFrom( objectClass ) )
{
result = InstantiateFromString( objectClass, "0" );
}
else if ( objectClass == Boolean.class)
{
result = new Boolean( "true" );
}
else if ( objectClass == Character.class)
{
result = new Character( 'X' );
}
else if ( classIsArray( objectClass ) )
{
result = Array.newInstance( objectClass, 0 );
}
else if ( objectClass == Object.class )
{
result = new String( "anyObject" );
}
else if ( objectClass == String.class )
{
result = new String( "" );
}
else if ( objectClass == java.net.URL.class )
{
result = new java.net.URL( "http://www.sun.com" );
}
else if ( objectClass == java.net.URI.class )
{
result = new java.net.URI( "http://www.sun.com" );
}
else if ( classIsArray( inClass ) )
{
final int dimensions = 3;
result = Array.newInstance( getInnerArrayElementClass( inClass ), dimensions );
}
else
{
result = objectClass.newInstance();
//result = InstantiateFromString( objectClass, "0" );
}
return( result );
}
final static String [] sJavaLangTypes =
{ "Character", "Boolean", "Byte", "Short", "Integer", "Long", "Float", "Double", "String", "Object"};
final static int sNumBaseTypes = Array.getLength( sJavaLangTypes );
/**
Expand an abbreviated classname into its true java name.
Turn "Integer" into "java.lang.Integer", etc.
*/
public static String
ExpandClassName( final String name )
{
String fullName = name;
final int numTypes = sNumBaseTypes;
for( int i = 0; i < numTypes; ++i )
{
if ( name.equals( sJavaLangTypes[ i ] ) )
{
fullName = "java.lang." + name;
break;
}
}
if ( fullName == name ) // no match so far
{
if ( name.equals( "Number" ) )
{
fullName = "java.lang." + name;
}
else if ( name.equals( "BigDecimal" ) || name.equals( "BigInteger" ) )
{
fullName = "java.math." + name;
}
else if ( name.equals( "URL" ) || name.equals( "URI" ) )
{
fullName = "java.net." + name;
}
else if ( name.equals( "Date" ) )
{
fullName = "java.util." + name;
}
else if ( name.equals( "ObjectName" ) )
{
fullName = "javax.management." + name;
}
}
return( fullName );
}
/**
Convert inner element to another type. Only works for arrays of Objects. Example:
convertArrayClass( "[[[LObject;", "Long" ) =>[[[LLong;
@param arrayClass
@param newInnerType the desired Class of the innermost element
*/
public static Class
convertArrayClass( final Class arrayClass, final Class newInnerType )
throws ClassNotFoundException
{
final String arrayClassname = arrayClass.getName();
if ( ! arrayClassname.endsWith( ";" ) )
{
throw new IllegalArgumentException( "not an array of Object" );
}
final int innerNameBegin = 1 + arrayClassname.indexOf( "L" );
final String newClassName = arrayClassname.substring( 0, innerNameBegin ) + newInnerType.getName() + ";";
final Class newClass = getClassFromName( newClassName );
return( newClass );
}
private static class MyClassLoader extends ClassLoader
{
MyClassLoader( )
{
this( Thread.currentThread().getContextClassLoader() );
}
MyClassLoader( ClassLoader cl )
{
super( cl );
}
public Package[]
getPackages()
{
return( super.getPackages() );
}
}
public static Package[]
getPackages()
{
return( new MyClassLoader().getPackages() );
}
public static Package[]
getPackages( ClassLoader cl )
{
return( new MyClassLoader( cl ).getPackages( ) );
}
/**
*/
public static Object
getFieldValue(
final Class theInterface,
final String name )
{
Object value = null;
try
{
final Field field = theInterface.getField( name );
value = field.get( theInterface );
}
catch( Exception e )
{
value = null;
}
return( value );
}
public static String
stripPackagePrefix( final String classname )
{
final int index = classname.lastIndexOf( "." );
String result = classname;
if ( index > 0 )
{
result = classname.substring( index + 1, classname.length() );
}
return( result );
};
public static String
getPackagePrefix( final String classname )
{
final int index = classname.lastIndexOf( "." );
String result = classname;
if ( index > 0 )
{
result = classname.substring( 0, index );
}
return( result );
};
}
|
