plugins/org.eclipse.jem.beaninfo/beaninfo/org/eclipse/jem/internal/beaninfo/core/Utilities.java - gerrit/jeetools/webtools.javaee - Git at Google

 /*******************************************************************************
  * Copyright (c) 2003, 2006 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.jem.internal.beaninfo.core;
 /*


  */
 import java.util.Iterator;

 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.ecore.*;
 import org.eclipse.emf.ecore.resource.ResourceSet;

 import org.eclipse.jem.internal.beaninfo.*;
 import org.eclipse.jem.internal.beaninfo.adapters.BeaninfoNature;
 import org.eclipse.jem.internal.beaninfo.adapters.BeaninfoProxyConstants;
 import org.eclipse.jem.internal.java.adapters.ReflectionAdaptor;
 import org.eclipse.jem.internal.proxy.core.*;
 import org.eclipse.jem.java.*;

 /**
  * Beaninfo (introspection) utilities methods
  */

 public final class Utilities {

 	private Utilities() {
 	}

 	/**
 	 * Utility to return the class as a JavaClass. If it actually is a JavaType this will
 	 * fail with a ClassCastException.
 	 * @param className
 	 * @param rset
 	 * @return java class
 	 *
 	 * @throws ClassCastException if not a java class, but instead a java primitive.
 	 * @since 1.1.0
 	 */
 	public static JavaClass getJavaClass(String className, ResourceSet rset) {
 		return (JavaClass) getJavaType(className, rset);
 	}

 	/**
 	 * Utility to return the class as a JavaHelpers.
 	 *
 	 * @param className
 	 * @param rset
 	 * @return java helpers.
 	 *
 	 * @since 1.1.0
 	 */
 	public static JavaHelpers getJavaType(String className, ResourceSet rset) {
 		return (JavaHelpers) rset.getEObject(getJavaClassURI(className), true);
 	}

 	/**
 	 * Create a URI to the given classname.
 	 * <p>
 	 * Note: It must be in normal form, i.e. fully-qualified, if primitive spelled out (e.g. "int" not I), and if
 	 * arrays it must readable form (e.g. "java.lang.String[]" and not "[Ljava.lang.String;").
 	 *
 	 * @param className
 	 * @return
 	 *
 	 * @since 1.1.0
 	 */
 	public static URI getJavaClassURI(String className) {
 		return JavaRefFactory.eINSTANCE.createTypeURI(className);
 	}

 	/**
 	 * Utility to return the EClassifier from the given IBeanTypeProxy.
 	 */
 	public static EClassifier getJavaClass(IBeanTypeProxy type, ResourceSet rset) {
 		if (type != null) {
 			return getJavaType(type.getFormalTypeName(), rset);
 		} else
 			return null;
 	}

 	/**
 	 * Utility to return the Method from the given IMethodProxy.
 	 */
 	public static Method getMethod(IMethodProxy method, ResourceSet rset) {
 		return method != null ? (Method) rset.getEObject(URI.createURI(getMethodURL(method)), true) : null;
 	}

 	/**
 	 * Answer the URL String for Method from the given IMethodProxy
 	 */
 	public static String getMethodURL(IMethodProxy method) {
 		String className = method.getClassType().getTypeName();
 		IBeanTypeProxy[] parms = method.getParameterTypes();
 		String[] parmTypes = parms.length > 0 ? new String[parms.length] : null;
 		for (int i = 0; i < parms.length; i++) {
 			parmTypes[i] = parms[i].getFormalTypeName();
 		}
 		return computeMethodURL(className, method.getName(), parmTypes);
 	}

 	protected static String computeMethodURL(String fullyQualifiedClassName, String methodName, String[] parmTypes) {
 		int classStart = fullyQualifiedClassName.lastIndexOf('.');
 		StringBuffer url = new StringBuffer(50);
 		url.append("java:/"); //$NON-NLS-1$
 		if (classStart > -1)
 			url.append(fullyQualifiedClassName.substring(0, classStart));
 		url.append('#');
 		url.append(computeMethodID(fullyQualifiedClassName.substring(classStart + 1), methodName, parmTypes));
 		return url.toString();
 	}

 	protected static String computeFieldURL(String fullyQualifiedClassName, String fieldName) {
 		int classStart = fullyQualifiedClassName.lastIndexOf('.');
 		StringBuffer url = new StringBuffer(50);
 		url.append("java:/"); //$NON-NLS-1$
 		if (classStart > -1)
 			url.append(fullyQualifiedClassName.substring(0, classStart));
 		url.append('#');
 		url.append(fullyQualifiedClassName.substring(classStart + 1));
 		url.append(ReflectionAdaptor.C_CLASS_MEMBER_DELIMITER);
 		url.append(fieldName);
 		return url.toString();
 	}

 	/**
 	 * Return the field uri for the given classname, fieldname.
 	 * @param fullyQualifiedClassName
 	 * @param fieldName
 	 * @return
 	 *
 	 * @since 1.1.0
 	 */
 	public static URI getFieldURI(String fullyQualifiedClassName, String fieldName) {
 		return URI.createURI(computeFieldURL(fullyQualifiedClassName, fieldName));
 	}
 	/**
 	 * Return the method uri for the given classname, methodname, parm types.
 	 * @param fullyQualifiedClassName
 	 * @param methodName
 	 * @param parmTypes <code>null</code> if there are no parms.
 	 * @return
 	 *
 	 * @since 1.1.0
 	 */
 	public static URI getMethodURI(String fullyQualifiedClassName, String methodName, String[] parmTypes) {
 		return URI.createURI(computeMethodURL(fullyQualifiedClassName, methodName, parmTypes));
 	}

 	/**
 	 * Turn it into an URI.
 	 */
 	public static URI getMethodURI(IMethodProxy method) {
 		return URI.createURI(getMethodURL(method));
 	}

 	/**
 	 * Utility to compute the Java Modeling METHODID from method declaring class name,
 	 * method name, and parameter class names.
 	 */
 	public static String computeMethodID(String className, String methodName, String[] parameterTypes) {
 		StringBuffer out = new StringBuffer(50);
 		out.append(className);
 		out.append(ReflectionAdaptor.C_CLASS_MEMBER_DELIMITER);
 		out.append(methodName);
 		out.append(ReflectionAdaptor.C_METHOD_PARM_DELIMITER);
 		if (parameterTypes != null)
 			for (int i = 0; i < parameterTypes.length; i++) {
 				out.append(parameterTypes[i]);
 				if (i < parameterTypes.length - 1)
 					out.append(ReflectionAdaptor.C_PARM_PARM_DELIMITER);
 			}
 		if (className.equals(methodName))
 			out.append(ReflectionAdaptor.S_CONSTRUCTOR_TOKEN); //It's a constructor
 		return out.toString();
 	}

 	/**
 	 * Utility to retrieve the BeanDecorator.
 	 */
 	public static BeanDecorator getBeanDecorator(EModelElement model) {
 		return (BeanDecorator) getDecorator(model, BeanDecorator.class);
 	}
 	/**
 	 * Utility to retrieve a decorator of the specified class.
 	 */
 	public static EAnnotation getDecorator(EModelElement model, Class decoratorClass) {
 		Iterator itr = model.getEAnnotations().iterator();
 		while (itr.hasNext()) {
 			EAnnotation decr = (EAnnotation) itr.next();
 			if (decoratorClass.isInstance(decr))
 				return decr;
 		}
 		return null;
 	}

 	/**
 	 * Utility to retrieve the EventSetDecorator.
 	 */
 	public static EventSetDecorator getEventSetDecorator(EModelElement model) {
 		return (EventSetDecorator) getDecorator(model, EventSetDecorator.class);
 	}

 	/**
 	 * Utility to retrieve the MethodDecorator.
 	 */
 	public static MethodDecorator getMethodDecorator(EModelElement model) {
 		return (MethodDecorator) getDecorator(model, MethodDecorator.class);
 	}

 	/**
 	 * Utility to retrieve the PropertyDecorator.
 	 */
 	public static PropertyDecorator getPropertyDecorator(EModelElement model) {
 		return (PropertyDecorator) getDecorator(model, PropertyDecorator.class);
 	}

 	/**
 	 * Utility to return an iterator on the list which will return the property decorators
 	 * of only the properties in the EList passed in. If the property does not have a
 	 * property decorator, then it is not a beaninfo property.
 	 */
 	public static Iterator getPropertiesIterator(final EList properties) {
 		return new Iterator() {
 			private Iterator itr = properties.iterator();
 			private boolean hasNext = true;
 			private PropertyDecorator next;
 			{
 				findNext();
 			}
 			public boolean hasNext() {
 				return hasNext;
 			}

 			public Object next() {
 				PropertyDecorator temp = next;
 				findNext();
 				return temp;
 			}

 			public void remove() {
 				throw new UnsupportedOperationException();
 			}

 			private void findNext() {
 				while (itr.hasNext()) {
 					EModelElement nextOne = (EModelElement) itr.next();
 					next = getPropertyDecorator(nextOne);
 					if (next != null) {
 						return;
 					}
 				}
 				hasNext = false;
 			}
 		};
 	}

 	/**
 	 * Utility to return an iterator on the list which will return the EventSet decorators
 	 * of only the BeanEvents in the EList passed in.
 	 */
 	public static Iterator getEventSetsIterator(final EList events) {
 		return new Iterator() {
 			private Iterator itr = events.iterator();
 			private boolean hasNext = true;
 			private EventSetDecorator next;
 			{
 				findNext();
 			}
 			public boolean hasNext() {
 				return hasNext;
 			}

 			public Object next() {
 				EventSetDecorator temp = next;
 				findNext();
 				return temp;
 			}

 			public void remove() {
 				throw new UnsupportedOperationException();
 			}

 			private void findNext() {
 				while (itr.hasNext()) {
 					EModelElement nextOne = (EModelElement) itr.next();
 					next = getEventSetDecorator(nextOne);
 					if (next != null) {
 						return;
 					}
 				}
 				hasNext = false;
 			}
 		};
 	}

 	/**
 	 * Utility to return an iterator on the list which will return the Method decorators
 	 * of only the Methods in the EList passed in.
 	 */
 	public static Iterator getMethodsIterator(final EList methods) {
 		return new Iterator() {
 			private Iterator itr = methods.iterator();
 			private boolean hasNext = true;
 			private MethodDecorator next;
 			{
 				findNext();
 			}
 			public boolean hasNext() {
 				return hasNext;
 			}

 			public Object next() {
 				MethodDecorator temp = next;
 				findNext();
 				return temp;
 			}

 			public void remove() {
 				throw new UnsupportedOperationException();
 			}

 			private void findNext() {
 				while (itr.hasNext()) {
 					EModelElement nextOne = (EModelElement) itr.next();
 					next = getMethodDecorator(nextOne);
 					if (next != null) {
 						return;
 					}
 				}
 				hasNext = false;
 			}
 		};
 	}

 	/**
 	 * Get the search path from the remote vm.
 	 *
 	 * Note: This shouldn't be used when working with a BeaninfoNature. Use the
 	 * accessors taking the nature  instead. Otherwise there will be inconsistencies since the search path won't be
 	 * saved across invocations of the workspace if it is not updated through the nature).
 	 */
 	public static IArrayBeanProxy getBeanInfoSearchPath(ProxyFactoryRegistry registry) {
 		BeaninfoProxyConstants biconstants = BeaninfoProxyConstants.getConstants(registry);
 		if (biconstants != null)
 			return (IArrayBeanProxy) biconstants
 				.getGetBeanInfoSearchPathProxy()
 				.invokeCatchThrowableExceptions(
 				null);
 		else
 			return null;
 	}

 	/**
 	 * Set the search path to the array of strings passed in on the remote vm.
 	 *
 	 * Note: This shouldn't be used when working with a BeaninfoNature. Use the
 	 * accessors taking the nature  instead. Otherwise there will be inconsistencies since the search path won't be
 	 * saved across invocations of the workspace if it is not updated through the nature).
 	 */
 	public static void setBeanInfoSearchPath(ProxyFactoryRegistry registry, String[] paths) {

 		try {
 			BeaninfoProxyConstants biConstants = BeaninfoProxyConstants.getConstants(registry);
 			if (biConstants != null) {
 				JavaStandardBeanProxyConstants jConstants = JavaStandardBeanProxyConstants.getConstants(registry);
 				IStandardBeanProxyFactory proxyFactory = registry.getBeanProxyFactory();
 				IArrayBeanProxy newPath = proxyFactory.createBeanProxyWith(jConstants.getStringType(), paths != null ? paths.length : 0);
 				if (paths != null)
 					for (int i = 0; i < paths.length; i++)
 						newPath.set(proxyFactory.createBeanProxyWith(paths[i]), i);
 				biConstants.getSetBeanInfoSearchPathProxy().invoke(null, newPath);
 			}
 		} catch (ThrowableProxy e) {
 		}
 	}

 	/**
 	 * From the Beaninfo Nature, insert a path to the beaninfo path at the given index, -1 means at the end.
 	 * If index is larger than the current path, it will also add at the end.
 	 */
 	public static void insertBeanInfoSearchPath(BeaninfoNature nature, IBeaninfosDocEntry path, int index) throws CoreException {
 		BeaninfosDoc infoPath = nature.getSearchPath();
 		IBeaninfosDocEntry[] oldPath = infoPath.getSearchpath();

 		IBeaninfosDocEntry[] newPath = new IBeaninfosDocEntry[oldPath.length + 1];

 		if (index == -1 || index >= oldPath.length) {
 			// At the end or past end
 			System.arraycopy(oldPath, 0, newPath, 0, oldPath.length);
 			newPath[oldPath.length] = path;
 		} else {
 			// In the middle
 			System.arraycopy(oldPath, 0, newPath, 0, index);
 			newPath[index] = path;
 			System.arraycopy(oldPath, index, newPath, index + 1, oldPath.length - index);
 		}

 		infoPath.setSearchpath(newPath);
 		nature.setSearchPath(infoPath);
 	}

 	/**
 	 * Insert a path to the beaninfo path at the given index, -1 means at the end.
 	 * If index is larger than the current path, it will also add at the end.
 	 *
 	 * Note: This shouldn't be used when working with a BeaninfoNature. Use the
 	 * accessors taking the nature  instead. Otherwise there will be inconsistencies since the search path won't be
 	 * saved across invocations of the workspace if it is not updated through the nature).
 	 */
 	public static void insertBeanInfoSearchPath(ProxyFactoryRegistry registry, String path, int index) {
 		try {
 			BeaninfoProxyConstants biConstants = BeaninfoProxyConstants.getConstants(registry);
 			if (biConstants != null) {
 				IArrayBeanProxy infoPath = (IArrayBeanProxy) biConstants.getGetBeanInfoSearchPathProxy().invoke(null);
 				int pathLength = infoPath.getLength();
 				IStandardBeanProxyFactory proxyFactory = registry.getBeanProxyFactory();
 				IArrayBeanProxy newPath = proxyFactory.createBeanProxyWith(infoPath.getTypeProxy(), pathLength + 1);
 				IBeanProxy stringProxy = proxyFactory.createBeanProxyWith(path);
 				JavaStandardBeanProxyConstants constants = JavaStandardBeanProxyConstants.getConstants(registry);
 				if (index == -1 || index >= pathLength) {
 					// At the end or past end
 					constants.arraycopy(infoPath, 0, newPath, 0, infoPath.getLength());
 					newPath.set(stringProxy, pathLength);
 				} else {
 					// In the middle
 					constants.arraycopy(infoPath, 0, newPath, 0, index);
 					newPath.set(stringProxy, index);
 					constants.arraycopy(infoPath, index, newPath, index + 1, pathLength - index);
 				}
 				biConstants.getSetBeanInfoSearchPathProxy().invoke(null, newPath);
 			}
 		} catch (ThrowableProxy e) {
 		}
 	}

 	/**
 	 * From the Beaninfo Nature, remove the specified path from the beaninfo search path.
 	 * Not an error if not found.
 	 */
 	public static void removeBeanInfoPath(BeaninfoNature nature, IBeaninfosDocEntry path) throws CoreException {
 		BeaninfosDoc infoPath = nature.getSearchPath();
 		IBeaninfosDocEntry[] oldPath = infoPath.getSearchpath();

 		for (int i = 0; i < oldPath.length; i++) {
 			if (path.equals(oldPath[i])) {
 				// We found it, so remove it.
 				IBeaninfosDocEntry[] newPath = new IBeaninfosDocEntry[oldPath.length - 1];
 				System.arraycopy(oldPath, 0, newPath, 0, i);
 				if (i < oldPath.length - 1)
 					System.arraycopy(oldPath, i + 1, newPath, i, oldPath.length - i - 1);
 				infoPath.setSearchpath(newPath);
 				nature.setSearchPath(infoPath);
 				return;
 			}
 		}
 	}

 	/**
 	 * Remove the specified path from the beaninfo search path.
 	 * Not an error if not found.
 	 *
 	 * Note: This shouldn't be used when working with a BeaninfoNature. Use the
 	 * accessors taking the nature  instead. Otherwise there will be inconsistencies since the search path won't be
 	 * saved across invocations of the workspace if it is not updated through the nature).
 	 */
 	public static void removeBeanInfoPath(ProxyFactoryRegistry registry, String path) {
 		try {
 			BeaninfoProxyConstants biConstants = BeaninfoProxyConstants.getConstants(registry);
 			if (biConstants != null) {
 				IArrayBeanProxy infoPath = (IArrayBeanProxy) biConstants.getGetBeanInfoSearchPathProxy().invoke(null);
 				int pathLength = infoPath.getLength();
 				for (int i = 0; i < pathLength; i++) {
 					IStringBeanProxy aPath = (IStringBeanProxy) infoPath.get(i);
 					if (path.equals(aPath.stringValue())) {
 						// We found it, so remove it.
 						IArrayBeanProxy newPath = registry.getBeanProxyFactory().createBeanProxyWith(infoPath.getTypeProxy(), pathLength - 1);
 						JavaStandardBeanProxyConstants constants = JavaStandardBeanProxyConstants.getConstants(registry);
 						constants.arraycopy(infoPath, 0, newPath, 0, i);
 						if (i < pathLength - 1)
 							constants.arraycopy(infoPath, i + 1, newPath, i, pathLength - i - 1);
 						biConstants.getSetBeanInfoSearchPathProxy().invoke(null, newPath);
 						return;
 					}
 				}
 			}
 		} catch (ThrowableProxy e) {
 		}
 	};

 }
	/*******************************************************************************
	* Copyright (c) 2003, 2006 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.jem.internal.beaninfo.core;
	/*


	*/
	import java.util.Iterator;

	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.emf.common.util.EList;
	import org.eclipse.emf.common.util.URI;
	import org.eclipse.emf.ecore.*;
	import org.eclipse.emf.ecore.resource.ResourceSet;

	import org.eclipse.jem.internal.beaninfo.*;
	import org.eclipse.jem.internal.beaninfo.adapters.BeaninfoNature;
	import org.eclipse.jem.internal.beaninfo.adapters.BeaninfoProxyConstants;
	import org.eclipse.jem.internal.java.adapters.ReflectionAdaptor;
	import org.eclipse.jem.internal.proxy.core.*;
	import org.eclipse.jem.java.*;

	/**
	* Beaninfo (introspection) utilities methods
	*/

	public final class Utilities {

	private Utilities() {
	}

	/**
	* Utility to return the class as a JavaClass. If it actually is a JavaType this will
	* fail with a ClassCastException.
	* @param className
	* @param rset
	* @return java class
	*
	* @throws ClassCastException if not a java class, but instead a java primitive.
	* @since 1.1.0
	*/
	public static JavaClass getJavaClass(String className, ResourceSet rset) {
	return (JavaClass) getJavaType(className, rset);
	}

	/**
	* Utility to return the class as a JavaHelpers.
	*
	* @param className
	* @param rset
	* @return java helpers.
	*
	* @since 1.1.0
	*/
	public static JavaHelpers getJavaType(String className, ResourceSet rset) {
	return (JavaHelpers) rset.getEObject(getJavaClassURI(className), true);
	}

	/**
	* Create a URI to the given classname.
	* <p>
	* Note: It must be in normal form, i.e. fully-qualified, if primitive spelled out (e.g. "int" not I), and if
	* arrays it must readable form (e.g. "java.lang.String[]" and not "[Ljava.lang.String;").
	*
	* @param className
	* @return
	*
	* @since 1.1.0
	*/
	public static URI getJavaClassURI(String className) {
	return JavaRefFactory.eINSTANCE.createTypeURI(className);
	}

	/**
	* Utility to return the EClassifier from the given IBeanTypeProxy.
	*/
	public static EClassifier getJavaClass(IBeanTypeProxy type, ResourceSet rset) {
	if (type != null) {
	return getJavaType(type.getFormalTypeName(), rset);
	} else
	return null;
	}

	/**
	* Utility to return the Method from the given IMethodProxy.
	*/
	public static Method getMethod(IMethodProxy method, ResourceSet rset) {
	return method != null ? (Method) rset.getEObject(URI.createURI(getMethodURL(method)), true) : null;
	}

	/**
	* Answer the URL String for Method from the given IMethodProxy
	*/
	public static String getMethodURL(IMethodProxy method) {
	String className = method.getClassType().getTypeName();
	IBeanTypeProxy[] parms = method.getParameterTypes();
	String[] parmTypes = parms.length > 0 ? new String[parms.length] : null;
	for (int i = 0; i < parms.length; i++) {
	parmTypes[i] = parms[i].getFormalTypeName();
	}
	return computeMethodURL(className, method.getName(), parmTypes);
	}

	protected static String computeMethodURL(String fullyQualifiedClassName, String methodName, String[] parmTypes) {
	int classStart = fullyQualifiedClassName.lastIndexOf('.');
	StringBuffer url = new StringBuffer(50);
	url.append("java:/"); //$NON-NLS-1$
	if (classStart > -1)
	url.append(fullyQualifiedClassName.substring(0, classStart));
	url.append('#');
	url.append(computeMethodID(fullyQualifiedClassName.substring(classStart + 1), methodName, parmTypes));
	return url.toString();
	}

	protected static String computeFieldURL(String fullyQualifiedClassName, String fieldName) {
	int classStart = fullyQualifiedClassName.lastIndexOf('.');
	StringBuffer url = new StringBuffer(50);
	url.append("java:/"); //$NON-NLS-1$
	if (classStart > -1)
	url.append(fullyQualifiedClassName.substring(0, classStart));
	url.append('#');
	url.append(fullyQualifiedClassName.substring(classStart + 1));
	url.append(ReflectionAdaptor.C_CLASS_MEMBER_DELIMITER);
	url.append(fieldName);
	return url.toString();
	}

	/**
	* Return the field uri for the given classname, fieldname.
	* @param fullyQualifiedClassName
	* @param fieldName
	* @return
	*
	* @since 1.1.0
	*/
	public static URI getFieldURI(String fullyQualifiedClassName, String fieldName) {
	return URI.createURI(computeFieldURL(fullyQualifiedClassName, fieldName));
	}
	/**
	* Return the method uri for the given classname, methodname, parm types.
	* @param fullyQualifiedClassName
	* @param methodName
	* @param parmTypes <code>null</code> if there are no parms.
	* @return
	*
	* @since 1.1.0
	*/
	public static URI getMethodURI(String fullyQualifiedClassName, String methodName, String[] parmTypes) {
	return URI.createURI(computeMethodURL(fullyQualifiedClassName, methodName, parmTypes));
	}

	/**
	* Turn it into an URI.
	*/
	public static URI getMethodURI(IMethodProxy method) {
	return URI.createURI(getMethodURL(method));
	}

	/**
	* Utility to compute the Java Modeling METHODID from method declaring class name,
	* method name, and parameter class names.
	*/
	public static String computeMethodID(String className, String methodName, String[] parameterTypes) {
	StringBuffer out = new StringBuffer(50);
	out.append(className);
	out.append(ReflectionAdaptor.C_CLASS_MEMBER_DELIMITER);
	out.append(methodName);
	out.append(ReflectionAdaptor.C_METHOD_PARM_DELIMITER);
	if (parameterTypes != null)
	for (int i = 0; i < parameterTypes.length; i++) {
	out.append(parameterTypes[i]);
	if (i < parameterTypes.length - 1)
	out.append(ReflectionAdaptor.C_PARM_PARM_DELIMITER);
	}
	if (className.equals(methodName))
	out.append(ReflectionAdaptor.S_CONSTRUCTOR_TOKEN); //It's a constructor
	return out.toString();
	}

	/**
	* Utility to retrieve the BeanDecorator.
	*/
	public static BeanDecorator getBeanDecorator(EModelElement model) {
	return (BeanDecorator) getDecorator(model, BeanDecorator.class);
	}
	/**
	* Utility to retrieve a decorator of the specified class.
	*/
	public static EAnnotation getDecorator(EModelElement model, Class decoratorClass) {
	Iterator itr = model.getEAnnotations().iterator();
	while (itr.hasNext()) {
	EAnnotation decr = (EAnnotation) itr.next();
	if (decoratorClass.isInstance(decr))
	return decr;
	}
	return null;
	}

	/**
	* Utility to retrieve the EventSetDecorator.
	*/
	public static EventSetDecorator getEventSetDecorator(EModelElement model) {
	return (EventSetDecorator) getDecorator(model, EventSetDecorator.class);
	}

	/**
	* Utility to retrieve the MethodDecorator.
	*/
	public static MethodDecorator getMethodDecorator(EModelElement model) {
	return (MethodDecorator) getDecorator(model, MethodDecorator.class);
	}

	/**
	* Utility to retrieve the PropertyDecorator.
	*/
	public static PropertyDecorator getPropertyDecorator(EModelElement model) {
	return (PropertyDecorator) getDecorator(model, PropertyDecorator.class);
	}

	/**
	* Utility to return an iterator on the list which will return the property decorators
	* of only the properties in the EList passed in. If the property does not have a
	* property decorator, then it is not a beaninfo property.
	*/
	public static Iterator getPropertiesIterator(final EList properties) {
	return new Iterator() {
	private Iterator itr = properties.iterator();
	private boolean hasNext = true;
	private PropertyDecorator next;
	{
	findNext();
	}
	public boolean hasNext() {
	return hasNext;
	}

	public Object next() {
	PropertyDecorator temp = next;
	findNext();
	return temp;
	}

	public void remove() {
	throw new UnsupportedOperationException();
	}

	private void findNext() {
	while (itr.hasNext()) {
	EModelElement nextOne = (EModelElement) itr.next();
	next = getPropertyDecorator(nextOne);
	if (next != null) {
	return;
	}
	}
	hasNext = false;
	}
	};
	}

	/**
	* Utility to return an iterator on the list which will return the EventSet decorators
	* of only the BeanEvents in the EList passed in.
	*/
	public static Iterator getEventSetsIterator(final EList events) {
	return new Iterator() {
	private Iterator itr = events.iterator();
	private boolean hasNext = true;
	private EventSetDecorator next;
	{
	findNext();
	}
	public boolean hasNext() {
	return hasNext;
	}

	public Object next() {
	EventSetDecorator temp = next;
	findNext();
	return temp;
	}

	public void remove() {
	throw new UnsupportedOperationException();
	}

	private void findNext() {
	while (itr.hasNext()) {
	EModelElement nextOne = (EModelElement) itr.next();
	next = getEventSetDecorator(nextOne);
	if (next != null) {
	return;
	}
	}
	hasNext = false;
	}
	};
	}

	/**
	* Utility to return an iterator on the list which will return the Method decorators
	* of only the Methods in the EList passed in.
	*/
	public static Iterator getMethodsIterator(final EList methods) {
	return new Iterator() {
	private Iterator itr = methods.iterator();
	private boolean hasNext = true;
	private MethodDecorator next;
	{
	findNext();
	}
	public boolean hasNext() {
	return hasNext;
	}

	public Object next() {
	MethodDecorator temp = next;
	findNext();
	return temp;
	}

	public void remove() {
	throw new UnsupportedOperationException();
	}

	private void findNext() {
	while (itr.hasNext()) {
	EModelElement nextOne = (EModelElement) itr.next();
	next = getMethodDecorator(nextOne);
	if (next != null) {
	return;
	}
	}
	hasNext = false;
	}
	};
	}

	/**
	* Get the search path from the remote vm.
	*
	* Note: This shouldn't be used when working with a BeaninfoNature. Use the
	* accessors taking the nature instead. Otherwise there will be inconsistencies since the search path won't be
	* saved across invocations of the workspace if it is not updated through the nature).
	*/
	public static IArrayBeanProxy getBeanInfoSearchPath(ProxyFactoryRegistry registry) {
	BeaninfoProxyConstants biconstants = BeaninfoProxyConstants.getConstants(registry);
	if (biconstants != null)
	return (IArrayBeanProxy) biconstants
	.getGetBeanInfoSearchPathProxy()
	.invokeCatchThrowableExceptions(
	null);
	else
	return null;
	}

	/**
	* Set the search path to the array of strings passed in on the remote vm.
	*
	* Note: This shouldn't be used when working with a BeaninfoNature. Use the
	* accessors taking the nature instead. Otherwise there will be inconsistencies since the search path won't be
	* saved across invocations of the workspace if it is not updated through the nature).
	*/
	public static void setBeanInfoSearchPath(ProxyFactoryRegistry registry, String[] paths) {

	try {
	BeaninfoProxyConstants biConstants = BeaninfoProxyConstants.getConstants(registry);
	if (biConstants != null) {
	JavaStandardBeanProxyConstants jConstants = JavaStandardBeanProxyConstants.getConstants(registry);
	IStandardBeanProxyFactory proxyFactory = registry.getBeanProxyFactory();
	IArrayBeanProxy newPath = proxyFactory.createBeanProxyWith(jConstants.getStringType(), paths != null ? paths.length : 0);
	if (paths != null)
	for (int i = 0; i < paths.length; i++)
	newPath.set(proxyFactory.createBeanProxyWith(paths[i]), i);
	biConstants.getSetBeanInfoSearchPathProxy().invoke(null, newPath);
	}
	} catch (ThrowableProxy e) {
	}
	}

	/**
	* From the Beaninfo Nature, insert a path to the beaninfo path at the given index, -1 means at the end.
	* If index is larger than the current path, it will also add at the end.
	*/
	public static void insertBeanInfoSearchPath(BeaninfoNature nature, IBeaninfosDocEntry path, int index) throws CoreException {
	BeaninfosDoc infoPath = nature.getSearchPath();
	IBeaninfosDocEntry[] oldPath = infoPath.getSearchpath();

	IBeaninfosDocEntry[] newPath = new IBeaninfosDocEntry[oldPath.length + 1];

	if (index == -1 \|\| index >= oldPath.length) {
	// At the end or past end
	System.arraycopy(oldPath, 0, newPath, 0, oldPath.length);
	newPath[oldPath.length] = path;
	} else {
	// In the middle
	System.arraycopy(oldPath, 0, newPath, 0, index);
	newPath[index] = path;
	System.arraycopy(oldPath, index, newPath, index + 1, oldPath.length - index);
	}

	infoPath.setSearchpath(newPath);
	nature.setSearchPath(infoPath);
	}

	/**
	* Insert a path to the beaninfo path at the given index, -1 means at the end.
	* If index is larger than the current path, it will also add at the end.
	*
	* Note: This shouldn't be used when working with a BeaninfoNature. Use the
	* accessors taking the nature instead. Otherwise there will be inconsistencies since the search path won't be
	* saved across invocations of the workspace if it is not updated through the nature).
	*/
	public static void insertBeanInfoSearchPath(ProxyFactoryRegistry registry, String path, int index) {
	try {
	BeaninfoProxyConstants biConstants = BeaninfoProxyConstants.getConstants(registry);
	if (biConstants != null) {
	IArrayBeanProxy infoPath = (IArrayBeanProxy) biConstants.getGetBeanInfoSearchPathProxy().invoke(null);
	int pathLength = infoPath.getLength();
	IStandardBeanProxyFactory proxyFactory = registry.getBeanProxyFactory();
	IArrayBeanProxy newPath = proxyFactory.createBeanProxyWith(infoPath.getTypeProxy(), pathLength + 1);
	IBeanProxy stringProxy = proxyFactory.createBeanProxyWith(path);
	JavaStandardBeanProxyConstants constants = JavaStandardBeanProxyConstants.getConstants(registry);
	if (index == -1 \|\| index >= pathLength) {
	// At the end or past end
	constants.arraycopy(infoPath, 0, newPath, 0, infoPath.getLength());
	newPath.set(stringProxy, pathLength);
	} else {
	// In the middle
	constants.arraycopy(infoPath, 0, newPath, 0, index);
	newPath.set(stringProxy, index);
	constants.arraycopy(infoPath, index, newPath, index + 1, pathLength - index);
	}
	biConstants.getSetBeanInfoSearchPathProxy().invoke(null, newPath);
	}
	} catch (ThrowableProxy e) {
	}
	}

	/**
	* From the Beaninfo Nature, remove the specified path from the beaninfo search path.
	* Not an error if not found.
	*/
	public static void removeBeanInfoPath(BeaninfoNature nature, IBeaninfosDocEntry path) throws CoreException {
	BeaninfosDoc infoPath = nature.getSearchPath();
	IBeaninfosDocEntry[] oldPath = infoPath.getSearchpath();

	for (int i = 0; i < oldPath.length; i++) {
	if (path.equals(oldPath[i])) {
	// We found it, so remove it.
	IBeaninfosDocEntry[] newPath = new IBeaninfosDocEntry[oldPath.length - 1];
	System.arraycopy(oldPath, 0, newPath, 0, i);
	if (i < oldPath.length - 1)
	System.arraycopy(oldPath, i + 1, newPath, i, oldPath.length - i - 1);
	infoPath.setSearchpath(newPath);
	nature.setSearchPath(infoPath);
	return;
	}
	}
	}

	/**
	* Remove the specified path from the beaninfo search path.
	* Not an error if not found.
	*
	* Note: This shouldn't be used when working with a BeaninfoNature. Use the
	* accessors taking the nature instead. Otherwise there will be inconsistencies since the search path won't be
	* saved across invocations of the workspace if it is not updated through the nature).
	*/
	public static void removeBeanInfoPath(ProxyFactoryRegistry registry, String path) {
	try {
	BeaninfoProxyConstants biConstants = BeaninfoProxyConstants.getConstants(registry);
	if (biConstants != null) {
	IArrayBeanProxy infoPath = (IArrayBeanProxy) biConstants.getGetBeanInfoSearchPathProxy().invoke(null);
	int pathLength = infoPath.getLength();
	for (int i = 0; i < pathLength; i++) {
	IStringBeanProxy aPath = (IStringBeanProxy) infoPath.get(i);
	if (path.equals(aPath.stringValue())) {
	// We found it, so remove it.
	IArrayBeanProxy newPath = registry.getBeanProxyFactory().createBeanProxyWith(infoPath.getTypeProxy(), pathLength - 1);
	JavaStandardBeanProxyConstants constants = JavaStandardBeanProxyConstants.getConstants(registry);
	constants.arraycopy(infoPath, 0, newPath, 0, i);
	if (i < pathLength - 1)
	constants.arraycopy(infoPath, i + 1, newPath, i, pathLength - i - 1);
	biConstants.getSetBeanInfoSearchPathProxy().invoke(null, newPath);
	return;
	}
	}
	}
	} catch (ThrowableProxy e) {
	}
	};

	}