/*
I made this paste in haste of an error in NetBeans 8.0 so this will indeed be unstable ;)
*/
package game.debug;
import java.lang.reflect.*;
import java.util.Arrays;
import java.util.Date;
/**
* This is a debugger. It makes life easier.
*
* @author Link_The_Programmer
* @version 1.1
*
* =name changed from Initializer to Debugger
* =name changed from method initialize(Object obj) to parseObject
* =name changed from method initialize(Object[] obj) to parseData
* -removed redundancies (some things were already done by the JVM)
* -(volatile Exception irrelevant)
*/
public final class Debugger {
private static final String version = "1.1";
private static transient Exception e;
private static Object obj;
private static transient int numOfObjects = 0;
private static transient Date date = new Date();
static {
System.out.println("~" + Debugger + ".java version " + version);
System.out.println();
}
Debugger() {
}
//[Constructor]
public Debugger(Object obj) {
parseObject(obj);
System.out.println(obj + " initialized.");
}
/**
*
* @param obj
* @throws ClassNotFoundException
* @throws NoSuchFieldException
* @throws Exception
*/
public Debugger(Object[] obj) throws Exception {
int mill1;
int mill2;
System.out.println("--[" + date.getHours() + ":" + date.getMinutes() + ":" + date.getSeconds() + ":" + System.currentTimeMillis() / date.getSeconds() + "] Parsing objects...");
mill1 = (int) (System.currentTimeMillis() / date.getSeconds());
parseData(obj);
System.out.println("--[" + date.getHours() + ":" + date.getMinutes() + ":" + date.getSeconds() + ":" + System.currentTimeMillis() / date.getSeconds() + "] Objects data parsed. Total quantity: " + numOfObjects);
mill2 = (int) (mill1 - System.currentTimeMillis() / date.getSeconds());
System.out.println("--Time Elapsed: " + Math.abs(mill2) + " millisecond(s)");
System.out.println();
for (Object object : obj) {
if (object == null) {
System.err.println(e.getStackTrace()[e.getStackTrace().length - 1].getClassName() + ".Field" + Arrays.toString(e.getStackTrace()[e.getStackTrace().length - 1].getClassName().getBytes()) + "] was not parsed; value = " + e.getLocalizedMessage());
}
}
}
//[/Constructor]
/**
* Parses a single Object.
*
* @param obj
*/
private synchronized void parseObject(Object obj) {
if (obj instanceof Field || obj instanceof Class) {
if (obj instanceof Field) {
Field.setAccessible((AccessibleObject[]) obj, true);
System.out.println(obj + " initialized. value: " + getFieldValue((Field) obj));
numOfObjects += 1;
Field.setAccessible((AccessibleObject[]) obj, false);
} else {
System.out.println(((Class) obj).getCanonicalName() + " initialized.");
numOfObjects += 1;
}
} else {
System.out.println(getContainingClass(obj) + ".Field"
+ Arrays.toString(e.getStackTrace()[getStackSize() - 1].getClassName().getBytes())
+ "] initialized. value: " + "(" + getInstanceAsString(obj) + ")" + obj);
numOfObjects += 1;
}
}
/**
* Parses an array of objects.
*
*
* @param obj
* @return
* @throws ClassNotFoundException
* @throws NoSuchFieldException
* @throws Exception
*/
private synchronized void parseData(Object[] obj) throws ClassNotFoundException, NoSuchFieldException, Exception {
try {
throw new Exception();
} catch (Exception ex) {
Debugger.e = ex;
for (Object object : obj) {
parseObject(object);
}
}
}
/**
* Gets a field value specified by the parameter obj.
*
* @param obj
* @return
*/
@SuppressWarnings("BoxingBoxedValue")
public static Object getFieldValue(Object obj) {
try {
if (!(obj instanceof Class)) {
Field f = (Field) obj;
if (f.getType().isPrimitive() || f.getType().isSynthetic() || (f.getType() == String.class || f.getType() == Character.class) || f.getType() == Boolean.class) {
return f.get(f);
} else {
return null;
}
}
} catch (IllegalArgumentException | IllegalAccessException ex) {
}
return null;
}
/**
* Gets the last value that the Initializer set a value for.
*
* @return the last value that was set
*/
public Object getLastValueSet() {
return obj;
}
/**
*
* @param clss
* @return
*/
public static Object[] getClasses(Class clss) {
return clss.getDeclaredClasses();
}
/**
*
* @param clss
* @return
*/
public static Object[] getFields(Class clss) {
return clss.getDeclaredFields();
}
/**
*
* @return
*/
public static int getNumOfObjects() {
return numOfObjects;
}
/**
* Gets the stack object length. The stack object is Initializer.e (private
* field)
*
* @return the stack size
*/
@SuppressWarnings("BoxingBoxedValue")
public static int getStackSize() {
if (e != null) {
return e.getStackTrace().length;
}
return 0;
}
/**
* Gets the StackTrace context of this object.
*
* @return Exception e which is the Exception that has the stack being used.
*/
public static Exception getStackContext() {
return Debugger.e;
}
/**
* Gets the type of an object.
*
* @param obj
* @return the type of obj
* @throws NoSuchFieldException
*/
public static Object getInstance(Object obj) throws NoSuchFieldException {
return ((Class) obj).getTypeName();
}
/**
* Gets the type of an Object and returns it as a String object.
*
* @param obj
* @return the instance as a String object
*/
public static String getInstanceAsString(Object obj) {
return obj.getClass().getTypeName();
}
/**
* Gets the class in which the object is declared in. This is equivalent to
* @code{object.getClass().getDeclaringClass()} except it uses the stacktrace
* in order to find that class.
*
* @param obj
* @return the class which the object is declared in.
*/
public static Class getContainingClass(Object obj) {
try{
throw new Exception();
} catch(Exception ex){
e = ex;
return e.getStackTrace()[getStackSize() - 1].getClassName().getClass().getDeclaringClass();
}
}
/**
* Gets the version of Initializer.java
*
* @return the version
*/
public static String getVersion() {
return version;
}
}
Comments