Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2003-2007 the original author or authors.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package groovy.inspect;
 
 
 import java.util.*;

The Inspector provides a unified access to an object's information that can be determined by introspection.

Author(s):
Dierk Koenig
 
 public class Inspector {
     protected Object objectUnderInspection;
 
     // Indexes to retrieve Class Property information
     public static final int CLASS_PACKAGE_IDX       = 0;
     public static final int CLASS_CLASS_IDX         = 1;
     public static final int CLASS_INTERFACE_IDX     = 2;
     public static final int CLASS_SUPERCLASS_IDX    = 3;
     public static final int CLASS_OTHER_IDX         = 4;
 
     // Indexes to retrieve field and method information
     public static final int MEMBER_ORIGIN_IDX = 0;
     public static final int MEMBER_MODIFIER_IDX = 1;
     public static final int MEMBER_DECLARER_IDX = 2;
     public static final int MEMBER_TYPE_IDX = 3;
     public static final int MEMBER_NAME_IDX = 4;
     public static final int MEMBER_PARAMS_IDX = 5;
     public static final int MEMBER_VALUE_IDX = 5;
     public static final int MEMBER_EXCEPTIONS_IDX = 6;
 
     public static final String NOT_APPLICABLE = "n/a";
     public static final String GROOVY = "GROOVY";
     public static final String JAVA = "JAVA";

    

Parameters:
objectUnderInspection must not be null
 
     public Inspector(Object objectUnderInspection) {
         if (null == objectUnderInspection){
             throw new IllegalArgumentException("argument must not be null");
         }
         this. = objectUnderInspection;
     }

    
Get the Class Properties of the object under inspection.

Returns:
String array to be indexed by the CLASS_xxx_IDX constants
 
     public String[] getClassProps() {
         String[] result = new String[+1];
         Package pack = getClassUnderInspection().getPackage();
         result[] = "package "+ ((pack == null) ?  : pack.getName());
         String modifiers = Modifier.toString(getClassUnderInspection().getModifiers());
         result[] = modifiers + " class "shortName(getClassUnderInspection());
         result[] = "implements ";
         Class[] interfaces = getClassUnderInspection().getInterfaces();
         for (Class anInterface : interfaces) {
             result[] += shortName(anInterface) + " ";
         }
         result[] = "extends " + shortName(getClassUnderInspection().getSuperclass());
         result[] = "is Primitive: "+getClassUnderInspection().isPrimitive()
                   +", is Array: "   +getClassUnderInspection().isArray()
                   +", is Groovy: "  + isGroovy();
         return result;
     }
 
     public boolean isGroovy() {
         return GroovyObject.class.isAssignableFrom(getClassUnderInspection());
     }

    
Gets the object being inspected.

Returns:
the object
    public Object getObject() {
    	return ;
    }

    
Get info about usual Java instance and class Methods as well as Constructors.

Returns:
Array of StringArrays that can be indexed with the MEMBER_xxx_IDX constants
    public Object[] getMethods(){
        Method[] methods = getClassUnderInspection().getMethods();
        Constructor[] ctors = getClassUnderInspection().getConstructors();
        Object[] result = new Object[methods.length + ctors.length];
        int resultIndex = 0;
        for (; resultIndex < methods.lengthresultIndex++) {
            Method method = methods[resultIndex];
            result[resultIndex] = methodInfo(method);
        }
        for (int i = 0; i < ctors.lengthi++, resultIndex++) {
            Constructor ctor = ctors[i];
            result[resultIndex] = methodInfo(ctor);
        }
        return result;
    }
     
Get info about instance and class Methods that are dynamically added through Groovy.

Returns:
Array of StringArrays that can be indexed with the MEMBER_xxx_IDX constants
    public Object[] getMetaMethods(){
        MetaClass metaClass = InvokerHelper.getMetaClass();
        List metaMethods = metaClass.getMetaMethods();
        Object[] result = new Object[metaMethods.size()];
        int i=0;
        for (Iterator iter = metaMethods.iterator(); iter.hasNext(); i++) {
            MetaMethod metaMethod = (MetaMethoditer.next();
            result[i] = methodInfo(metaMethod);
        }
        return result;
    }

    
Get info about usual Java public fields incl. constants.

Returns:
Array of StringArrays that can be indexed with the MEMBER_xxx_IDX constants
    public Object[] getPublicFields(){
        Field[] fields = getClassUnderInspection().getFields();
        Object[] result = new Object[fields.length];
        for (int i = 0; i < fields.lengthi++) {
            Field field = fields[i];
            result[i] = fieldInfo(field);
        }
        return result;
    }
    
Get info about Properties (Java and Groovy alike).

Returns:
Array of StringArrays that can be indexed with the MEMBER_xxx_IDX constants
    public Object[] getPropertyInfo(){
        List props = DefaultGroovyMethods.getMetaPropertyValues();
        Object[] result = new Object[props.size()];
        int i=0;
        for (Iterator iter = props.iterator(); iter.hasNext(); i++) {
            PropertyValue pv = (PropertyValueiter.next();
            result[i] = fieldInfo(pv);
        }
        return result;
    }
    protected String[] fieldInfo(Field field) {
        String[] result = new String[+1];
        result[] = ;
        result[] = Modifier.toString(field.getModifiers());
        result[] = shortName(field.getDeclaringClass());
        result[] = shortName(field.getType());
        result[] = field.getName();
        try {
            result[] = InvokerHelper.inspect(field.get());
        } catch (IllegalAccessException e) {
            result[] = ;
        }
        return withoutNulls(result);
    }
    protected String[] fieldInfo(PropertyValue pv) {
        String[] result = new String[+1];
        result[] = ;
        result[] = "public";
        result[] = ;
        result[] = shortName(pv.getType());
        result[] = pv.getName();
        try {
            result[] = InvokerHelper.inspect(pv.getValue());
        } catch (Exception e) {
            result[] = ;
        }
        return withoutNulls(result);
    }
    protected Class getClassUnderInspection() {
        return .getClass();
    }
    public static String shortName(Class clazz){
        if (null == clazzreturn ;
        String className = clazz.getName();
        if (null == clazz.getPackage()) return className;
        String packageName = clazz.getPackage().getName();
        int offset = packageName.length();
        if (offset > 0) offset++;
        className = className.substring(offset);
        return className;
    }
    protected String[] methodInfo(Method method){
        String[] result = new String[+1];
	    int mod = method.getModifiers();
        result[] = ;
        result[] = shortName(method.getDeclaringClass());
        result[] = Modifier.toString(mod);
        result[] = method.getName();
        result[] = shortName(method.getReturnType());
	    Class[] params = method.getParameterTypes();
        StringBuffer sb = new StringBuffer();
	    for (int j = 0; j < params.lengthj++) {
		    sb.append(shortName(params[j]));
		    if (j < (params.length - 1)) sb.append(", ");
	    }
        result[] = sb.toString();
	    sb.setLength(0);
	    Class[] exceptions = method.getExceptionTypes();
		for (int k = 0; k < exceptions.lengthk++) {
		    sb.append(shortName(exceptions[k]));
		    if (k < (exceptions.length - 1)) sb.append(", ");
	    }
        result[] = sb.toString();
	    return withoutNulls(result);
    }
    protected String[] methodInfo(Constructor ctor){
        String[] result = new String[+1];
	    int mod = ctor.getModifiers();
        result[] = ;
        result[] = Modifier.toString(mod);
        result[] = shortName(ctor.getDeclaringClass());
        result[] = shortName(ctor.getDeclaringClass());
        result[] = ctor.getName();
	    Class[] params = ctor.getParameterTypes();
        StringBuffer sb = new StringBuffer();
	    for (int j = 0; j < params.lengthj++) {
		    sb.append(shortName(params[j]));
		    if (j < (params.length - 1)) sb.append(", ");
	    }
        result[] = sb.toString();
	    sb.setLength(0);
	    Class[] exceptions = ctor.getExceptionTypes();
		for (int k = 0; k < exceptions.lengthk++) {
		    sb.append(shortName(exceptions[k]));
		    if (k < (exceptions.length - 1)) sb.append(", ");
	    }
        result[] = sb.toString();
	    return withoutNulls(result);
    }
    protected String[] methodInfo(MetaMethod method){
        String[] result = new String[+1];
	    int mod = method.getModifiers();
        result[] = ;
        result[] = Modifier.toString(mod);
        result[] = shortName(method.getDeclaringClass().getTheClass());
        result[] = shortName(method.getReturnType());
        result[] = method.getName();
	    CachedClass[] params = method.getParameterTypes();
        StringBuffer sb = new StringBuffer();
	    for (int j = 0; j < params.lengthj++) {
            sb.append(shortName(params[j].getTheClass()));
		    if (j < (params.length - 1)) sb.append(", ");
	    }
        result[] = sb.toString();
        result[] = // no exception info for Groovy MetaMethods
        return withoutNulls(result);
    }
    protected String[] withoutNulls(String[] toNormalize){
        for (int i = 0; i < toNormalize.lengthi++) {
            String s = toNormalize[i];
            if (null == stoNormalize[i] = ;
        }
        return toNormalize;
    }
    public static void print(Object[] memberInfo) {
        print(.memberInfo);
    }
    static void print(final PrintStream outObject[] memberInfo) {
        for (int i = 0; i < memberInfo.lengthi++) {
            String[] metaMethod = (String[]) memberInfo[i];
            out.print(i+":\t");
            for (String s : metaMethod) {
                out.print(s + " ");
            }
            out.println("");
        }
    }
    public static Collection sort(List<ObjectmemberInfo) {
        Collections.sort(memberInfonew MemberComparator());
        return memberInfo;
    }
    public static class MemberComparator implements Comparator<Object> {
        public int compare(Object aObject b) {
            String[] aStr = (String[]) a;
            String[] bStr = (String[]) b;
            int result = aStr[.].compareTo(bStr[.]);
            if (0 != resultreturn result;
            result = aStr[.].compareTo(bStr[.]);
            if (0 != resultreturn result;
            result = aStr[.].compareTo(bStr[.]);
            if (0 != resultreturn result;
            result = aStr[.].compareTo(bStr[.]);
            if (0 != resultreturn result;
            result = aStr[.].compareTo(bStr[.]);
            if (0 != resultreturn result;
            result = aStr[.].compareTo(bStr[.]);
            return result;
        }
    }
New to GrepCode? Check out our FAQ X