org.eclipse.jdt.debug/model/org/eclipse/jdt/internal/debug/core/model/JDIReferenceType.java - jdt/eclipse.jdt.debug - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2011 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jdt.internal.debug.core.model;

 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;

 import org.eclipse.debug.core.DebugException;
 import org.eclipse.jdt.core.Signature;
 import org.eclipse.jdt.debug.core.IJavaClassObject;
 import org.eclipse.jdt.debug.core.IJavaFieldVariable;
 import org.eclipse.jdt.debug.core.IJavaObject;
 import org.eclipse.jdt.debug.core.IJavaReferenceType;

 import com.ibm.icu.text.MessageFormat;
 import com.sun.jdi.AbsentInformationException;
 import com.sun.jdi.ArrayType;
 import com.sun.jdi.ClassLoaderReference;
 import com.sun.jdi.ClassNotLoadedException;
 import com.sun.jdi.Field;
 import com.sun.jdi.ObjectReference;
 import com.sun.jdi.ReferenceType;
 import com.sun.jdi.Type;
 import com.sun.jdi.VirtualMachine;

 /**
  * References a class, interface, or array type.
  */
 public abstract class JDIReferenceType extends JDIType implements
 		IJavaReferenceType {

 	// field names declared in this type
 	private String[] fDeclaredFields = null;
 	// field names declared in this type, super types, implemented interfaces
 	// and super-interfaces
 	private String[] fAllFields = null;

 	/**
 	 * Constructs a new reference type in the given target.
 	 *
 	 * @param target
 	 *            associated VM
 	 * @param type
 	 *            reference type
 	 */
 	public JDIReferenceType(JDIDebugTarget target, Type type) {
 		super(target, type);
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.jdt.debug.core.IJavaReferenceType#getAvailableStrata()
 	 */
 	public String[] getAvailableStrata() {
 		List<String> strata = getReferenceType().availableStrata();
 		return strata.toArray(new String[strata.size()]);
 	}

 	/**
 	 * Returns the underlying reference type.
 	 *
 	 * @return the underlying reference type
 	 */
 	protected ReferenceType getReferenceType() {
 		return (ReferenceType) getUnderlyingType();
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.jdt.debug.core.IJavaReferenceType#getDefaultStratum()
 	 */
 	public String getDefaultStratum() throws DebugException {
 		try {
 			return getReferenceType().defaultStratum();
 		} catch (RuntimeException e) {
 			targetRequestFailed(JDIDebugModelMessages.JDIReferenceType_1, e);
 		}
 		// execution will not reach here
 		return null;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see
 	 * org.eclipse.jdt.debug.core.IJavaReferenceType#getField(java.lang.String)
 	 */
 	public IJavaFieldVariable getField(String name) throws DebugException {
 		try {
 			ReferenceType type = (ReferenceType) getUnderlyingType();
 			Field field = type.fieldByName(name);
 			if (field != null && field.isStatic()) {
 				return new JDIFieldVariable(getJavaDebugTarget(), field, type);
 			}
 		} catch (RuntimeException e) {
 			targetRequestFailed(
 					MessageFormat.format(
 							JDIDebugModelMessages.JDIClassType_exception_while_retrieving_field,
 							e.toString(), name), e);
 		}
 		// it is possible to return null
 		return null;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.jdt.debug.core.IJavaReferenceType#getClassObject()
 	 */
 	public IJavaClassObject getClassObject() throws DebugException {
 		try {
 			ReferenceType type = (ReferenceType) getUnderlyingType();
 			return (IJavaClassObject) JDIValue.createValue(
 					getJavaDebugTarget(), type.classObject());
 		} catch (RuntimeException e) {
 			targetRequestFailed(
 					MessageFormat.format(
 							JDIDebugModelMessages.JDIClassType_exception_while_retrieving_class_object,
 							e.toString()), e);
 		}
 		// execution will not fall through to here,
 		// as #requestFailed will throw an exception
 		return null;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.jdt.debug.core.IJavaReferenceType#getAllFieldNames()
 	 */
 	public String[] getAllFieldNames() throws DebugException {
 		if (fAllFields == null) {
 			try {
 				List<Field> fields = ((ReferenceType) getUnderlyingType()).allFields();
 				fAllFields = new String[fields.size()];
 				Iterator<Field> iterator = fields.iterator();
 				int i = 0;
 				while (iterator.hasNext()) {
 					Field field = iterator.next();
 					fAllFields[i] = field.name();
 					i++;
 				}
 			} catch (RuntimeException e) {
 				targetRequestFailed(JDIDebugModelMessages.JDIReferenceType_2, e);
 			}
 		}
 		return fAllFields;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see
 	 * org.eclipse.jdt.debug.core.IJavaReferenceType#getDeclaredFieldNames()
 	 */
 	public String[] getDeclaredFieldNames() throws DebugException {
 		if (fDeclaredFields == null) {
 			try {
 				List<Field> fields = ((ReferenceType) getUnderlyingType()).fields();
 				fDeclaredFields = new String[fields.size()];
 				Iterator<Field> iterator = fields.iterator();
 				int i = 0;
 				while (iterator.hasNext()) {
 					Field field = iterator.next();
 					fDeclaredFields[i] = field.name();
 					i++;
 				}
 			} catch (RuntimeException e) {
 				targetRequestFailed(JDIDebugModelMessages.JDIReferenceType_3, e);
 			}
 		}
 		return fDeclaredFields;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see
 	 * org.eclipse.jdt.debug.core.IJavaReferenceType#getSourcePaths(java.lang
 	 * .String)
 	 */
 	public String[] getSourcePaths(String stratum) throws DebugException {
 		try {
 			List<String> sourcePaths = getReferenceType().sourcePaths(stratum);
 			return sourcePaths
 					.toArray(new String[sourcePaths.size()]);
 		} catch (AbsentInformationException e) {
 		} catch (RuntimeException e) {
 			requestFailed(JDIDebugModelMessages.JDIReferenceType_4, e,
 					DebugException.TARGET_REQUEST_FAILED);
 		}
 		return null;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.jdt.debug.core.IJavaReferenceType#getSourceName()
 	 */
 	public String getSourceName() throws DebugException {
 		try {
 			return getReferenceType().sourceName();
 		} catch (AbsentInformationException e) {
 		} catch (RuntimeException e) {
 			requestFailed(JDIDebugModelMessages.JDIReferenceType_4, e,
 					DebugException.TARGET_REQUEST_FAILED);
 		}
 		return null;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see
 	 * org.eclipse.jdt.debug.core.IJavaReferenceType#getSourceNames(java.lang
 	 * .String)
 	 */
 	public String[] getSourceNames(String stratum) throws DebugException {
 		try {
 			List<String> sourceNames = getReferenceType().sourceNames(stratum);
 			return sourceNames
 					.toArray(new String[sourceNames.size()]);
 		} catch (AbsentInformationException e) {
 		} catch (RuntimeException e) {
 			requestFailed(JDIDebugModelMessages.JDIReferenceType_4, e,
 					DebugException.TARGET_REQUEST_FAILED);
 		}
 		return null;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.jdt.debug.core.IJavaReferenceType#getClassLoaderObject()
 	 */
 	public IJavaObject getClassLoaderObject() throws DebugException {
 		try {
 			ReferenceType type = (ReferenceType) getUnderlyingType();
 			ClassLoaderReference classLoader = type.classLoader();
 			if (classLoader != null) {
 				return (IJavaObject) JDIValue.createValue(getJavaDebugTarget(),
 						classLoader);
 			}
 		} catch (RuntimeException e) {
 			targetRequestFailed(MessageFormat.format(
 					JDIDebugModelMessages.JDIReferenceType_0,
 					e.toString()), e);
 		}
 		return null;
 	}

 	static public String getGenericName(ReferenceType type)
 			throws DebugException {
 		if (type instanceof ArrayType) {
 			try {
 				Type componentType;
 				componentType = ((ArrayType) type).componentType();
 				if (componentType instanceof ReferenceType) {
 					return getGenericName((ReferenceType) componentType) + "[]"; //$NON-NLS-1$
 				}
 				return type.name();
 			} catch (ClassNotLoadedException e) {
 				// we cannot create the generic name using the component type,
 				// just try to create one with the information
 			}
 		}
 		String signature = type.signature();
 		StringBuffer res = new StringBuffer(getTypeName(signature));
 		String genericSignature = type.genericSignature();
 		if (genericSignature != null) {
 			String[] typeParameters = Signature
 					.getTypeParameters(genericSignature);
 			if (typeParameters.length > 0) {
 				res.append('<').append(
 						Signature.getTypeVariable(typeParameters[0]));
 				for (int i = 1; i < typeParameters.length; i++) {
 					res.append(',').append(
 							Signature.getTypeVariable(typeParameters[i]));
 				}
 				res.append('>');
 			}
 		}
 		return res.toString();
 	}

 	/**
 	 * Return the name from the given signature. Keep the '$' characters.
 	 *
 	 * @param genericTypeSignature
 	 *            the signature to derive the type name from
 	 * @return the type name
 	 */
 	public static String getTypeName(String genericTypeSignature) {
 		int arrayDimension = 0;
 		while (genericTypeSignature.charAt(arrayDimension) == '[') {
 			arrayDimension++;
 		}
 		int parameterStart = genericTypeSignature.indexOf('<');
 		StringBuffer name = new StringBuffer();
 		if (parameterStart < 0) {
 			name.append(genericTypeSignature.substring(arrayDimension + 1,
 					genericTypeSignature.length() - 1).replace('/', '.'));
 		} else {
 			if (parameterStart != 0) {
 				name.append(genericTypeSignature.substring(arrayDimension + 1,
 						parameterStart).replace('/', '.'));
 			}
 			try {
 				String sig = Signature.toString(genericTypeSignature)
 						.substring(
 								Math.max(parameterStart - 1, 0)
 										- arrayDimension);
 				name.append(sig.replace('/', '.'));
 			} catch (IllegalArgumentException iae) {
 				// do nothing
 				name.append(genericTypeSignature);
 			}
 		}
 		for (int i = 0; i < arrayDimension; i++) {
 			name.append("[]"); //$NON-NLS-1$
 		}
 		return name.toString();
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.jdt.debug.core.IJavaReferenceType#getGenericSignature()
 	 */
 	public String getGenericSignature() throws DebugException {
 		return getReferenceType().genericSignature();
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.jdt.debug.core.IJavaReferenceType#getInstances(long)
 	 */
 	public IJavaObject[] getInstances(long max) throws DebugException {
 		try {
 			List<ObjectReference> list = getReferenceType().instances(max);
 			IJavaObject[] instances = new IJavaObject[list.size()];
 			for (int i = 0; i < instances.length; i++) {
 				instances[i] = (IJavaObject) JDIValue.createValue(
 						getJavaDebugTarget(), list.get(i));
 			}
 			return instances;
 		} catch (RuntimeException e) {
 			targetRequestFailed(JDIDebugModelMessages.JDIReferenceType_5, e);
 		}
 		return null;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.jdt.debug.core.IJavaReferenceType#getInstanceCount()
 	 */
 	public long getInstanceCount() throws DebugException {
 		JDIDebugTarget target = getJavaDebugTarget();
 		if (target.supportsInstanceRetrieval()) {
 			Type type = getUnderlyingType();
 			if(type instanceof ReferenceType) {
 				ArrayList<ReferenceType> list = new ArrayList<ReferenceType>(2);
 				list.add((ReferenceType) type);
 				VirtualMachine vm = getVM();
 				try {
 					long[] counts = vm.instanceCounts(list);
 					return counts[0];
 				} catch (RuntimeException e) {
 					targetRequestFailed(JDIDebugModelMessages.JDIReferenceType_5, e);
 				}
 			}
 		}
 		return -1;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2011 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jdt.internal.debug.core.model;

	import java.util.ArrayList;
	import java.util.Iterator;
	import java.util.List;

	import org.eclipse.debug.core.DebugException;
	import org.eclipse.jdt.core.Signature;
	import org.eclipse.jdt.debug.core.IJavaClassObject;
	import org.eclipse.jdt.debug.core.IJavaFieldVariable;
	import org.eclipse.jdt.debug.core.IJavaObject;
	import org.eclipse.jdt.debug.core.IJavaReferenceType;

	import com.ibm.icu.text.MessageFormat;
	import com.sun.jdi.AbsentInformationException;
	import com.sun.jdi.ArrayType;
	import com.sun.jdi.ClassLoaderReference;
	import com.sun.jdi.ClassNotLoadedException;
	import com.sun.jdi.Field;
	import com.sun.jdi.ObjectReference;
	import com.sun.jdi.ReferenceType;
	import com.sun.jdi.Type;
	import com.sun.jdi.VirtualMachine;

	/**
	* References a class, interface, or array type.
	*/
	public abstract class JDIReferenceType extends JDIType implements
	IJavaReferenceType {

	// field names declared in this type
	private String[] fDeclaredFields = null;
	// field names declared in this type, super types, implemented interfaces
	// and super-interfaces
	private String[] fAllFields = null;

	/**
	* Constructs a new reference type in the given target.
	*
	* @param target
	* associated VM
	* @param type
	* reference type
	*/
	public JDIReferenceType(JDIDebugTarget target, Type type) {
	super(target, type);
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.jdt.debug.core.IJavaReferenceType#getAvailableStrata()
	*/
	public String[] getAvailableStrata() {
	List<String> strata = getReferenceType().availableStrata();
	return strata.toArray(new String[strata.size()]);
	}

	/**
	* Returns the underlying reference type.
	*
	* @return the underlying reference type
	*/
	protected ReferenceType getReferenceType() {
	return (ReferenceType) getUnderlyingType();
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.jdt.debug.core.IJavaReferenceType#getDefaultStratum()
	*/
	public String getDefaultStratum() throws DebugException {
	try {
	return getReferenceType().defaultStratum();
	} catch (RuntimeException e) {
	targetRequestFailed(JDIDebugModelMessages.JDIReferenceType_1, e);
	}
	// execution will not reach here
	return null;
	}

	/*
	* (non-Javadoc)
	*
	* @see
	* org.eclipse.jdt.debug.core.IJavaReferenceType#getField(java.lang.String)
	*/
	public IJavaFieldVariable getField(String name) throws DebugException {
	try {
	ReferenceType type = (ReferenceType) getUnderlyingType();
	Field field = type.fieldByName(name);
	if (field != null && field.isStatic()) {
	return new JDIFieldVariable(getJavaDebugTarget(), field, type);
	}
	} catch (RuntimeException e) {
	targetRequestFailed(
	MessageFormat.format(
	JDIDebugModelMessages.JDIClassType_exception_while_retrieving_field,
	e.toString(), name), e);
	}
	// it is possible to return null
	return null;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.jdt.debug.core.IJavaReferenceType#getClassObject()
	*/
	public IJavaClassObject getClassObject() throws DebugException {
	try {
	ReferenceType type = (ReferenceType) getUnderlyingType();
	return (IJavaClassObject) JDIValue.createValue(
	getJavaDebugTarget(), type.classObject());
	} catch (RuntimeException e) {
	targetRequestFailed(
	MessageFormat.format(
	JDIDebugModelMessages.JDIClassType_exception_while_retrieving_class_object,
	e.toString()), e);
	}
	// execution will not fall through to here,
	// as #requestFailed will throw an exception
	return null;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.jdt.debug.core.IJavaReferenceType#getAllFieldNames()
	*/
	public String[] getAllFieldNames() throws DebugException {
	if (fAllFields == null) {
	try {
	List<Field> fields = ((ReferenceType) getUnderlyingType()).allFields();
	fAllFields = new String[fields.size()];
	Iterator<Field> iterator = fields.iterator();
	int i = 0;
	while (iterator.hasNext()) {
	Field field = iterator.next();
	fAllFields[i] = field.name();
	i++;
	}
	} catch (RuntimeException e) {
	targetRequestFailed(JDIDebugModelMessages.JDIReferenceType_2, e);
	}
	}
	return fAllFields;
	}

	/*
	* (non-Javadoc)
	*
	* @see
	* org.eclipse.jdt.debug.core.IJavaReferenceType#getDeclaredFieldNames()
	*/
	public String[] getDeclaredFieldNames() throws DebugException {
	if (fDeclaredFields == null) {
	try {
	List<Field> fields = ((ReferenceType) getUnderlyingType()).fields();
	fDeclaredFields = new String[fields.size()];
	Iterator<Field> iterator = fields.iterator();
	int i = 0;
	while (iterator.hasNext()) {
	Field field = iterator.next();
	fDeclaredFields[i] = field.name();
	i++;
	}
	} catch (RuntimeException e) {
	targetRequestFailed(JDIDebugModelMessages.JDIReferenceType_3, e);
	}
	}
	return fDeclaredFields;
	}

	/*
	* (non-Javadoc)
	*
	* @see
	* org.eclipse.jdt.debug.core.IJavaReferenceType#getSourcePaths(java.lang
	* .String)
	*/
	public String[] getSourcePaths(String stratum) throws DebugException {
	try {
	List<String> sourcePaths = getReferenceType().sourcePaths(stratum);
	return sourcePaths
	.toArray(new String[sourcePaths.size()]);
	} catch (AbsentInformationException e) {
	} catch (RuntimeException e) {
	requestFailed(JDIDebugModelMessages.JDIReferenceType_4, e,
	DebugException.TARGET_REQUEST_FAILED);
	}
	return null;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.jdt.debug.core.IJavaReferenceType#getSourceName()
	*/
	public String getSourceName() throws DebugException {
	try {
	return getReferenceType().sourceName();
	} catch (AbsentInformationException e) {
	} catch (RuntimeException e) {
	requestFailed(JDIDebugModelMessages.JDIReferenceType_4, e,
	DebugException.TARGET_REQUEST_FAILED);
	}
	return null;
	}

	/*
	* (non-Javadoc)
	*
	* @see
	* org.eclipse.jdt.debug.core.IJavaReferenceType#getSourceNames(java.lang
	* .String)
	*/
	public String[] getSourceNames(String stratum) throws DebugException {
	try {
	List<String> sourceNames = getReferenceType().sourceNames(stratum);
	return sourceNames
	.toArray(new String[sourceNames.size()]);
	} catch (AbsentInformationException e) {
	} catch (RuntimeException e) {
	requestFailed(JDIDebugModelMessages.JDIReferenceType_4, e,
	DebugException.TARGET_REQUEST_FAILED);
	}
	return null;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.jdt.debug.core.IJavaReferenceType#getClassLoaderObject()
	*/
	public IJavaObject getClassLoaderObject() throws DebugException {
	try {
	ReferenceType type = (ReferenceType) getUnderlyingType();
	ClassLoaderReference classLoader = type.classLoader();
	if (classLoader != null) {
	return (IJavaObject) JDIValue.createValue(getJavaDebugTarget(),
	classLoader);
	}
	} catch (RuntimeException e) {
	targetRequestFailed(MessageFormat.format(
	JDIDebugModelMessages.JDIReferenceType_0,
	e.toString()), e);
	}
	return null;
	}

	static public String getGenericName(ReferenceType type)
	throws DebugException {
	if (type instanceof ArrayType) {
	try {
	Type componentType;
	componentType = ((ArrayType) type).componentType();
	if (componentType instanceof ReferenceType) {
	return getGenericName((ReferenceType) componentType) + "[]"; //$NON-NLS-1$
	}
	return type.name();
	} catch (ClassNotLoadedException e) {
	// we cannot create the generic name using the component type,
	// just try to create one with the information
	}
	}
	String signature = type.signature();
	StringBuffer res = new StringBuffer(getTypeName(signature));
	String genericSignature = type.genericSignature();
	if (genericSignature != null) {
	String[] typeParameters = Signature
	.getTypeParameters(genericSignature);
	if (typeParameters.length > 0) {
	res.append('<').append(
	Signature.getTypeVariable(typeParameters[0]));
	for (int i = 1; i < typeParameters.length; i++) {
	res.append(',').append(
	Signature.getTypeVariable(typeParameters[i]));
	}
	res.append('>');
	}
	}
	return res.toString();
	}

	/**
	* Return the name from the given signature. Keep the '$' characters.
	*
	* @param genericTypeSignature
	* the signature to derive the type name from
	* @return the type name
	*/
	public static String getTypeName(String genericTypeSignature) {
	int arrayDimension = 0;
	while (genericTypeSignature.charAt(arrayDimension) == '[') {
	arrayDimension++;
	}
	int parameterStart = genericTypeSignature.indexOf('<');
	StringBuffer name = new StringBuffer();
	if (parameterStart < 0) {
	name.append(genericTypeSignature.substring(arrayDimension + 1,
	genericTypeSignature.length() - 1).replace('/', '.'));
	} else {
	if (parameterStart != 0) {
	name.append(genericTypeSignature.substring(arrayDimension + 1,
	parameterStart).replace('/', '.'));
	}
	try {
	String sig = Signature.toString(genericTypeSignature)
	.substring(
	Math.max(parameterStart - 1, 0)
	- arrayDimension);
	name.append(sig.replace('/', '.'));
	} catch (IllegalArgumentException iae) {
	// do nothing
	name.append(genericTypeSignature);
	}
	}
	for (int i = 0; i < arrayDimension; i++) {
	name.append("[]"); //$NON-NLS-1$
	}
	return name.toString();
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.jdt.debug.core.IJavaReferenceType#getGenericSignature()
	*/
	public String getGenericSignature() throws DebugException {
	return getReferenceType().genericSignature();
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.jdt.debug.core.IJavaReferenceType#getInstances(long)
	*/
	public IJavaObject[] getInstances(long max) throws DebugException {
	try {
	List<ObjectReference> list = getReferenceType().instances(max);
	IJavaObject[] instances = new IJavaObject[list.size()];
	for (int i = 0; i < instances.length; i++) {
	instances[i] = (IJavaObject) JDIValue.createValue(
	getJavaDebugTarget(), list.get(i));
	}
	return instances;
	} catch (RuntimeException e) {
	targetRequestFailed(JDIDebugModelMessages.JDIReferenceType_5, e);
	}
	return null;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.jdt.debug.core.IJavaReferenceType#getInstanceCount()
	*/
	public long getInstanceCount() throws DebugException {
	JDIDebugTarget target = getJavaDebugTarget();
	if (target.supportsInstanceRetrieval()) {
	Type type = getUnderlyingType();
	if(type instanceof ReferenceType) {
	ArrayList<ReferenceType> list = new ArrayList<ReferenceType>(2);
	list.add((ReferenceType) type);
	VirtualMachine vm = getVM();
	try {
	long[] counts = vm.instanceCounts(list);
	return counts[0];
	} catch (RuntimeException e) {
	targetRequestFailed(JDIDebugModelMessages.JDIReferenceType_5, e);
	}
	}
	}
	return -1;
	}
	}