com.lambda.Debugger.ClassInformation Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of LewisOmniscientDebugger Show documentation
A command line utility for accesing the bowler framework.
The newest version!
/*                        ClassInformation.java

  Copyright 2003, Bil Lewis

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.
  
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA   
*/

package com.lambda.Debugger;

//              ClassInformation.java

/*
 */


import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;


public class ClassInformation {
    static private ClassInformation	arrayCI, vectorCI, arraylistCI, hashtableCI, hashMapCI;
    static private HashMapEq		table = new HashMapEq(20);		// Class -> 
    static private HashMapEq		classTable = new HashMapEq(200);	// Class -> 
    static private HashMapEq		usfTable = new HashMapEq(20);		// ClassName -> fieldName

    public String			className;				// "com.lambda.Debugger.Demo"
    public Class	 		clazz;
    protected String 			userSelectedField = null;
    private String[]			varNames;
    private Field[]			varFields;
    private Class[]			varClasses;
    private int				id=0;







    public int nextID() {
	return id++;
    }

    static {initialize();}

    public ClassInformation(Class c, String[] vn, Field[] fs, Class[] cs) {
	varFields = fs;
	varClasses = cs;
	varNames = vn;
	clazz = c;
	className=clazz.getName().intern();
    }

    public int size() {return varNames.length;}

    public boolean isArray() {
	return (this == arrayCI) ;
    }
    public boolean isVector() {
	return (this == vectorCI) ;
    }
    public boolean isArrayList() {
	return (this == arraylistCI) ;
    }
    public boolean isHashtable() {
        return (this == hashtableCI) ;
    }
    public boolean isHashMap() {
        return (this == hashMapCI) ;
    }

    public int getnInstanceVars() {
	if (isArray()) return 0;
	if (isVector()) return 0;
	if (isArrayList()) return 0;
        if (isHashtable()) return 0;
        if (isHashMap()) return 0;
	return varNames.length;
    }


    public Class getVarClass(int i) {
	return varClasses[i];
    }

    public Field getVarField(int i) {
	return varFields[i];
    }

    public String[] getVarNames() {
	return varNames;
    }


    public String getVarName(int i) {
	if (isArray()) return ""+i;
	if (isVector()) return ""+i;
	if (isArrayList()) return ""+i;
        if (isHashtable()) return ""+i;
        if (isHashMap()) return ""+i;
	if (i >= varNames.length) throw new DebuggerException("getVarName("+i+") " + this);
	return varNames[i];
    }

    public int getVarIndex(String s) {
	if (varNames == null) return -1;
	int len = varNames.length;
	for (int j = 0; j < len; j++) {
	    if (varNames[j] == s) return(j);
	}
	//	throw new DebuggerException("gvi " + s);
	return -1;// If a variable is private from an inherited class
    }


    public static void initialize() {
	arrayCI = new ClassInformation(Object[].class, null, null, null);
	vectorCI = new ClassInformation(MyVector.class, null, null, null);
	arraylistCI = new ClassInformation(MyArrayList.class, null, null, null);
        hashtableCI = new ClassInformation(Hashtable.class, null, null, null);
        hashMapCI = new ClassInformation(HashMap.class, null, null, null);
	Class c;
	c = Object[].class; table.put(c, arrayCI); classTable.put(c, arrayCI);
	c = int[].class; table.put(c, arrayCI); classTable.put(c, arrayCI);
	c = int[][].class; table.put(c, arrayCI); classTable.put(c, arrayCI);
	c = short[].class; table.put(c, arrayCI); classTable.put(c, arrayCI);
	c = byte[].class; table.put(c, arrayCI); classTable.put(c, arrayCI);
	c = char[].class; table.put(c, arrayCI); classTable.put(c, arrayCI);
	c = boolean[].class; table.put(c, arrayCI); classTable.put(c, arrayCI);
	c = long[].class; table.put(c, arrayCI); classTable.put(c, arrayCI);
	c = double[].class; table.put(c, arrayCI); classTable.put(c, arrayCI);
	c = float[].class; table.put(c, arrayCI); classTable.put(c, arrayCI);
	c = MyVector.class; table.put(c, vectorCI); classTable.put(c, vectorCI);
	c = MyArrayList.class; table.put(c, arraylistCI); classTable.put(c, arraylistCI);
	c = LocksList.class; table.put(c, vectorCI); classTable.put(c, vectorCI);
        c = MyHashtable.class; table.put(c, hashtableCI); classTable.put(c, hashtableCI);
        c = MyHashMap.class; table.put(c, hashMapCI); classTable.put(c, hashMapCI);
    }
  
    public static ClassInformation get(Object o) {
	Class c;
	ClassInformation ci;
	boolean isClass = false;

	if (o instanceof Class) {
	    isClass = true;
	    c = (Class) o;
	    ci = (ClassInformation) classTable.get(c);
	}
	else {
	    if (o instanceof Object[]) return arrayCI;
	    c = o.getClass();
	    ci = (ClassInformation) table.get(c);
	}

	if (ci != null) return ci;

	Field[] f;
	int nFields = 0, nsFields = 0, index = 0, sindex = 0;
	String[] varNames;
	String[] staticVarNames;
	Field[] varFields;
	Field[] staticVarFields;
	Class[] varClasses;
	Class[] staticVarClasses;

	{
	    f = c.getFields();

		Comparator comp = new Comparator() {public int compare(Object o1, Object o2) {
					Field f1 = (Field) o1, f2 = (Field) o2;
					String s1 = f1.getName(), s2 = f2.getName();
					return s1.compareTo(s2);
					}
				};
		Arrays.sort(f, comp);
	    int len = f.length;
	    for (int i = 0; i< len; i++) {if (Modifier.isStatic(f[i].getModifiers())) nsFields++;}
	    nFields = len-nsFields;
	    varNames = new String[nFields];
	    staticVarNames = new String[nsFields];
	    varFields = new Field[nFields];
	    staticVarFields = new Field[nsFields];
	    varClasses = new Class[nFields];
	    staticVarClasses = new Class[nsFields];
	    for (int i = 0; i< len; i++) {
		String n = f[i].getName().intern();		    
		Class cl = f[i].getType();		    
		if (! Modifier.isStatic(f[i].getModifiers())) {
		    varNames[index] = n;
		    varFields[index] = f[i];
		    varClasses[index] = cl;
		    index++;
		}
		else {
		    staticVarNames[sindex] = n;
		    staticVarFields[sindex] = f[i];
		    staticVarClasses[sindex] = cl;
		    sindex++;
		}
	    }

	    ci = new ClassInformation(c, varNames, varFields, varClasses);
	    String fieldName = (String)usfTable.get(ci.className);
	    if (fieldName != null) ci.addUserSelectedField(fieldName);
	    ClassInformation sci = new ClassInformation(c, staticVarNames, staticVarFields, staticVarClasses);
	    table.put(c, ci);
	    classTable.put(c, sci);
	    if (isClass)
		return sci;
	    else
		return ci;
	}
    }


    public void setUserSelectedField(String name) {// Used by Launch for Demo only.
	userSelectedField = name;
	ClassInformation ci = (ClassInformation) table.get(clazz);// Assumes get() called with Class Object
	ci.userSelectedField = name;
    }
    

    public static void addUserSelectedField(String className, String fieldName) {
	usfTable.put(className.intern(), fieldName);
    }
    public static VectorD getUserSelectedFields() {
	VectorD v = new VectorD();
	Iterator iter =  usfTable.keySet().iterator();
	while (iter.hasNext()) {
	    String key = (String) iter.next();
	    String value = (String) usfTable.get(key);
	    v.add(new String[] {key, value});
	}
	return v;
    }

    public void addUserSelectedField(String fieldName) {
	userSelectedField = fieldName.intern();
	}
    

    public static void main(String[] args) {
	System.out.println("-------------CI test-----------");
	get(int[].class);
	get(int[][].class);
	get(Object[].class);
	get(String[].class);
	get(ClassInformation[].class);
	get(ClassInformation.class);
	get(Class.class);
	get(Thread.class);
	get(Shadow.class);
    }

    public String toString() {
	String s = "[";
	if (varNames != null)
	    for (int i = 0; i < varNames.length; i++) {s+=varNames[i]+", ";}
	return "";
    }

}