import java.lang.reflect.*;
import java.util.*;
import java.io.*;
import utilities.*;

public class DumpMembers {

private final static int COLUMN_1_WIDTH = 20;
private final static int COLUMN_2_WIDTH = 18;

//-------------------------------------------------------------------
// main() entry point
//-------------------------------------------------------------------
public static void main (String[] args) {
	new DumpMembers();
}
//-------------------------------------------------------------------
// default DumpMembers Constructor
//-------------------------------------------------------------------
public DumpMembers() {

String className;				// class to list members of
Class target = null;
String depth;
boolean declaredOnly;
Vector members;					// all the members for class

	System.out.println("DumpMembers");
	System.out.println("-----------");
	System.out.println("Enter the name of the class to analyze: ");
	className = readString();

	System.out.println("(A)ll members or (D)eclared members: ");
	depth = readString();
	declaredOnly = depth.equals("D");		// true or false

	// find the Class instance
	try {
		target = Class.forName(className);
	} catch (ClassNotFoundException misspelled) {
		System.out.println("Class '" + className + "' could not be found.");
		System.exit(10);
	}

	// collect all Field, Constructor and Method members in a Vector
	members = new Vector();
	collectFields		(target, declaredOnly, members);
	collectConstructors	(target, declaredOnly, members);
	collectMethods		(target, declaredOnly, members);

	// and then dump the contents of the Vector
	dumpMemberInfo(className, members);
}
//-------------------------------------------------------------------
// Depending on the "declaredOnly" flag, collect public accessible
// members or all members declared in the target class.
//-------------------------------------------------------------------
public void collectFields(Class target, boolean declaredOnly, Vector bag) {
Member[] fields;

	// get all accessible public fields or all fields in this class only
	if ( declaredOnly ) {
		fields = target.getDeclaredFields();
	} else {
		fields = target.getFields();
	}

	// now siphon Fields to our Vector for later recall
	siphonElements(fields, bag);
}
//-------------------------------------------------------------------
public void collectConstructors(Class target, boolean declaredOnly, Vector bag) {
Member[] constructors;

	if ( declaredOnly ) {
		constructors = target.getDeclaredConstructors();
	} else {
		constructors = target.getConstructors();
	}
	siphonElements(constructors, bag);
}
//-------------------------------------------------------------------
public void collectMethods(Class target, boolean declaredOnly, Vector bag) {
Member[] methods;

	if ( declaredOnly ) {
		methods = target.getDeclaredMethods();
	} else {
		methods = target.getMethods();
	}
	siphonElements(methods, bag);
}
//-------------------------------------------------------------------
// All Members of a class have been collected in a Vector.
// Iterate through all elements of Vector, printing info on each Member
//-------------------------------------------------------------------
public void dumpMemberInfo(String className, Vector members) {

Member member;
String memberName;
int memberModifiers;
String memberDeclaringClass;
String memberInfo, column1Padding, column2Padding;
StringBuffer sb;

	System.out.println("");
	System.out.println("Class '"+ className +
						"' contains the following members:");
	System.out.println("");

	Enumeration memberIterator = members.elements();
	while ( memberIterator.hasMoreElements() ) {
		member = (Member) memberIterator.nextElement();

		memberName				= member.getName();
		memberModifiers			= member.getModifiers();
		memberDeclaringClass	= member.getDeclaringClass().getName();

		column1Padding = StringKit.columnPadding(COLUMN_1_WIDTH, memberName);
		column2Padding = StringKit.columnPadding(COLUMN_2_WIDTH, memberDeclaringClass);

		memberInfo = memberName			  + column1Padding + "in " +
					 memberDeclaringClass + column2Padding + "(";

		System.out.print(memberInfo);

		sb = new StringBuffer();

		if (Modifier.isPublic(memberModifiers)) {
			sb.append("public, ");
		}
		if (Modifier.isPrivate(memberModifiers)){
	    	sb.append("private, ");
		}
		if ( Modifier.isProtected(memberModifiers) ) {
    		sb.append("protected, ");
		}
		if ( Modifier.isStatic(memberModifiers) ){
    		sb.append("static, ");
		}
		if ( Modifier.isFinal(memberModifiers) ){
    		sb.append("final, ");
		}
		if ( Modifier.isSynchronized(memberModifiers) ){
    		sb.append("synchronized, ");
		}
		if ( Modifier.isVolatile(memberModifiers) ){
    		sb.append("volatile, ");
		}
		if ( Modifier.isTransient(memberModifiers) ){
    		sb.append("transient, ");
		}
		if ( Modifier.isNative(memberModifiers) ){
    		sb.append("native, ");
		}
		if ( Modifier.isInterface(memberModifiers) ){
    		sb.append("interface, ");
		}
		if ( Modifier.isAbstract(memberModifiers) ){
    		sb.append("abstract, ");
		}

		// erase last comma and space
		StringKit.shrinkStringBufferBy(2, sb);

		// print modifier list
		System.out.println( sb.toString() + ")" );

	} // End while
}
//-------------------------------------------------------------------
// Utility method to transfer all objects in an array to a Vector
//-------------------------------------------------------------------
public static void siphonElements(Object[] array, Vector bag) {

	for (int i=0; i < array.length; i++) {
		bag.addElement(array[i]);
	}
}
//-------------------------------------------------------------------
// Utility method to read a line of text from console.
//-------------------------------------------------------------------
public static String readString() {
DataInputStream in = new DataInputStream(System.in);
String string = null;

	try {
		string = in.readLine();
	} catch (IOException ignored) {
		System.out.println("ERROR: reading line from stdin");
	}

	return string;
}
} // End of Class DumpMembers