incubator-kato-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From monte...@apache.org
Subject svn commit: r772669 [6/7] - in /incubator/kato/trunk: HprofBinaryReaderPOC/ HprofBinaryReaderPOC/.settings/ HprofBinaryReaderPOC/META-INF/ HprofBinaryReaderPOC/bin/ HprofBinaryReaderPOC/bin/org/ HprofBinaryReaderPOC/bin/org/apache/ HprofBinaryReaderPOC...
Date Thu, 07 May 2009 14:50:35 GMT
Added: incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaClassImpl.java
URL: http://svn.apache.org/viewvc/incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaClassImpl.java?rev=772669&view=auto
==============================================================================
--- incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaClassImpl.java (added)
+++ incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaClassImpl.java Thu May  7 14:50:21 2009
@@ -0,0 +1,755 @@
+/*******************************************************************************
+ * 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 org.apache.kato.hprof.java;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.apache.kato.common.BasicType;
+import org.apache.kato.hprof.IJavaClass;
+import org.apache.kato.hprof.datalayer.ConstantPoolEntry;
+import org.apache.kato.hprof.datalayer.FieldEntry;
+import org.apache.kato.hprof.datalayer.InstanceFieldEntry;
+import org.apache.kato.hprof.datalayer.StaticFieldEntry;
+import org.apache.kato.hprof.image.CorruptDataImpl;
+import org.apache.kato.hprof.image.ImagePointerImpl;
+import org.apache.kato.image.CorruptDataException;
+import org.apache.kato.image.DataUnavailable;
+import org.apache.kato.image.ImagePointer;
+import org.apache.kato.image.MemoryAccessException;
+import org.apache.kato.java.JavaClass;
+import org.apache.kato.java.JavaClassLoader;
+import org.apache.kato.java.JavaField;
+import org.apache.kato.java.JavaObject;
+
+/**
+ * HProf implementation of JavaClass. 
+ * 
+ *
+ */
+public class JavaClassImpl implements JavaClass {
+	IJavaHeapInternal heap;
+	IJavaClass javaClass;
+	
+	/**
+	 * Superclass to static and instance fields.
+	 *
+	 */
+	abstract class JavaFieldImpl implements JavaField {
+		FieldEntry field;
+
+		/**
+		 * Returns the signature of this field.
+		 * Unfortunately, only the fact that a field is an object reference
+		 * is recorded. 
+		 * If we find all objects an object reference field refers to,
+		 * if we take the lowest common subclass then that is the closest to
+		 * the field's actual type. It would be prohibitively expensive to do
+		 * that though.
+		 */
+		@Override
+		public String getSignature() throws CorruptDataException {
+			switch (field.getType()) {
+			case BasicType.OBJECT:
+				return "Ljava/lang/Object;";
+			case BasicType.BOOLEAN:
+				return "Z";
+			case BasicType.CHAR:
+				return "C";
+			case BasicType.FLOAT:
+				return "F";
+			case BasicType.DOUBLE:
+				return "D";
+			case BasicType.BYTE:
+				return "B";
+			case BasicType.SHORT:
+				return "S";
+			case BasicType.INT:
+				return "I";
+			case BasicType.LONG:
+				return "J";
+			default:
+				throw new CorruptDataException(new CorruptDataImpl("Unexpected basic type of " + field.getType()+
+						"encountered."));
+			}
+		}
+
+		@Override
+		public String getName() throws CorruptDataException {
+			return heap.getUTF8StringByID(field.getFieldNameID());
+		}
+		
+		@Override
+		public JavaClass getDeclaringClass() throws CorruptDataException,
+				DataUnavailable {
+					return JavaClassImpl.this;
+				}
+		
+		String getStringFromJavaObject(JavaObject obj) throws CorruptDataException, MemoryAccessException {
+			JavaClass clazz = obj.getJavaClass();
+			JavaObject value=null;
+			int offset=0;
+			int count=0;
+			boolean valueSet = false, offsetSet = false, countSet=false;
+			
+			Iterator iter = clazz.getDeclaredFields();
+			
+			while (iter.hasNext()) {
+				JavaField field = (JavaField) iter.next();
+				String name = field.getName();
+				if("value".equals(name)) {
+					value = (JavaObject) field.get(obj);
+					valueSet = true;
+				} else if ("offset".equals(name)) {
+					offset = field.getInt(obj);
+					offsetSet = true;
+				} else if ("count".equals(name)) {
+					count = field.getInt(obj);
+					countSet = true;
+				}
+				
+			}
+
+			if (valueSet == false || offsetSet == false || countSet == false ) {
+				throw new CorruptDataException(new CorruptDataImpl("Unable to find all String classes fields values"));
+			}
+			char characters[] = new char[count];
+			
+			value.arraycopy(offset, characters, 0, count);
+			
+			return new String(characters);
+		}
+	}
+	
+	class InstanceFieldImpl extends JavaFieldImpl {
+		
+		
+		public InstanceFieldImpl(InstanceFieldEntry field) {
+			this.field = field;
+		}
+		
+		/**
+		 * Returns true if this field can retrieve a value from the passed class.
+		 * 
+		 * @param clazz JavaClassImpl of object to retrieve field from
+		 * @return true if the class is compatible
+		 * 
+		 * @throws CorruptDataException
+		 */
+		private boolean isCompatible(JavaClassImpl clazz) throws CorruptDataException {
+			// checks that this field can be extracted from the passed clazz
+			
+			while(clazz != null) {
+				if (clazz.equals(JavaClassImpl.this)) {
+					return true;
+				}
+				
+				clazz = clazz.getSuperclass();
+			}
+			
+			return false;
+		}
+		
+		/** 
+		 * Returns the offset of this field into a given object.
+		 * 
+		 * @param clazz JavaClassImpl
+		 * @return int offset
+		 * @throws CorruptDataException
+		 */
+		private int getOffset(JavaClassImpl clazz) throws CorruptDataException {
+			// The potential subclasses of this field have to be skipped before
+			// using the stored field offset.			
+			int offset = ((InstanceFieldEntry)field).getOffset();			
+			while ((clazz != null) && !clazz.equals(JavaClassImpl.this)) {
+				offset += clazz.getOffsetSize(); // Or some variant.
+				clazz = clazz.getSuperclass();
+			}
+			return offset;
+		}
+		
+		@Override
+		public Object get(JavaObject obj) throws CorruptDataException,
+				MemoryAccessException {
+			
+			if (! (obj instanceof JavaObjectInstanceImpl)) {
+				throw new IllegalArgumentException("Passed object must be an ordinary object");			
+			}
+			
+			JavaClassImpl clazz = (JavaClassImpl) obj.getJavaClass();
+			
+			if (!isCompatible(clazz)) {
+				throw new IllegalArgumentException("Field " + 
+						JavaClassImpl.this.getName() + "." + 
+						getName() +" not in class hierachy of object 0x"+
+						Long.toHexString(obj.getID().getAddress()));
+			}
+ 			
+			// The potential subclasses of this field have to be skipped before
+			// using the stored field offset. 
+			int offset = getOffset(clazz);
+			
+			JavaObjectInstanceImpl instance = ((JavaObjectInstanceImpl) obj);
+
+			switch(field.getType()) {
+			case BasicType.BOOLEAN:
+				return new Boolean(instance.getBooleanField(offset));
+			case BasicType.BYTE: 
+				return new Byte(instance.getByteField(offset));
+			case BasicType.SHORT: 
+				return new Short(instance.getShortField(offset));
+			case BasicType.CHAR: 
+				return new Character(instance.getCharField(offset));
+			case BasicType.INT: 
+				return new Integer(instance.getIntegerField(offset));
+			case BasicType.LONG: 
+				return new Long(instance.getLongField(offset));
+			case BasicType.FLOAT: 
+				return new Float(instance.getFloatField(offset));
+			case BasicType.DOUBLE: 
+				return new Double(instance.getDoubleField(offset));
+			case BasicType.OBJECT:
+				return JavaClassImpl.this.heap.getObjectByID(instance.getIDField(offset));
+			default:
+				throw new CorruptDataException(new CorruptDataImpl("Invalid field type "
+						+field.getType()));
+			}
+		}
+
+		@Override
+		public boolean getBoolean(JavaObject obj) throws CorruptDataException,
+				MemoryAccessException {
+			JavaObjectInstanceImpl instance = ((JavaObjectInstanceImpl) obj);
+			JavaClassImpl clazz = (JavaClassImpl) obj.getJavaClass();
+			int offset = getOffset(clazz);
+			
+			return instance.getBooleanField(offset);
+		}
+
+		@Override
+		public byte getByte(JavaObject obj) throws CorruptDataException,
+				MemoryAccessException {
+			JavaObjectInstanceImpl instance = ((JavaObjectInstanceImpl) obj);
+			JavaClassImpl clazz = (JavaClassImpl) obj.getJavaClass();
+			int offset = getOffset(clazz);
+			
+			return instance.getByteField(offset);
+		}
+
+		@Override
+		public char getChar(JavaObject obj) throws CorruptDataException,
+				MemoryAccessException {
+			JavaObjectInstanceImpl instance = ((JavaObjectInstanceImpl) obj);
+			JavaClassImpl clazz = (JavaClassImpl) obj.getJavaClass();
+			int offset = getOffset(clazz);
+			
+			return instance.getCharField(offset);
+		}
+
+		@Override
+		public double getDouble(JavaObject obj) throws CorruptDataException,
+				MemoryAccessException {
+			JavaObjectInstanceImpl instance = ((JavaObjectInstanceImpl) obj);
+			JavaClassImpl clazz = (JavaClassImpl) obj.getJavaClass();
+			int offset = getOffset(clazz);
+			
+			return instance.getDoubleField(offset);
+		}
+
+		@Override
+		public float getFloat(JavaObject obj) throws CorruptDataException,
+				MemoryAccessException {
+			JavaObjectInstanceImpl instance = ((JavaObjectInstanceImpl) obj);
+			JavaClassImpl clazz = (JavaClassImpl) obj.getJavaClass();
+			int offset = getOffset(clazz);
+			
+			return instance.getFloatField(offset);
+
+		}
+
+		@Override
+		public int getInt(JavaObject obj) throws CorruptDataException,
+				MemoryAccessException {
+			JavaObjectInstanceImpl instance = ((JavaObjectInstanceImpl) obj);
+			JavaClassImpl clazz = (JavaClassImpl) obj.getJavaClass();
+			int offset = getOffset(clazz);
+			
+			return instance.getIntegerField(offset);
+
+		}
+
+		@Override
+		public long getLong(JavaObject obj) throws CorruptDataException,
+				MemoryAccessException {
+			JavaObjectInstanceImpl instance = ((JavaObjectInstanceImpl) obj);
+			JavaClassImpl clazz = (JavaClassImpl) obj.getJavaClass();
+			int offset = getOffset(clazz);
+			
+			return instance.getLongField(offset);
+
+		}
+
+		@Override
+		public short getShort(JavaObject obj) throws CorruptDataException,
+				MemoryAccessException {
+			JavaObjectInstanceImpl instance = ((JavaObjectInstanceImpl) obj);
+			JavaClassImpl clazz = (JavaClassImpl) obj.getJavaClass();
+			int offset = getOffset(clazz);
+			
+			return instance.getShortField(offset);
+		}
+
+		@Override
+		public String getString(JavaObject obj) throws CorruptDataException,
+				MemoryAccessException {
+			Object fieldObj = get(obj);
+			if (fieldObj == null) {
+				return null;
+			}
+			if (!(fieldObj instanceof JavaObject)) {
+				throw new IllegalArgumentException("Field "+getName()+" not an object");
+			}
+			JavaObject jObject = (JavaObject) fieldObj;
+			
+			if (! "java/lang/String".equals( jObject.getJavaClass().getName() )) {
+				throw new IllegalArgumentException("Field "+getName()+" refers to 0x"+
+						Long.toHexString(jObject.getID().getAddress()) +
+						", which not a string - it's a " + jObject.getJavaClass());
+			}
+			
+			return getStringFromJavaObject(jObject);
+		}
+
+		@Override
+		public int getModifiers() throws CorruptDataException {
+			return 0;
+		}
+		
+	}
+	
+	/**
+	 * Represents a static field.
+	 * Passed JavaObject is always ignored. The actual value is stored
+	 * within the StaticFieldEntry.
+	 * 
+	 */
+	class StaticFieldImpl extends JavaFieldImpl {
+
+		StaticFieldImpl(StaticFieldEntry field) {
+			this.field = field;
+		}
+		
+		/**
+		 * Retrieves the field and returns an Object - primitive types are
+		 * boxed. Other types are implementations of JavaObject, or null.
+		 */
+		@Override
+		public Object get(JavaObject arg0) throws CorruptDataException,
+				MemoryAccessException {
+			StaticFieldEntry field = (StaticFieldEntry) this.field;
+			
+			switch(field.getType()){
+			case BasicType.OBJECT:
+				return heap.getObjectByID(field.getIDField());
+			case BasicType.BOOLEAN:
+				return new Boolean(field.getBooleanField());
+			case BasicType.CHAR:
+				return new Character(field.getCharField());
+			case BasicType.FLOAT:
+				return new Float(field.getFloatField());
+			case BasicType.DOUBLE:
+				return new Double(field.getDoubleField());
+			case BasicType.BYTE:
+				return new Byte(field.getByteField());
+			case BasicType.SHORT:
+				return new Short(field.getShortField());
+			case BasicType.INT:
+				return new Integer(field.getIntegerField());
+			case BasicType.LONG:
+				return new Long(field.getLongField());
+			default:
+				throw new CorruptDataException(new CorruptDataImpl("Unexpected basic type of " + field.getType()+
+						"encountered."));		
+			}
+		}
+
+		@Override
+		public boolean getBoolean(JavaObject arg0) throws CorruptDataException,
+				MemoryAccessException {
+			return ((StaticFieldEntry)field).getBooleanField();
+		}
+
+		@Override
+		public byte getByte(JavaObject arg0) throws CorruptDataException,
+				MemoryAccessException {
+			return ((StaticFieldEntry)field).getByteField();
+		}
+
+		@Override
+		public char getChar(JavaObject arg0) throws CorruptDataException,
+				MemoryAccessException {
+			return ((StaticFieldEntry)field).getCharField();
+		}
+
+		@Override
+		public double getDouble(JavaObject arg0) throws CorruptDataException,
+				MemoryAccessException {
+			return ((StaticFieldEntry)field).getDoubleField();
+		}
+
+		@Override
+		public float getFloat(JavaObject arg0) throws CorruptDataException,
+				MemoryAccessException {
+			return ((StaticFieldEntry)field).getFloatField();
+		}
+
+		@Override
+		public int getInt(JavaObject arg0) throws CorruptDataException,
+				MemoryAccessException {
+			return ((StaticFieldEntry)field).getIntegerField();
+		}
+
+		@Override
+		public long getLong(JavaObject arg0) throws CorruptDataException,
+				MemoryAccessException {
+			return ((StaticFieldEntry)field).getLongField();
+		}
+
+		@Override
+		public short getShort(JavaObject arg0) throws CorruptDataException,
+				MemoryAccessException {
+			return ((StaticFieldEntry)field).getShortField();
+		}
+
+		@Override
+		public String getString(JavaObject arg0) throws CorruptDataException,
+				MemoryAccessException {
+			
+			return getStringFromJavaObject(heap.getObjectByID(((StaticFieldEntry)field).getIDField()));
+		}
+
+		/**
+		 * This field is static - nothing else is known.
+		 */
+		@Override
+		public int getModifiers() throws CorruptDataException {
+			return java.lang.reflect.Modifier.STATIC;
+		}
+	}
+	
+	public JavaClassImpl(IJavaHeapInternal heap, IJavaClass javaClass) {
+		this.heap = heap;
+		this.javaClass = javaClass;
+	}
+	
+	@Override
+	public JavaClassLoader getClassLoader() throws CorruptDataException {
+		return heap.getJavaClassLoaderByID(javaClass.getClassLoaderObjectID());
+	}
+
+	/**
+	 * Get the component type of this class if it is an array class.
+	 * 
+	 * Primitive arrays have primitives as elements, so their component
+	 * type are classes called "int", etc. These classes are faked using 
+	 * JavaPrimitiveClassImpl as they don't exist in hprof dumps. 
+	 *  
+	 * An int[][] array is an array of arrays, hence not primitive.
+	 * 
+	 * The component types are retrieved by name from the JavaClassLoader this
+	 * array class belongs to. 
+	 */
+	@Override
+	public JavaClass getComponentType() throws CorruptDataException {
+		if (!isArray()) {
+			throw new IllegalArgumentException("Class is not an array type");
+		}
+		
+		String name = javaClass.getClassName();
+		
+		if ("boolean[]".equals(name)) {
+			return heap.getPrimitiveClass(BasicType.BOOLEAN);
+		}if ("byte[]".equals(name)) {
+			return heap.getPrimitiveClass(BasicType.BYTE);
+		}if ("short[]".equals(name)) {
+			return heap.getPrimitiveClass(BasicType.SHORT);
+		}if ("char[]".equals(name)) {
+			return heap.getPrimitiveClass(BasicType.CHAR);
+		}if ("int[]".equals(name)) {
+			return heap.getPrimitiveClass(BasicType.INT);
+		}if ("long[]".equals(name)) {
+			return heap.getPrimitiveClass(BasicType.LONG);
+		}if ("float[]".equals(name)) {
+			return heap.getPrimitiveClass(BasicType.FLOAT);
+		}if ("double[]".equals(name)) {
+			return heap.getPrimitiveClass(BasicType.DOUBLE);
+		}
+		
+		String componentName = this.getName().substring(1);
+		
+		/* If the array was "[Ljava/lang/String;"
+		 * Strip it to "java/lang/String"
+		 */
+		if(componentName.charAt(0) == 'L') {
+			componentName = componentName.substring(1,componentName.length()-1);
+		}
+		
+		return getClassLoader().findClass(componentName);
+	}
+
+	@Override
+	public Iterator getConstantPoolReferences() {
+		List cpeList = new LinkedList();
+		
+		
+		ConstantPoolEntry[] cpes = this.javaClass.getConstantPoolEntries();
+
+		for ( ConstantPoolEntry cpe : cpes) {
+			if (cpe.type == BasicType.OBJECT) {
+			//	cpeList.add(heap.getObjectByID(cpe.data));
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * The static and instance fields belonging to this class.
+	 * 
+	 */
+	private ArrayList<JavaField> fields;
+	@Override
+	public Iterator getDeclaredFields() {
+		if (fields == null) {
+			StaticFieldEntry staticFields[] = javaClass.getStaticFields();
+			InstanceFieldEntry instanceFields[] = javaClass.getInstanceFields();
+			
+			fields = new ArrayList<JavaField>(staticFields.length + instanceFields.length);
+			
+			for (StaticFieldEntry f : staticFields) {
+				fields.add(new StaticFieldImpl(f));
+			}
+			
+			for (InstanceFieldEntry f : instanceFields) {
+				fields.add(new InstanceFieldImpl(f));
+			}
+		}
+		
+		return fields.iterator();
+	}
+
+	/** 
+	 * Method information isn't stored within classes.
+	 * 
+	 */
+	@Override
+	public Iterator getDeclaredMethods() {
+		return new LinkedList().iterator();
+	}
+
+	
+	/**
+	 * Wraps up object ID of class as it's ID.
+	 * That should be sufficiently unique.
+	 * 
+	 * @return ImagePointer
+	 */
+	@Override	
+	public ImagePointer getID() {
+		return new ImagePointerImpl(javaClass.getClassObjectID());
+	}
+
+	/**
+	 * Implemented interfaces aren't stored in Hprof.
+	 * The constant pool could be used if the right entries could be targeted, 
+	 * but there is nothing to suggest that that is possible.
+	 */
+	@Override
+	public Iterator getInterfaces() {
+		return new LinkedList().iterator();
+	}
+
+	/**
+	 * There is no modifier information to return
+	 * @return 0
+	 */
+	@Override
+	public int getModifiers() throws CorruptDataException {
+		return 0;
+	}
+
+	/**
+	 * Returns the classes's name. This is stored in hprof with "." and "$" separators,
+	 * the "."s are replaced by "/"s to conform with the API.
+	 * 
+	 * @return String of the class's name.
+	 */
+	@Override
+	public String getName() throws CorruptDataException {
+		String name = javaClass.getClassName();
+		
+		/* Process the array's such that they are of the format:
+		 * [Ljava/lang/Object;
+		 * 
+		 * or 
+		 * [[B
+		 *  
+		 * Primitive arrays are renamed correctly.
+		 */
+		if(name.indexOf('[') != -1) {
+			int depth=0;
+			String prefix = "";
+			for(int n=0; n < name.length(); n++) {
+				if (name.charAt(n) == '[') {
+					prefix+="[";
+				}
+			}
+			
+			// Chop off arrays.
+			name = name.substring(0, name.indexOf('['));
+			
+			if (name.startsWith("boolean")) {
+				name = "Z";
+			} else if (name.startsWith("byte")) {
+				name = "B";
+			} else if (name.startsWith("char")) {
+				name = "C";
+			} else if (name.startsWith("short")) {
+				name = "S";
+			} else if (name.startsWith("int")) {
+				name = "I";
+			} else if (name.startsWith("long")) {
+				name = "J";
+			} else if (name.startsWith("float")) {
+				name = "F";
+			} else if (name.startsWith("double")) {
+				name = "D";
+			} else {
+				name = "L" + name.replace('.', '/') +";";
+			}
+			return prefix+name;
+		}
+		return name.replace('.', '/');
+	}
+
+	/**
+	 * Returns null. There are no java/lang/Class objects referenced
+	 * by the class records. 
+	 */
+	@Override
+	public JavaObject getObject() throws CorruptDataException {
+		return null;
+	}
+
+	/**
+	 * Return the superclass of this class or null.
+	 * 
+	 * @return JavaClassImpl or null
+	 */
+	@Override
+	public JavaClassImpl getSuperclass() throws CorruptDataException {
+		long superClassObjId = javaClass.getSuperClassObjectID();
+		
+		// This is an assumption, but it will be necessary.
+		if (superClassObjId == 0L) {
+			return null;
+		}
+		
+		return heap.getJavaClassByID(superClassObjId);
+	}
+
+	@Override
+	public Iterator getReferences() {
+		// TODO Auto-generated method stub
+		// All object references, constantpool entries, superclass, etc.
+		return null;
+	}
+
+	/**
+	 * Returns true if this is an array.
+	 * 
+	 * @return true if this class is an array type.
+	 */
+	@Override
+	public boolean isArray() throws CorruptDataException {
+		return javaClass.getClassName().indexOf('[') != -1;
+	}
+
+	/**
+	 * @return true if passed object is this JavaClass
+	 */
+	public boolean equals(Object obj) {
+		if (obj == null) {
+			return false;
+		} 
+		
+		if (!(obj instanceof JavaClassImpl)) {
+			return false;
+		}
+		
+		if (obj == this) {
+			return true;
+		}
+		
+		JavaClassImpl clazz = (JavaClassImpl) obj;
+		
+		return clazz.getObjectID() == getObjectID();
+	}
+	
+	/**
+	 * Gets the object ID that uniquely identifies this class on the heap.
+	 * 
+	 * @return long object ID
+	 */
+	long getObjectID() {
+		return javaClass.getClassObjectID();
+	}
+	
+	public String toString() {
+		String name = "<UNSET CLASS NAME>";
+		try {
+			name = this.getName();
+		} catch (CorruptDataException e) {
+			// oh well.
+		}
+		return name+" @ "+ Long.toHexString(javaClass.getClassObjectID());
+	}
+	
+	public int hashCode() {
+		return (int) (javaClass.getClassObjectID() % Integer.MAX_VALUE);
+	}
+	
+	/**
+	 * Return the size of object instances.
+	 * 
+	 * @return int of the object size.
+	 */
+	int getInstanceSize() {
+		return javaClass.getInstanceSize();
+	}
+	
+	/**
+	 * Returns the number of bytes the part of this class takes up in an instance object.
+	 * This is the number of bytes taken up by the fields in this class and none of its
+	 * superclasses.
+	 * This is different from getInstanceSize(), which is the size of an instance of this
+	 * class, including all superclasses.
+	 * 
+	 * @return int fields size
+	 */
+	int getOffsetSize() {
+		return javaClass.getOffsetSize();
+	}
+}

Added: incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaClassLoaderImpl.java
URL: http://svn.apache.org/viewvc/incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaClassLoaderImpl.java?rev=772669&view=auto
==============================================================================
--- incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaClassLoaderImpl.java (added)
+++ incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaClassLoaderImpl.java Thu May  7 14:50:21 2009
@@ -0,0 +1,132 @@
+/*******************************************************************************
+ * 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 org.apache.kato.hprof.java;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedList;
+
+import org.apache.kato.hprof.HProfView;
+import org.apache.kato.hprof.IJavaClass;
+import org.apache.kato.hprof.IJavaClassLoader;
+import org.apache.kato.hprof.image.CorruptDataImpl;
+import org.apache.kato.hprof.image.ImagePointerImpl;
+import org.apache.kato.image.CorruptDataException;
+import org.apache.kato.java.JavaClassLoader;
+import org.apache.kato.java.JavaObject;
+
+/**
+ * Implements JavaClassLoader.
+ * 
+ *
+ */
+public class JavaClassLoaderImpl implements JavaClassLoader {
+	IJavaClassLoader loader;
+	IJavaHeapInternal heap;
+	
+	public JavaClassLoaderImpl(IJavaHeapInternal heap, IJavaClassLoader loader) {
+		this.loader = loader;
+		this.heap = heap;;
+	}
+	
+	/**
+	 * Returns the JavaClassImpl that has the name passed.
+	 * 
+	 * Iterates through all of the Class object IDs, and retrieves
+	 * the IJavaClasses held in HProfView, so as not to create JavaClasses
+	 * unnecessarily.
+	 */
+	@Override
+	public JavaClassImpl findClass(String className) throws CorruptDataException {
+		if (className == null) {
+			return null;
+		} else if (className.length() == 0) {
+			return null;
+		}
+		
+		Collection<Long> classes = loader.getClasses();
+		
+		for (Long ID : classes) {
+			JavaClassImpl clazz = heap.getJavaClassByID(ID);
+			if (className.equals(clazz.getName())) {
+				return clazz;
+			}
+		}
+		
+		return null;
+	}
+
+	@Override
+	/**
+	 * Returns an empty Iterator, as the HProf format doesn't describe
+	 * how the classes are cached.
+	 * 
+	 * FIXME It may be possible to pull out the classes from the java.lang.ClassLoader.classes Vector 
+	 */
+	public Iterator getCachedClasses() {
+		return new LinkedList().iterator();
+	}
+
+	@Override
+	public Iterator getDefinedClasses() {
+		return new ClassesIterator();
+	}
+
+	/**
+	 * An iterator over the classes loaded by this class loader.
+	 * Wraps the IDs this class loader holds with JavaClassImpls.
+	 * 
+	 * @author monteith
+	 *
+	 */
+	private class ClassesIterator implements Iterator {
+		private Collection<Long> classes = loader.getClasses();
+		private Iterator<Long> iterator = classes.iterator();		
+		@Override
+		public boolean hasNext() {
+			return iterator.hasNext();
+		}
+
+		@Override
+		public Object next() {
+			Long ID = iterator.next();
+			JavaClassImpl clazz = heap.getJavaClassByID(ID);
+
+			if (clazz == null) {
+				return new CorruptDataImpl(new ImagePointerImpl(ID), "Can't match class object ID to a JavaClassImpl.");
+			}
+			
+			return clazz;
+		}
+
+		/**
+		 * Not implemented.
+		 */
+		@Override
+		public void remove() {
+			throw new UnsupportedOperationException("remove() not supported for ClassesIterator");
+		}
+		
+	}
+	
+	/**
+	 * Gets the java/lang/ClassLoader object from the heap.
+	 * 
+	 */
+	@Override
+	public JavaObject getObject() throws CorruptDataException {
+		return heap.getObjectByID(this.loader.getID());
+	}
+
+}

Added: incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaHeapImpl.java
URL: http://svn.apache.org/viewvc/incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaHeapImpl.java?rev=772669&view=auto
==============================================================================
--- incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaHeapImpl.java (added)
+++ incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaHeapImpl.java Thu May  7 14:50:21 2009
@@ -0,0 +1,309 @@
+/*******************************************************************************
+ * 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 org.apache.kato.hprof.java;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.WeakHashMap;
+
+import org.apache.kato.common.BasicType;
+import org.apache.kato.hprof.HProfView;
+import org.apache.kato.hprof.IJavaClass;
+import org.apache.kato.hprof.IJavaClassLoader;
+import org.apache.kato.hprof.datalayer.IGCInstanceHeapDumpRecord;
+import org.apache.kato.hprof.datalayer.IGCObjectArrayHeapDumpRecord;
+import org.apache.kato.hprof.datalayer.IGCPrimitiveArrayHeapDumpRecord;
+import org.apache.kato.hprof.datalayer.IHProfRecord;
+import org.apache.kato.hprof.datalayer.IHeapDumpHProfRecord;
+import org.apache.kato.hprof.datalayer.IHeapObject;
+import org.apache.kato.java.JavaObject;
+
+
+/**
+ * Contains the contents of the heap - JavaClasses and JavaClassLoaders and object
+ * of all sorts.
+ * 
+ *
+ */
+public class JavaHeapImpl implements IJavaHeapInternal {
+	private JavaRuntimeImpl runtime;
+	private HProfView view=null;
+	long  heapRecordId=0;
+	
+	public JavaHeapImpl(JavaRuntimeImpl runtime,long loc) {
+		if(loc<1) throw new IllegalArgumentException("heap record id ["+loc+"] is less than 1");
+		this.view=runtime.getView();
+		this.heapRecordId=loc;
+		this.runtime = runtime;
+	}
+	
+	@Override
+	public String getName() {
+		
+		return ""+heapRecordId;
+	}
+
+	@Override
+	public Iterator getObjects() {
+		
+		final IHeapDumpHProfRecord record=view.getHeapRecord();
+		
+		if(record==null) return buildEmptyIterator();
+		
+		Iterator iter = new Iterator(){
+			
+			int latestRecord=0;
+			private JavaObject nextObject=null;
+			
+			@Override
+			public boolean hasNext() {
+				
+				if(nextObject!=null) return true;
+				
+				while(true) {
+					IHProfRecord subRecord=record.getSubRecord(latestRecord);
+					if(subRecord==null) {
+						return false;
+					}
+					
+					latestRecord++;
+					
+					// is this an object record?
+					if(subRecord instanceof IGCInstanceHeapDumpRecord) {
+						IGCInstanceHeapDumpRecord instance = (IGCInstanceHeapDumpRecord) subRecord;
+						
+						nextObject = new JavaObjectInstanceImpl(JavaHeapImpl.this, instance);
+						return true;
+					} else if (subRecord instanceof IGCObjectArrayHeapDumpRecord) {
+						IGCObjectArrayHeapDumpRecord objArray = (IGCObjectArrayHeapDumpRecord) subRecord;
+						nextObject = new JavaObjectArrayImpl(JavaHeapImpl.this, objArray);
+						return true;						
+					} else if (subRecord instanceof IGCPrimitiveArrayHeapDumpRecord) {
+						IGCPrimitiveArrayHeapDumpRecord primArray = (IGCPrimitiveArrayHeapDumpRecord) subRecord;
+						nextObject = new JavaPrimitiveArrayImpl(JavaHeapImpl.this, primArray);
+						return true;
+					} 
+				
+					
+				}
+
+			}
+
+			@Override
+			public Object next() {
+				if (hasNext()) {
+					// We'll never get a new object if nextObject is never null...
+					Object returnObject = nextObject;
+					nextObject = null;
+					return returnObject;
+				} else {
+					throw new NoSuchElementException("JavaHeap.getObjects() reached past end of iterator.");
+				}
+			}
+
+			@Override
+			public void remove() {
+				throw new UnsupportedOperationException("JavaHeap.getObject() Iterator.remove() method not supported.");				
+			}};
+		
+		
+
+			iter.hasNext(); // initialize iterator.
+			return iter;
+	}
+
+	private Iterator buildEmptyIterator() {
+		List l=new LinkedList();
+		return l.iterator();
+	}
+
+	@Override
+	public Iterator getSections() {
+		return buildEmptyIterator();
+	}
+
+	/**
+	 * Retrieves an object by it's ID.
+	 * 
+	 * @param ID
+	 * @return
+	 */
+	@Override
+	public JavaObject getObjectByID(Long ID) {
+		if (ID.longValue() == 0L) {
+			return null;
+		}
+		
+		
+		IHeapObject obj = view.getJavaObjectByID(ID);
+
+		if(obj == null) {
+			return null;
+		}
+		
+		if (obj instanceof IGCInstanceHeapDumpRecord) {
+			return new JavaObjectInstanceImpl(this, (IGCInstanceHeapDumpRecord)obj);
+		} else if (obj instanceof IGCObjectArrayHeapDumpRecord) {
+			return new JavaObjectArrayImpl(this, (IGCObjectArrayHeapDumpRecord) obj);
+		} else if (obj instanceof IGCPrimitiveArrayHeapDumpRecord) {
+			return new JavaPrimitiveArrayImpl(this, (IGCPrimitiveArrayHeapDumpRecord) obj);
+		}
+		
+		return null;
+	}
+
+	private WeakHashMap<Long,JavaClassImpl> classCache = new WeakHashMap<Long,JavaClassImpl>();
+
+	/**
+	 * Provides a single point for getting classes.
+	 * All class instantiations should go through here.
+	 * 
+	 * @param ID ID of a class.
+	 * @return JavaClassImpl
+	 */
+	public JavaClassImpl getJavaClassByID(long ID) {
+		JavaClassImpl javaClass = classCache.get(ID);
+		
+		if (javaClass == null) {
+			IJavaClass clazz = view.getJavaClassByID(ID);
+			javaClass = new JavaClassImpl(this, clazz);
+			classCache.put(ID, javaClass);
+		}
+		
+		return javaClass;
+	}
+
+	private JavaClassImpl[] primitiveArrayClasses = new JavaClassImpl[8];
+	
+	/**
+	 * Gets the primitive array of the passed basic type.
+	 * 
+	 * @see org.apache.kato.common.BasicType
+	 * @param type a value from 4 to 11
+	 * @return JavaClassImpl of a primitive array
+	 */
+	public JavaClassImpl getPrimitiveArrayClass(short type) {
+		if (type <4 || type > 11) {
+			throw new IllegalArgumentException("Passed invalid basic type id "+type);
+		}
+		
+		JavaClassImpl clazz = primitiveArrayClasses[type-4];
+		
+		if(clazz == null) {
+			long ID = view.getPrimitiveArrayClass(type).getClassObjectID();
+			clazz = primitiveArrayClasses[type-4] = getJavaClassByID(ID);
+		}
+		
+		return clazz;
+	}
+	
+	private JavaPrimitiveClassImpl[] primitiveClasses = new JavaPrimitiveClassImpl[8];
+	public JavaPrimitiveClassImpl getPrimitiveClass(int type) {
+		if (type < 4 || type > 11) {
+			throw new IllegalArgumentException("Passed invalid basic type id "+type);
+		}
+		
+		JavaPrimitiveClassImpl clazz = primitiveClasses[type-4];
+		
+		if (clazz == null) {
+			String name;
+	
+			switch(type) {
+			case BasicType.BOOLEAN:
+				name = "boolean";
+				break;
+			case BasicType.BYTE:
+				name = "byte";
+				break;
+			case BasicType.SHORT:
+				name = "short";
+				break;
+			case BasicType.CHAR:
+				name = "char";
+				break;
+			case BasicType.INT:
+				name = "int";
+				break;
+			case BasicType.LONG:
+				name = "long";
+				break;
+			case BasicType.FLOAT:
+				name = "float";
+				break;
+			case BasicType.DOUBLE:
+				name = "double";
+				break;
+				default:
+					 name ="<invalid primitive class type "+type+">";
+			}
+			
+			clazz = primitiveClasses[type-4] = new JavaPrimitiveClassImpl(name, type);
+		}
+		
+		return clazz;
+	}
+	
+	/**
+	 * Map from JavaClassLoader IDs to JavaClassLoaders.
+	 */
+	private Map<Long,JavaClassLoaderImpl> javaClassLoaders;
+	
+	/**
+	 * Create a map of JavaClassLoader object ID's to JavaClassLoaderImpl's.
+	 *
+	 * JavaClassLoaders are expected to be sufficiently low in number to warrant
+	 * keeping a definitive collection to avoid duplication by JavaClasses.
+	 */
+	private void createJavaClassLoaders() {
+		if (javaClassLoaders == null) {
+			javaClassLoaders = new HashMap<Long,JavaClassLoaderImpl>();
+			for (IJavaClassLoader loader : view.getJavaClassLoaders()) {
+				javaClassLoaders.put(loader.getID(),new JavaClassLoaderImpl(this, loader));
+			}
+		}
+	}
+	
+	@Override
+	/**
+	 * Returns the java class loaders
+	 * @return 
+	 */
+	public Collection<JavaClassLoaderImpl> getJavaClassLoaders() {
+		createJavaClassLoaders();
+		return javaClassLoaders.values();
+	}
+	/**
+	 * Retrieve a JavaClassLoaderImpl by it's ID.
+	 * Used by JavaClassImpl.
+	 *  
+	 * @param ID
+	 * @return
+	 */
+	@Override
+	public JavaClassLoaderImpl getJavaClassLoaderByID(long ID) {
+		createJavaClassLoaders();
+		return javaClassLoaders.get(ID);
+	}
+
+	@Override
+	public String getUTF8StringByID(long ID) {
+		return view.getUTF8String(ID);
+	}
+	
+}

Added: incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaObjectArrayImpl.java
URL: http://svn.apache.org/viewvc/incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaObjectArrayImpl.java?rev=772669&view=auto
==============================================================================
--- incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaObjectArrayImpl.java (added)
+++ incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaObjectArrayImpl.java Thu May  7 14:50:21 2009
@@ -0,0 +1,168 @@
+/*******************************************************************************
+ * 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 org.apache.kato.hprof.java;
+
+import java.util.Iterator;
+
+import org.apache.kato.hprof.datalayer.IGCObjectArrayHeapDumpRecord;
+import org.apache.kato.hprof.image.ImagePointerImpl;
+import org.apache.kato.image.CorruptDataException;
+import org.apache.kato.image.DataUnavailable;
+import org.apache.kato.image.ImagePointer;
+import org.apache.kato.image.MemoryAccessException;
+import org.apache.kato.java.JavaClass;
+import org.apache.kato.java.JavaHeap;
+import org.apache.kato.java.JavaObject;
+
+/**
+ * An array of object references.
+ * 
+ * 
+ *
+ */
+public class JavaObjectArrayImpl implements JavaObject {
+	private IJavaHeapInternal heap;
+	private IGCObjectArrayHeapDumpRecord record;
+
+	public JavaObjectArrayImpl(IJavaHeapInternal heap, IGCObjectArrayHeapDumpRecord record) {
+		this.heap = heap;
+		this.record = record;		
+	}
+
+	/**
+	 * Retrieves object IDs from the record on the disk and fills in array
+	 * with JavaObjects by mapping from the IDs to JavaObjects.
+	 * 
+	 */
+	@Override
+	public void arraycopy(int srcStart, Object dst, int dstStart, int length)
+			throws CorruptDataException, MemoryAccessException {
+		if (srcStart < 0 || srcStart > getArraySize()) {
+			throw new IndexOutOfBoundsException("srcStart must be between 0 and " + getArraySize()+", not " + srcStart);
+		}
+		
+		if (srcStart+length > getArraySize()) {
+			throw new IndexOutOfBoundsException("srcStart+length must be <="+getArraySize()+", srcStart=" + srcStart+", length="+length);			
+		}
+		if (dstStart < 0) {
+			throw new IndexOutOfBoundsException("dstStart must be >=0, not " + dstStart);
+		}
+
+		if (dst == null) {
+			throw new IllegalArgumentException("Destination array must not be null");
+		}
+		if (!dst.getClass().isArray()) {
+			throw new IllegalArgumentException("Destination array must be an array, not "+dst.getClass().getName());			
+		}
+		if(dst.getClass().getComponentType() != JavaObject.class) {
+			throw new IllegalArgumentException("Destination array wrong type - must be JavaObject array");
+		}
+		
+		JavaObject[] array = (JavaObject[]) dst;
+		checkArrayBounds(dstStart, array.length, length);
+		
+		for (int i=0; i < length; i++) {
+			array[dstStart+i] = heap.getObjectByID(record.getElement(srcStart+i));
+		}
+	}
+	
+	private static void checkArrayBounds(int arrayStart, int arrayLength, int dataLength) {
+		if ( arrayStart + dataLength > arrayLength) {
+			throw new IndexOutOfBoundsException("Destination array of length "+ arrayLength+" can't" 
+					+ " accomodate array copy with start of "+arrayStart+" and length of "+ dataLength);
+		}
+	}
+	@Override
+	public int getArraySize() throws CorruptDataException {
+		return record.getNumberOfElements();
+	}
+
+	@Override
+	public long getHashcode() throws DataUnavailable, CorruptDataException {
+		// this is probably a bad hash
+		return record.getID(); 
+	}
+
+	@Override
+	public JavaHeap getHeap() throws CorruptDataException, DataUnavailable {
+		return heap;
+	}
+
+	@Override
+	public ImagePointer getID() {
+		return new ImagePointerImpl(record.getID());
+	}
+
+	@Override
+	public JavaClass getJavaClass() throws CorruptDataException {
+		return heap.getJavaClassByID(record.getArrayClassObjectID());
+	}
+
+	@Override
+	public long getPersistentHashcode() throws DataUnavailable,
+			CorruptDataException {
+		throw new DataUnavailable("Persistent hashcode unknown.");	}
+
+	@Override
+	public Iterator getReferences() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public Iterator getSections() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public long getSize() throws CorruptDataException {
+		return 0;
+	}
+
+	@Override
+	public boolean isArray() throws CorruptDataException {
+		return true;
+	}
+	
+	/**
+	 * Compares identity. This object may be created multiple times.
+	 * Uses object ID for comparing identity. 
+	 * We don't check runtime identity.
+	 */
+	@Override
+	public boolean equals(Object obj) {
+		if (obj == null) {
+			return false;
+		}
+		
+		if (!(obj instanceof JavaObjectArrayImpl)) {
+			JavaObjectArrayImpl other = (JavaObjectArrayImpl) obj;
+			
+			if (other.getObjectID() == record.getID()) {
+				return true;
+			}
+		}
+		
+		return false;
+	}
+	
+	/**
+	 * Return object ID of record on disk.
+	 * @return
+	 */
+	long getObjectID() {
+		return record.getID();
+	}
+}

Added: incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaObjectInstanceImpl.java
URL: http://svn.apache.org/viewvc/incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaObjectInstanceImpl.java?rev=772669&view=auto
==============================================================================
--- incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaObjectInstanceImpl.java (added)
+++ incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaObjectInstanceImpl.java Thu May  7 14:50:21 2009
@@ -0,0 +1,238 @@
+/*******************************************************************************
+ * 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 org.apache.kato.hprof.java;
+
+import java.util.Iterator;
+
+import org.apache.kato.hprof.datalayer.IGCInstanceHeapDumpRecord;
+import org.apache.kato.hprof.image.ImagePointerImpl;
+import org.apache.kato.image.CorruptDataException;
+import org.apache.kato.image.DataUnavailable;
+import org.apache.kato.image.ImagePointer;
+import org.apache.kato.image.MemoryAccessException;
+import org.apache.kato.java.JavaHeap;
+import org.apache.kato.java.JavaObject;
+
+final class JavaObjectInstanceImpl implements JavaObject {
+	/**
+	 * 
+	 */
+	private final IGCInstanceHeapDumpRecord record;
+	private IJavaHeapInternal heap;
+	
+	JavaObjectInstanceImpl(IJavaHeapInternal javaHeapImpl, IGCInstanceHeapDumpRecord record) {
+		this.record = record;
+		this.heap = javaHeapImpl;
+	}
+
+	@Override
+	public void arraycopy(int srcStart, Object dst,
+			int dstStart, int length)
+			throws CorruptDataException,
+			MemoryAccessException {
+		throw new IllegalArgumentException("instance is not an array");		
+	}
+
+	@Override
+	public int getArraySize()
+			throws CorruptDataException {		
+		throw new IllegalArgumentException("instance is not an array");
+	}
+
+	@Override
+	public long getHashcode() throws DataUnavailable,
+			CorruptDataException {		
+		return record.getID();
+	}
+
+	@Override
+	public JavaHeap getHeap()
+			throws CorruptDataException,
+			DataUnavailable {
+		return heap;
+	}
+
+	@Override
+	public ImagePointer getID() {		
+		return new ImagePointerImpl(record.getID());
+	}
+
+	@Override
+	public JavaClassImpl getJavaClass()
+			throws CorruptDataException {
+		return heap.getJavaClassByID(record.getClassObjectID());
+	}
+
+	@Override
+	public long getPersistentHashcode()
+			throws DataUnavailable,
+			CorruptDataException {
+		throw new DataUnavailable("Persistent hashcode unknown.");
+	}
+
+	@Override
+	public Iterator getReferences() {
+		return new Iterator(){			
+			@Override
+			public boolean hasNext() {
+				// TODO Auto-generated method stub
+				return false;
+			}
+
+			@Override
+			public Object next() {
+				// TODO Auto-generated method stub
+				return null;
+			}
+
+			@Override
+			public void remove() {
+				// TODO Auto-generated method stub
+				
+			}};
+	}
+
+	@Override
+	public Iterator getSections() {		
+		return null;
+	}
+
+	@Override
+	public long getSize() throws CorruptDataException {
+		return getJavaClass().getInstanceSize(); 
+	}
+
+	@Override
+	public boolean isArray()
+			throws CorruptDataException {
+		return false;
+	}
+
+	/**
+	 * Retrieve a byte field from this object.
+	 * 
+	 * @param offset into instance values.
+	 * @return byte value
+	 */
+	boolean getBooleanField(int offset) {
+		return record.getBooleanField(offset);
+	}
+	
+	/**
+	 * Retrieve a byte field from this object.
+	 * 
+	 * @param offset into instance values.
+	 * @return byte value
+	 */
+	byte getByteField(int offset) {
+		return record.getByteField(offset);
+	}
+	
+	/**
+	 * Retrieve a char field from this object.
+	 * 
+	 * @param offset into instance values.
+	 * @return char value
+	 */
+	char getCharField(int offset) {
+		return record.getCharField(offset);
+	}
+	
+	/**
+	 * Retrieve a short field from this object.
+	 * 
+	 * @param offset into instance values.
+	 * @return short value
+	 */
+	short getShortField(int offset) {
+		return record.getShortField(offset);
+	}
+	
+	/**
+	 * Retrieve a int field from this object.
+	 * 
+	 * @param offset into instance values.
+	 * @return int value
+	 */
+	int getIntegerField(int offset) {
+		return record.getIntegerField(offset);
+	}
+	
+	/**
+	 * Retrieve a long field from this object.
+	 * 
+	 * @param offset into instance values.
+	 * @return long value
+	 */
+	long getLongField(int offset) {
+		return record.getLongField(offset);
+	}
+	
+	/**
+	 * Retrieve a float field from this object.
+	 * 
+	 * @param offset into instance values.
+	 * @return float value
+	 */
+	float getFloatField(int offset) {
+		return record.getFloatField(offset);
+	}
+	
+	/**
+	 * Retrieve a double field from this object.
+	 * 
+	 * @param offset into instance values.
+	 * @return double value
+	 */
+	double getDoubleField(int offset) {
+		return record.getDoubleField(offset);
+	}
+	
+	/**
+	 * Retrieve an object ID field from this object.
+	 * 
+	 * @param offset into instance values.
+	 * @return long value - an object ID.
+	 */
+	long getIDField(int offset) {
+		return record.getIDField(offset);
+	}
+	
+	/**
+	 * Compares identity. This object may be created multiple times.
+	 * Uses object ID for comparing identity. 
+	 * We don't check runtime identity.
+	 */
+	@Override
+	public boolean equals(Object obj) {
+		if (obj == null) {
+			return false;
+		}
+		
+		if (obj instanceof JavaObjectInstanceImpl) {
+			JavaObjectInstanceImpl other = (JavaObjectInstanceImpl) obj;
+			
+			if (other.getObjectID() == record.getID()) {
+				return true;
+			}
+		}
+		
+		return false;
+	}
+	
+	long getObjectID() {
+		return record.getID();
+	}
+	
+}
\ No newline at end of file

Added: incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaPrimitiveArrayImpl.java
URL: http://svn.apache.org/viewvc/incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaPrimitiveArrayImpl.java?rev=772669&view=auto
==============================================================================
--- incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaPrimitiveArrayImpl.java (added)
+++ incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaPrimitiveArrayImpl.java Thu May  7 14:50:21 2009
@@ -0,0 +1,258 @@
+/*******************************************************************************
+ * 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 org.apache.kato.hprof.java;
+
+import java.util.Iterator;
+
+import org.apache.kato.common.BasicType;
+import org.apache.kato.hprof.datalayer.IGCPrimitiveArrayHeapDumpRecord;
+import org.apache.kato.hprof.image.CorruptDataImpl;
+import org.apache.kato.hprof.image.ImagePointerImpl;
+import org.apache.kato.image.CorruptDataException;
+import org.apache.kato.image.DataUnavailable;
+import org.apache.kato.image.ImagePointer;
+import org.apache.kato.image.MemoryAccessException;
+import org.apache.kato.java.JavaClass;
+import org.apache.kato.java.JavaHeap;
+import org.apache.kato.java.JavaObject;
+
+public class JavaPrimitiveArrayImpl implements JavaObject {
+	private IJavaHeapInternal heap;
+	private IGCPrimitiveArrayHeapDumpRecord record;
+
+	public JavaPrimitiveArrayImpl(IJavaHeapInternal heap, IGCPrimitiveArrayHeapDumpRecord record) {
+		this.heap = heap;
+		this.record = record;
+	}
+	@Override
+	public void arraycopy(int srcStart, Object dst, int dstStart, int length)
+			throws CorruptDataException, MemoryAccessException {
+		if (srcStart < 0 || srcStart > getArraySize()) {
+			throw new IndexOutOfBoundsException("srcStart must be between 0 and " + getArraySize()+", not " + srcStart);
+		}
+		
+		if (srcStart+length > getArraySize()) {
+			throw new IndexOutOfBoundsException("srcStart+length must be <="+getArraySize()+", srcStart=" + srcStart+", length="+length);			
+		}
+		if (dstStart < 0) {
+			throw new IndexOutOfBoundsException("dstStart must be >=0, not " + dstStart);
+		}
+
+		if (dst == null) {
+			throw new IllegalArgumentException("Destination array must not be null");
+		}
+		if (!dst.getClass().isArray()) {
+			throw new IllegalArgumentException("Destination array must be an array, not "+dst.getClass().getName());			
+		}
+		
+		
+		switch(record.getElementType()) {
+		case BasicType.BOOLEAN:
+		{
+			if(dst.getClass().getComponentType().getName() != "boolean") {
+				throw new IllegalArgumentException("Destination array wrong type - must be boolean");
+			}
+			boolean[] array = (boolean[]) dst;
+			checkArrayBounds(dstStart, array.length, length);
+			
+			for (int i=0; i < length; i++) {
+				array[dstStart+i] = record.getBooleanElement(srcStart+i);
+			}
+			break;
+		}
+		case BasicType.BYTE:
+		{
+			if(dst.getClass().getComponentType().getName() != "byte") {
+				throw new IllegalArgumentException("Destination array wrong type - must be byte");
+			}
+			byte[] array = (byte[]) dst;
+			checkArrayBounds(dstStart, array.length, length);
+			
+			for (int i=0; i < length; i++) {
+				array[dstStart+i] = (byte) record.getByteElement(srcStart+i);
+			}
+			break;
+		}
+		case BasicType.SHORT:
+		{
+			if(dst.getClass().getComponentType().getName() != "short") {
+				throw new IllegalArgumentException("Destination array wrong type - must be short");
+			}
+			short[] array = (short[]) dst;
+			checkArrayBounds(dstStart, array.length, length);
+			
+			for (int i=0; i < length; i++) {
+				array[dstStart+i] =  record.getShortElement(srcStart+i);
+			}
+			break;
+		}
+		case BasicType.CHAR:
+		{
+			if(dst.getClass().getComponentType().getName() != "char") {
+				throw new IllegalArgumentException("Destination array wrong type - must be char");
+			}
+			char[] array = (char[]) dst;
+			checkArrayBounds(dstStart, array.length, length);
+			
+			for (int i=0; i < length; i++) {
+				array[dstStart+i] =  record.getCharElement(srcStart+i);
+			}
+			break;
+		}
+		case BasicType.INT:
+		{
+			if(dst.getClass().getComponentType().getName() != "int") {
+				throw new IllegalArgumentException("Destination array wrong type - must be int");
+			}
+			int[] array = (int[]) dst;
+			checkArrayBounds(dstStart, array.length, length);
+			
+			for (int i=0; i < length; i++) {
+				array[dstStart+i] =  record.getIntElement(srcStart+i);
+			}
+			break;
+		}
+		case BasicType.LONG:
+		{
+			if(dst.getClass().getComponentType().getName() != "long") {
+				throw new IllegalArgumentException("Destination array wrong type - must be long");
+			}
+			long[] array = (long[]) dst;
+			checkArrayBounds(dstStart, array.length, length);
+			
+			for (int i=0; i < length; i++) {
+				array[dstStart+i] =  record.getLongElement(srcStart+i);
+			}
+			break;
+		}
+		case BasicType.FLOAT:
+		{
+			if(dst.getClass().getComponentType().getName() != "float") {
+				throw new IllegalArgumentException("Destination array wrong type - must be float");
+			}
+			float[] array = (float[]) dst;
+			checkArrayBounds(dstStart, array.length, length);
+			
+			for (int i=0; i < length; i++) {
+				array[dstStart+i] =  record.getFloatElement(srcStart+i);
+			}
+			break;
+		}
+		case BasicType.DOUBLE:
+		{
+			if(dst.getClass().getComponentType().getName() != "double") {
+				throw new IllegalArgumentException("Destination array wrong type - must be double");
+			}
+			double[] array = (double[]) dst;
+			checkArrayBounds(dstStart, array.length, length);
+			
+			for (int i=0; i < length; i++) {
+				array[dstStart+i] =  record.getDoubleElement(srcStart+i);
+			}
+			break;
+		}
+		default:
+			throw new CorruptDataException(new CorruptDataImpl("Primitive array has invalid type of "+record.getElementType()));
+		}
+	}
+
+	private static void checkArrayBounds(int arrayStart, int arrayLength, int dataLength) {
+		if ( arrayStart + dataLength > arrayLength) {
+			throw new IndexOutOfBoundsException("Destination array of length "+ arrayLength+" can't" 
+					+ " accomodate array copy with start of "+arrayStart+" and length of "+ dataLength);
+		}
+	}
+	@Override
+	public int getArraySize() throws CorruptDataException {
+		return record.getNumberOfElements();
+	}
+
+	@Override
+	public long getHashcode() throws DataUnavailable, CorruptDataException {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public JavaHeap getHeap() throws CorruptDataException, DataUnavailable {
+		return heap;
+	}
+
+	@Override
+	public ImagePointer getID() {
+		return new ImagePointerImpl(record.getID());
+	}
+
+	@Override
+	public JavaClass getJavaClass() throws CorruptDataException {
+		return heap.getPrimitiveArrayClass(record.getElementType());
+	}
+
+	@Override
+	public long getPersistentHashcode() throws DataUnavailable,
+			CorruptDataException {
+		throw new DataUnavailable("Persistent hashcode unknown.");	}
+
+	@Override
+	public Iterator getReferences() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public Iterator getSections() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public long getSize() throws CorruptDataException {
+		return 0;
+	}
+
+	@Override
+	public boolean isArray() throws CorruptDataException {
+		return true;
+	}
+
+	/**
+	 * Compares identity. This object may be created multiple times.
+	 * Uses object ID for comparing identity. 
+	 * We don't check runtime identity.
+	 */
+	@Override
+	public boolean equals(Object obj) {
+		if (obj == null) {
+			return false;
+		}
+		
+		if (!(obj instanceof JavaPrimitiveArrayImpl)) {
+			JavaPrimitiveArrayImpl other = (JavaPrimitiveArrayImpl) obj;
+			
+			if (other.getObjectID() == record.getID()) {
+				return true;
+			}
+		}
+		
+		return false;
+	}
+	
+	/**
+	 * Return object ID of record on disk.
+	 * @return
+	 */
+	long getObjectID() {
+		return record.getID();
+	}
+}

Added: incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaPrimitiveClassImpl.java
URL: http://svn.apache.org/viewvc/incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaPrimitiveClassImpl.java?rev=772669&view=auto
==============================================================================
--- incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaPrimitiveClassImpl.java (added)
+++ incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaPrimitiveClassImpl.java Thu May  7 14:50:21 2009
@@ -0,0 +1,108 @@
+/*******************************************************************************
+ * 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 org.apache.kato.hprof.java;
+
+import java.util.Iterator;
+import java.util.Vector;
+
+import org.apache.kato.hprof.image.ImagePointerImpl;
+import org.apache.kato.image.CorruptDataException;
+import org.apache.kato.image.ImagePointer;
+import org.apache.kato.java.JavaClass;
+import org.apache.kato.java.JavaClassLoader;
+import org.apache.kato.java.JavaObject;
+
+/**
+ * There aren't any primitive types in hprof dumps.
+ * We have to fake them.
+ * 
+ *
+ */
+public class JavaPrimitiveClassImpl implements JavaClass {
+	private String name;
+	private int id;
+
+	public JavaPrimitiveClassImpl(String name, int id) {
+		this.name = name;
+		this.id = id;
+	}
+	
+	@Override
+	public JavaClassLoader getClassLoader() throws CorruptDataException {
+		// TODO This should probably exist.
+		return null;
+	}
+
+	@Override
+	public JavaClass getComponentType() throws CorruptDataException {
+		return null;
+	}
+
+	@Override
+	public Iterator getConstantPoolReferences() {
+		return new Vector(0).iterator();
+	}
+
+	@Override
+	public Iterator getDeclaredFields() {
+		return new Vector(0).iterator();
+	}
+
+	@Override
+	public Iterator getDeclaredMethods() {
+		return new Vector(0).iterator();
+	}
+
+	
+	@Override
+	public ImagePointer getID() {
+		// Use basic type id as the id.
+		return new ImagePointerImpl(id);
+	}
+
+	@Override
+	public Iterator getInterfaces() {
+		return new Vector(0).iterator();
+	}
+
+	@Override
+	public int getModifiers() throws CorruptDataException {
+		return 0;
+	}
+
+	@Override
+	public String getName() throws CorruptDataException {
+		return name;
+	}
+
+	@Override
+	public JavaObject getObject() throws CorruptDataException {
+		return null;
+	}
+
+	@Override
+	public Iterator getReferences() {
+		return new Vector(0).iterator();
+	}
+
+	@Override
+	public JavaClass getSuperclass() throws CorruptDataException {
+		return null;		
+	}
+
+	@Override
+	public boolean isArray() throws CorruptDataException {
+		return false;
+	}
+}

Added: incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaRuntimeImpl.java
URL: http://svn.apache.org/viewvc/incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaRuntimeImpl.java?rev=772669&view=auto
==============================================================================
--- incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaRuntimeImpl.java (added)
+++ incubator/kato/trunk/KatoHProfAdapterPOC/src/org/apache/kato/hprof/java/JavaRuntimeImpl.java Thu May  7 14:50:21 2009
@@ -0,0 +1,160 @@
+/*******************************************************************************
+ * 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 org.apache.kato.hprof.java;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+import org.apache.kato.common.BasicType;
+import org.apache.kato.common.IViewMonitor;
+import org.apache.kato.hprof.HProfView;
+import org.apache.kato.hprof.IJavaClass;
+import org.apache.kato.hprof.IJavaClassLoader;
+import org.apache.kato.hprof.datalayer.HProfFile;
+import org.apache.kato.hprof.datalayer.IGCInstanceHeapDumpRecord;
+import org.apache.kato.hprof.datalayer.IGCObjectArrayHeapDumpRecord;
+import org.apache.kato.hprof.datalayer.IGCPrimitiveArrayHeapDumpRecord;
+import org.apache.kato.hprof.datalayer.IHeapObject;
+import org.apache.kato.image.CorruptDataException;
+import org.apache.kato.image.DataUnavailable;
+import org.apache.kato.image.ImagePointer;
+import org.apache.kato.image.MemoryAccessException;
+import org.apache.kato.java.JavaHeap;
+import org.apache.kato.java.JavaObject;
+import org.apache.kato.java.JavaRuntime;
+import org.apache.kato.java.JavaVMInitArgs;
+
+public class JavaRuntimeImpl implements JavaRuntime {
+
+	private HProfView view=null;
+	public JavaRuntimeImpl(HProfFile file) {
+		this.view=new HProfView(file);
+		view.open(new IViewMonitor(){
+
+			@Override
+			public void error(IOException e) {
+				// TODO Auto-generated method stub
+				
+			}});
+		heap = new JavaHeapImpl(this, view.getHeapRecordLocation());
+	}
+
+	/**
+	 * Return the HProfView this JavaRuntime is based on.
+	 * 
+	 * @return HProfView.
+	 */
+	HProfView getView() {
+		return view;
+	}
+	
+	@Override
+	public Iterator getCompiledMethods() {
+		
+		
+		List l=new LinkedList();
+		return l.iterator();
+	}
+
+	@Override
+	public Iterator getHeapRoots() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	private JavaHeapImpl heap;
+	
+	@Override
+	public Iterator getHeaps() {
+		List<JavaHeapImpl> l=new LinkedList<JavaHeapImpl>();
+		l.add(heap);
+		return l.iterator();
+	}
+
+	
+	
+	/**
+	 * Retrieves all of the JavaClassLoaders owned by this JavaRuntime.
+	 * 
+	 * 
+	 * @return Iterator<JavaClassLoaderImpl>
+	 */
+	@Override	
+	public Iterator<JavaClassLoaderImpl> getJavaClassLoaders() {
+		return heap.getJavaClassLoaders().iterator();
+	}
+
+	
+	@Override
+	public ImagePointer getJavaVM() throws CorruptDataException {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public JavaVMInitArgs getJavaVMInitArgs() throws DataUnavailable,
+			CorruptDataException {
+			throw new DataUnavailable();
+			
+	}
+
+	@Override
+	public Iterator getMonitors() {
+		
+		return null;
+	}
+
+	@Override
+	public JavaObject getObjectAtAddress(ImagePointer address)
+			throws CorruptDataException, IllegalArgumentException,
+			MemoryAccessException, DataUnavailable {
+		return heap.getObjectByID(address.getAddress());
+	}
+
+	@Override
+	public Iterator getThreads() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public Object getTraceBuffer(String bufferName, boolean formatted)
+			throws CorruptDataException {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public String getFullVersion() throws CorruptDataException {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public String getVersion() throws CorruptDataException {
+		// TODO Auto-generated method stub
+		return null;
+	}
+	
+
+
+	JavaHeap getHeap() {
+		return heap;
+	}
+}

Added: incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/data/empty.hprof
URL: http://svn.apache.org/viewvc/incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/data/empty.hprof?rev=772669&view=auto
==============================================================================
    (empty)

Added: incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/data/headeronly.hprof
URL: http://svn.apache.org/viewvc/incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/data/headeronly.hprof?rev=772669&view=auto
==============================================================================
Binary file - no diff available.

Propchange: incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/data/headeronly.hprof
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/data/minimal.hprof
URL: http://svn.apache.org/viewvc/incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/data/minimal.hprof?rev=772669&view=auto
==============================================================================
Binary file - no diff available.

Propchange: incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/data/minimal.hprof
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/data/populated.hprof
URL: http://svn.apache.org/viewvc/incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/data/populated.hprof?rev=772669&view=auto
==============================================================================
Binary file - no diff available.

Propchange: incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/data/populated.hprof
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/org/apache/kato/hprof/java/GCInstanceHeapDumpRecordTest.java
URL: http://svn.apache.org/viewvc/incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/org/apache/kato/hprof/java/GCInstanceHeapDumpRecordTest.java?rev=772669&view=auto
==============================================================================
--- incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/org/apache/kato/hprof/java/GCInstanceHeapDumpRecordTest.java (added)
+++ incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/org/apache/kato/hprof/java/GCInstanceHeapDumpRecordTest.java Thu May  7 14:50:21 2009
@@ -0,0 +1,90 @@
+/*******************************************************************************
+ * 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 org.apache.kato.hprof.java;
+
+import org.apache.kato.hprof.datalayer.IGCInstanceHeapDumpRecord;
+
+public class GCInstanceHeapDumpRecordTest implements IGCInstanceHeapDumpRecord{
+	@Override
+	public boolean getBooleanField(int offset) {
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	@Override
+	public byte getByteField(int offset) {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public char getCharField(int offset) {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public long getClassObjectID() {
+		return 12;
+	}
+
+	@Override
+	public double getDoubleField(int offset) {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public float getFloatField(int offset) {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public long getIDField(int offset) {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public int getIntegerField(int offset) {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public long getLongField(int offset) {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public short getShortField(int offset) {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public long getID() {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public int getStackTraceNumber() {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+	
+}
\ No newline at end of file

Added: incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/org/apache/kato/hprof/java/JavaHeapImplTest.java
URL: http://svn.apache.org/viewvc/incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/org/apache/kato/hprof/java/JavaHeapImplTest.java?rev=772669&view=auto
==============================================================================
--- incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/org/apache/kato/hprof/java/JavaHeapImplTest.java (added)
+++ incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/org/apache/kato/hprof/java/JavaHeapImplTest.java Thu May  7 14:50:21 2009
@@ -0,0 +1,83 @@
+/*******************************************************************************
+ * 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 org.apache.kato.hprof.java;
+
+import java.util.Collection;
+import java.util.Iterator;
+
+import org.apache.kato.java.JavaObject;
+
+public class JavaHeapImplTest implements IJavaHeapInternal {
+
+	@Override
+	public JavaClassImpl getJavaClassByID(long arrayClassObjectID) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public JavaClassLoaderImpl getJavaClassLoaderByID(long classLoaderObjectID) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public Collection<JavaClassLoaderImpl> getJavaClassLoaders() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public JavaObject getObjectByID(Long element) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public JavaClassImpl getPrimitiveArrayClass(short elementType) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public JavaPrimitiveClassImpl getPrimitiveClass(int l) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public String getUTF8StringByID(long fieldNameID) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public String getName() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public Iterator getObjects() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public Iterator getSections() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+}

Added: incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/org/apache/kato/hprof/java/JavaObjectInstanceImplTest.java
URL: http://svn.apache.org/viewvc/incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/org/apache/kato/hprof/java/JavaObjectInstanceImplTest.java?rev=772669&view=auto
==============================================================================
--- incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/org/apache/kato/hprof/java/JavaObjectInstanceImplTest.java (added)
+++ incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/org/apache/kato/hprof/java/JavaObjectInstanceImplTest.java Thu May  7 14:50:21 2009
@@ -0,0 +1,60 @@
+package org.apache.kato.hprof.java;
+
+
+/*******************************************************************************
+ * 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.
+ ******************************************************************************/
+import junit.framework.TestCase;
+
+public class JavaObjectInstanceImplTest extends TestCase {
+	JavaObjectInstanceImpl instance;
+	IJavaHeapInternal heap;
+	GCInstanceHeapDumpRecordTest gcInstance;
+	
+	public void setUp() {
+		heap = new JavaHeapImplTest();
+		gcInstance =  new GCInstanceHeapDumpRecordTest();
+		instance = new JavaObjectInstanceImpl(heap, gcInstance);
+	}
+	
+	public void testGetHeap() throws Exception {
+		assertEquals("JavaHeaps don't match.", heap, instance.getHeap());
+	}
+	
+	public void testGetID() throws Exception {
+		assertEquals("ID incorrectly retrieved", gcInstance.getID(), instance.getID().getAddress());
+	}
+	
+	public void testGetObjectID() throws Exception {
+		assertEquals("ID incorrectly retrieved", gcInstance.getID(), instance.getObjectID());
+	}
+	public void testEqualsNull() throws Exception {
+		assertFalse("equals(null) should be false.",instance.equals(null));
+	}
+	
+	public void testEqualsWrongType() throws Exception {
+		assertFalse("equals(String) should be false.", instance.equals("Completely wrong type"));
+	}
+	
+	public void testEquals() throws Exception {
+		assertTrue("instance.equals(instance) should be true.", instance.equals(instance));
+	}
+	
+	public void testIsArray() throws Exception {
+		assertFalse("instance.isArray() should be false", instance.isArray());
+	}
+	
+	public void testGetArraySize() throws Exception {
+		//assert
+	}
+}

Added: incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/test/apache/kato/hprof/AllTests.java
URL: http://svn.apache.org/viewvc/incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/test/apache/kato/hprof/AllTests.java?rev=772669&view=auto
==============================================================================
--- incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/test/apache/kato/hprof/AllTests.java (added)
+++ incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/test/apache/kato/hprof/AllTests.java Thu May  7 14:50:21 2009
@@ -0,0 +1,40 @@
+/*******************************************************************************
+ * 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 test.apache.kato.hprof;
+
+import test.apache.kato.hprof.image.TestImage;
+import test.apache.kato.hprof.image.TestImageAddressSpace;
+import test.apache.kato.hprof.image.TestImageFactory;
+import test.apache.kato.hprof.image.TestImageProcess;
+import test.apache.kato.hprof.java.TestJavaRuntime;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+public class AllTests {
+
+	public static Test suite() {
+		TestSuite suite = new TestSuite("Test for test.apache.kato.hprof");
+		//$JUnit-BEGIN$
+		suite.addTestSuite(TestImageProcess.class);
+		suite.addTestSuite(TestImageFactory.class);
+		suite.addTestSuite(TestImageAddressSpace.class);
+		suite.addTestSuite(TestImage.class);
+		
+		suite.addTestSuite(TestJavaRuntime.class);
+		
+		//$JUnit-END$
+		return suite;
+	}
+
+}

Added: incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/test/apache/kato/hprof/TestJavaHeap.java
URL: http://svn.apache.org/viewvc/incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/test/apache/kato/hprof/TestJavaHeap.java?rev=772669&view=auto
==============================================================================
--- incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/test/apache/kato/hprof/TestJavaHeap.java (added)
+++ incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/test/apache/kato/hprof/TestJavaHeap.java Thu May  7 14:50:21 2009
@@ -0,0 +1,48 @@
+/*******************************************************************************
+ * 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 test.apache.kato.hprof;
+
+import java.io.IOException;
+
+import org.apache.kato.hprof.HProfView;
+import org.apache.kato.hprof.java.JavaHeapImpl;
+
+import test.apache.kato.hprof.image.AbstractHProfTestCase;
+
+public class TestJavaHeap extends AbstractHProfTestCase {
+
+	public void testNullConstructor() {
+		
+		try {
+		JavaHeapImpl impl=new JavaHeapImpl(null,0);
+		fail("expected illegal argument exception");
+		}
+		catch(IllegalArgumentException iae) {
+			;
+		}
+	}
+	public void testBadHeapRecordIDConstructor() throws IOException {
+		
+		
+		HProfView view=getMinimalHProfView();
+		
+		try {
+		JavaHeapImpl impl=new JavaHeapImpl(view,0);
+		fail("expected illegal argument exception");
+		}
+		catch(IllegalArgumentException iae) {
+			;
+		}
+	}
+}

Added: incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/test/apache/kato/hprof/image/AbstractHProfTestCase.java
URL: http://svn.apache.org/viewvc/incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/test/apache/kato/hprof/image/AbstractHProfTestCase.java?rev=772669&view=auto
==============================================================================
--- incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/test/apache/kato/hprof/image/AbstractHProfTestCase.java (added)
+++ incubator/kato/trunk/KatoHProfAdapterPOC/testsrc/test/apache/kato/hprof/image/AbstractHProfTestCase.java Thu May  7 14:50:21 2009
@@ -0,0 +1,114 @@
+/*******************************************************************************
+ * 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 test.apache.kato.hprof.image;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+import java.util.Iterator;
+
+import junit.framework.TestCase;
+
+import org.apache.kato.hprof.HProfView;
+import org.apache.kato.hprof.datalayer.HProfFactory;
+import org.apache.kato.hprof.datalayer.HProfFile;
+import org.apache.kato.hprof.image.ImageFactoryImpl;
+import org.apache.kato.image.Image;
+import org.apache.kato.image.ImageAddressSpace;
+import org.apache.kato.image.ImageProcess;
+import org.apache.kato.java.JavaHeap;
+import org.apache.kato.java.JavaRuntime;
+
+public abstract class AbstractHProfTestCase extends TestCase {
+
+	 
+	public  File getFile(String fileName) {
+		URL u=getClass().getResource(fileName);
+		String path=u.getPath();
+		File realFile=new File(path);
+		return realFile;
+	}
+
+	protected File getEmptyHProfFile() {
+		File realFile = getFile("/data/empty.hprof");
+		return realFile;
+	}
+
+	protected File getHeaderOnlyHProfFile() {
+		File realFile = getFile("/data/headeronly.hprof");
+		return realFile;
+	}
+	protected File getPopulatedHProfFile() {
+		File realFile = getFile("/data/populated.hprof");
+		return realFile;
+	}
+	protected File getMinimalHProfFile() {
+		File realFile = getFile("/data/minimal.hprof");
+		return realFile;
+	}
+
+	public HProfView getMinimalHProfView() throws IOException {
+		File m=getMinimalHProfFile();
+		HProfFile hprofFile=HProfFactory.createReader(m);
+		hprofFile.open();
+		return new HProfView(hprofFile);
+	
+	}
+	public Image getMinimalImage() throws IOException {
+		ImageFactoryImpl factory=new ImageFactoryImpl();
+		return factory.getImage(getMinimalHProfFile());
+		
+	}
+	public Image getPopulatedImage() throws IOException {
+		ImageFactoryImpl factory=new ImageFactoryImpl();
+		return factory.getImage(getPopulatedHProfFile());
+		
+	}
+	protected ImageAddressSpace getFirstAddressSpace() throws IOException {
+		Image minimal=getMinimalImage();
+		Iterator i=minimal.getAddressSpaces();
+		Object o=i.next();
+		ImageAddressSpace space=(ImageAddressSpace) o;
+		return space;
+	}
+
+	protected ImageProcess getCurrentProcess() throws IOException {
+		
+		ImageAddressSpace space=getFirstAddressSpace();
+		return space.getCurrentProcess();
+		
+	}
+
+	protected JavaRuntime getJavaRuntime() throws IOException {
+		
+		return (JavaRuntime) getCurrentProcess().getRuntimes().next(); 
+	}
+protected JavaRuntime getPopulatedJavaRuntime() throws IOException {
+		
+		return (JavaRuntime) getCurrentProcess().getRuntimes().next(); 
+	}
+
+protected JavaHeap getPopulatedJavaHeap() throws IOException {
+	Image populated=getPopulatedImage();
+	Iterator i=populated.getAddressSpaces();
+	Object o=i.next();
+	ImageAddressSpace space=(ImageAddressSpace) o;
+	ImageProcess process=space.getCurrentProcess();
+	JavaRuntime rt=(JavaRuntime) process.getRuntimes().next();
+	return (JavaHeap) rt.getHeaps().next();
+	 
+}
+
+	
+}



Mime
View raw message