*    IBM Corporation - initial API and implementation 

 *    IBM Corporation - initial API and implementation

 * 

 *

 * @author melaasar, mmostafa

 * @author melaasar, mmostafa, keithc

	 * A map to store previously successful class lookups.

	 * A map to cache known information about class relationships. The first

	 */

	 * level key is keyed by a Class and yields a second-level map. The

	private static Map isAssignableTable = new HashMap();

	 * second-level map is keyed by a class name. The leaf values are Boolean

	 * objects whose values signify whether the Class is assignable to the named

	/** 

	 * class.

	 * A map to store previously failed class lookups.

	 */

	private static Map isNotAssignableTable = new HashMap();

	/**

	 * a map of classes that get asked for methods they do not contain, by

	 * the provider, the map is a class to a Set of method signatures

	 */

	private static ClassToMethodSignaturesSetMap passiveClasses = 

		new ClassToMethodSignaturesSetMap();

	/**

	 * a class to cach passive classes, passive classes are the classes we asked 

	 * for a method with a specific signature and they faild to find it. The cach used 

	 * so in the next time we can tell if the method does not exists oin the class

	 * without calling getMethod by reflection, which improves the performance

	 * @author mmostafa

	 *

	 */

	private static class ClassToMethodSignaturesSetMap{

		/**

		 * internal map for the cach, it is a map of Class to Set of method signature Strings

		 */

		Map classToMethodSignaturesSetMap = new HashMap();

		/**

		 * adds a class and a method signature to the passive class cach

		 * @param clazz		the class

		 * @param signature	the method signature

		 */

		public void addMethod(Class clazz, String signature){

			Set signatures = (Set)classToMethodSignaturesSetMap.get(clazz);

			if (signatures==null){

				signatures = new HashSet();

				classToMethodSignaturesSetMap.put(clazz,signatures);

			}

			signatures.add(signature);

		}

		/**

		 * check if the class and the method signatrue are contained in the apssive collection,

		 * which means we do  need need to call get method oon the class becuase we will not 

		 * find it, this helps improving the performance.

		 * @param clazz

		 * @param signature

		 * @return

		 */

		public boolean contains(Class clazz, String signature){

			Set signatures = (Set)classToMethodSignaturesSetMap.get(clazz);

			if (signatures==null)

				return false;

			return signatures.contains(signature);

		}

	}

	/**

	 * internal class used to cach Methods, so we do not call getMethod too often 

	 * @author mmostafa

	private static class ClassToMethodSignatureToMethodCach{

	private static final Map assignableMap = new WeakHashMap();

		/**

		 * internal map to hold the cached data, it is a map of Class => Map

		 * of Singature string => method

		 */

		Map classToMethodSignatureToMethod = new HashMap();

		/**

		 * adds a <code>Method</code> to the cach

		 * @param clazz		the class we got the method from 

		 * @param methodSignature	the method signature

		 * @param method	the <code>Method</code>

		 */

		public void addMethod(Class clazz,String methodSignature, Method method ){

			Map signatureToMethodMap = (Map)classToMethodSignatureToMethod.get(clazz);

			if (signatureToMethodMap==null){

				signatureToMethodMap = new HashMap();

				classToMethodSignatureToMethod.put(clazz,signatureToMethodMap);

			}

			signatureToMethodMap.put(methodSignature,method);

		}

		/**

		 * gets a method from the cach using the class that owns it and the method 

		 * signature.

		 * @param clazz		the class that owns the method

		 * @param methodSignature	the method signature

		 * @return	the <code>Method</code> if found any, otherwise null

		 */

		public Method getMethod(Class clazz,String methodSignature){

			Map signatureToMethodMap  = (Map)classToMethodSignatureToMethod.get(clazz);

			if (signatureToMethodMap !=null){

				return (Method)signatureToMethodMap.get(methodSignature);

			}

			return null;

		}

	}

	/**

	 * map for class to Method signature to method cach

	 */

	private static ClassToMethodSignatureToMethodCach

		classToMethodSignatureToMethodCach = new ClassToMethodSignatureToMethodCach();

	/**

	 * Gets the class name of <code>object</code>.

	 * @param object the object for which the class name is to be found.

	 * @return the class name

	 */

	static String getClassName( Object object ) {

	    String cn = object.getClass().getName();

	    return cn.substring( cn.lastIndexOf('.')+1);

	}

		/** 

		private static final MethodValueEntry[] NO_METHODS = new MethodValueEntry[0];

		private static boolean allMatch(MethodValueEntry[] methods, Object object) {

			for (int i = 0, n = methods.length; i < n; ++i)

				if (methods[i].matches(object) == false)

					return false;

			return true;

		}

		/**

		private String contextClassName;

		private final String contextClassName;

		private String contextClassPlugin;

		private final String contextClassPlugin;

		 */ 

		 */

		private boolean syntaxError; 

		private final boolean syntaxError;

		private final List methods;

		private final MethodValueEntry[] methods;

		private final List staticMethods;

		private final MethodValueEntry[] staticMethods;

		 * 

		 *

		 * 

		 *

			 String s = configElement.getAttribute(classNameTag);

			String className = null;

			 if (s != null) {

			String classPlugin = null;

				 int start = s.indexOf("(");//$NON-NLS-1$

			String s = configElement.getAttribute(classNameTag);

				 if (start != -1) {

					contextClassName = s.substring(0, start).trim();

			if (s != null) {

				 	int end = s.indexOf(")");//$NON-NLS-1$

				int start = s.indexOf('(') + 1;

					if (end != -1 && end > start+1)

				if (start == 0) {

						contextClassPlugin = s.substring(start+1, end);

					className = s;

				 } else

				} else {

					contextClassName = s.trim();

					className = s.substring(0, start - 1);

			 }

					int end = s.indexOf(')', start);

					if (end != -1)

			 IConfigurationElement[] methodConfigs =

						classPlugin = s.substring(start + 1, end).trim().intern();

				configElement.getChildren(METHOD);

			 IConfigurationElement[] staticMethodConfigs =

				configElement.getChildren(STATIC_METHOD);

			if (methodConfigs.length != 0) {

				methods = new ArrayList(methodConfigs.length);

				for (int i = 0; i < methodConfigs.length; i++) {

					String name = methodConfigs[i].getAttribute(NAME);

					if (name != null) {

						try {

							MethodDescriptor methodDescriptor =

								new MethodDescriptor(name);

							methodDescriptor.setCall(name.intern());

							ValueDescriptor value =

								new ValueDescriptor(methodConfigs[i]);

							if (value != null)

								methods.add(new MethodValueEntry(methodDescriptor, value));

						} catch (Exception e) {

							syntaxError = true;

							Log.error(CommonCorePlugin.getDefault(), CommonCoreStatusCodes.SERVICE_FAILURE,	configElement.getDeclaringExtension().getNamespace()+ ".plugin.xml extension [" + configElement.getDeclaringExtension().getExtensionPointUniqueIdentifier() + "]: invalid syntax for method [" + name + "]");  //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

						}

					} else {

						syntaxError = true;

						Log.error(CommonCorePlugin.getDefault(), CommonCoreStatusCodes.SERVICE_FAILURE,	configElement.getDeclaringExtension().getNamespace()+ ".plugin.xml extension [" + configElement.getDeclaringExtension().getExtensionPointUniqueIdentifier() + "] : missing method name");  //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

					}

			} 

				className = className.trim().intern();

			else

			}

				methods = Collections.EMPTY_LIST;

			contextClassName = className;

			contextClassPlugin = classPlugin;

			if (staticMethodConfigs.length != 0) {

				staticMethods = new ArrayList(staticMethodConfigs.length);

			methods = getMethods(configElement, false);

				for (int i = 0; i < staticMethodConfigs.length; i++) {

			staticMethods = getMethods(configElement, true);

					String name = staticMethodConfigs[i].getAttribute(NAME);

					if (name != null) {

			syntaxError = anyNull(methods) || anyNull(staticMethods);

						try {

		}

							StaticMethodDescriptor methodDescriptor =

								new StaticMethodDescriptor(name);

		private static boolean anyNull(MethodValueEntry[] entries) {

							methodDescriptor.setCall(name.intern());

			for (int i = entries.length; --i >= 0;)

							ValueDescriptor value =

				if (entries[i] == null)

								new ValueDescriptor(staticMethodConfigs[i]);

					return true;

							if (value != null)

								staticMethods.add(new MethodValueEntry(methodDescriptor, value));

			return false;

						} catch (Exception e) {

		}

							syntaxError = true;

							Log.error(CommonCorePlugin.getDefault(), CommonCoreStatusCodes.SERVICE_FAILURE,	configElement.getDeclaringExtension().getNamespace()+ ".plugin.xml extension [" + configElement.getDeclaringExtension().getExtensionPointUniqueIdentifier() + "]: invalid syntax for method [" + name + "]");  //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

		private static MethodValueEntry[] getMethods(

						}

				IConfigurationElement config,

					} else {

				boolean isStatic) {

						syntaxError = true;

						Log.error(CommonCorePlugin.getDefault(), CommonCoreStatusCodes.SERVICE_FAILURE,	configElement.getDeclaringExtension().getNamespace()+ ".plugin.xml extension [" + configElement.getDeclaringExtension().getExtensionPointUniqueIdentifier() + "] : missing method name");  //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

			IConfigurationElement[] elements;

			MethodValueEntry[] entries;

			int count;

			elements = config.getChildren(isStatic ? STATIC_METHOD : METHOD);

			count = elements.length;

			if (count == 0) {

				entries = NO_METHODS;

			} else {

				entries = new MethodValueEntry[count];

				for (int i = 0; i < count; ++i) {

					IConfigurationElement element = elements[i];

					String name = element.getAttribute(NAME);

					if (name == null) {

						logException(config, "missing method name"); //$NON-NLS-1$

						continue;

					}

					try {

						MethodDescriptor method;

						if (isStatic)

							method = StaticMethodDescriptor.create(name);

						else

							method = new MethodDescriptor(name);

						ValueDescriptor value = new ValueDescriptor(element);

						entries[i] = new MethodValueEntry(method, value);

					} catch (Exception e) {

						logException(config,

							"invalid syntax for method [" + name + ']'); //$NON-NLS-1$

			}else

			}

				staticMethods = Collections.EMPTY_LIST;

			return entries;

		}

			if (contextClassName != null)

		private static void logException(IConfigurationElement element, String message) {

				contextClassName = contextClassName.intern();

			IExtension extension = element.getDeclaringExtension();

			if (contextClassPlugin != null)

			Log.error(

				contextClassPlugin = contextClassPlugin.intern();

					CommonCorePlugin.getDefault(),

					CommonCoreStatusCodes.SERVICE_FAILURE,

					extension.getNamespace()

						+ ".plugin.xml extension [" //$NON-NLS-1$

						+ extension.getExtensionPointUniqueIdentifier()

						+ "]: " //$NON-NLS-1$

						+ message);

		 * 

		 *

			Object targetObject = object;

			if (contextClassName != null && object != null) {

			if (contextClassName != null) {

					targetObject = getAdapter(object, contextClassName, contextClassPlugin);

					object = getAdapter(object, contextClassName, contextClassPlugin);

					if (targetObject == null)

					if (object == null)

			for(Iterator iter = staticMethods.iterator(); iter.hasNext();) {

			return allMatch(methods, object)

				MethodValueEntry entry = (MethodValueEntry)iter.next();

				? allMatch(staticMethods, object)

				Object methodValue = invokeStaticMethod((StaticMethodDescriptor)entry.method, targetObject);

				: false;

		}

				if (methodValue == null || !entry.value.sameAs(methodValue))

	}

					return false;

	/**

	 * A simple string parser used to decompose method and value descriptors.

	 *

	 * @author keithc

	 */

	private static final class SimpleParser {

		private final String input;

		private int offset;

		public SimpleParser(String input) {

			super();

			this.input = input;

			this.offset = 0;

		}

		/**

		 * Return the next portion of the input string up to but not including

		 * the given delimiter character.

		 *

		 * @param delimiter

		 *            the delimiter

		 * @param delimiterRequired

		 *            is the delimiter required?

		 * @return String the token

		 * @throws IllegalArgumentException

		 *             if the delimiter is required but not found

		 */

		public String nextToken(char delimiter, boolean delimiterRequired) {

			int start = offset;

			int end = safeIndexOf(delimiter);

			if (end >= 0) {

				offset = end + 1;

			} else {

				if (delimiterRequired)

					throw new IllegalArgumentException();

				end = input.length();

				offset = end;

			}

			return unescape(start, end, delimiter);

		}

		/**

		 * Return the next portion of the input string up to but not including

		 * the last occurence of the first delimiter character that appears

		 * before the next occurence of the second delimiter character.

		 *

		 * @param delim1

		 *            the first delimiter character

		 * @param delim2

		 *            the second delimiter character

		 * @return String the token

		 * @throws IllegalArgumentException

		 *             if the delimiters are not found

		 */

		public String nextTokenBefore(char delim1, char delim2) {

			int start = offset;

			int end = safeIndexOf(delim2);

			if (end < 0)

				throw new IllegalArgumentException();

			end = safeLastIndexOf(delim1, end);

			offset = end + 1;

			return unescape(start, end, delim1);

		}

		public boolean moreInput() {

			return offset < input.length();

		}

		private int safeIndexOf(char delim) {

			for (int start = offset;;) {

				int index = input.indexOf(delim, start);

				if (index <= start || input.charAt(index - 1) != '\\')

					return index;

				start = index + 1;

			}

		}

		private int safeLastIndexOf(char delim, int end) {

			for (;;) {

				int index = input.lastIndexOf(delim, end);

				if (index < offset)

					throw new IllegalArgumentException();

				if (index == offset || input.charAt(index - 1) != '\\')

					return index;

				end = index = 1;

		}

			return true;

		public String tail() {

			return input.substring(offset);

		}

		private String unescape(int start, int end, char delimiter) {

			StringBuffer buffer = null;

			// don't consider the last character in the loop

			end -= 1;

			for (int index = start; index < end; ++index) {

				char c = input.charAt(index);

				if (c != '\\' || input.charAt(index + 1) != delimiter)

					continue;

				if (buffer == null)

					buffer = new StringBuffer(input.substring(0, index));

				else

					buffer.append(input.substring(start, index));

			}

			String result = input.substring(start, end + 1);

			if (buffer != null)

				result = buffer.append(result).toString();

			return result;

		/**

		 * An empty array of types and values for methods with no parameters.

		 */

		private static final Class[] NO_PARAMETERS = new Class[0];

		 * The method call.

		 * A cache for information about methods. Keyed by (class, method

		 * signature), the corresponding value is either a Method or

		 * Boolean.FALSE signifying that no accessible method exists.

		 *

		 * We use a WeakHashMap to allow classes to be unloaded.

		private String call;

		private static final Map methodCache = new WeakHashMap();

		private String name;

		protected final String name;

		private Object parameterObjects[];

		protected final Object[] parameterObjects;

		private Class parameterTypes[];

		protected final Class[] parameterTypes;

		private MethodDescriptor next;

		protected final MethodDescriptor next;

		private String signature = null;

		private final MethodSignature signature;

		protected MethodDescriptor(){

			// empty 

		}

		 * <LI>the <i>params </i> are comma-separated string literals without

		 * <LI>the <i>params</i> are comma-separated string literals without

		 * <LI>only string <i>params </i> are allowed (no texual representation

		 * <LI>only string <i>params</i> are allowed (no texual representation

		 * 

		 *

			// set method name

			super();

			string = parseName(string.trim());

			SimpleParser parser = new SimpleParser(string);

			name = parser.nextToken('(', true).trim().intern();

			string = parseParameterList(string.trim());

			List parameters = new ArrayList();

			String parmString = parser.nextToken(')', true).trim();

			SimpleParser parmParser = new SimpleParser(parmString);

			while (parmParser.moreInput())

				parameters.add(parmParser.nextToken(',', false));

			if (parameters != null && !parameters.isEmpty()) {

			int parmCount = parameters.size();

				Collections.reverse(parameters);

				parameterObjects = parameters.toArray();

			if (parmCount == 0) {

				parameterTypes = new Class[parameterObjects.length];

				parameterObjects = NO_PARAMETERS;

				for (int i = 0; i < parameterObjects.length; i++) {

				parameterTypes = NO_PARAMETERS;

					String p = (String) parameterObjects[i];

			} else {

					int objIndex = p.indexOf("[object]"); //$NON-NLS-1$

				parameterObjects = new Object[parmCount];

					boolean isObject = objIndex >= 0;

				parameterTypes = new Class[parmCount];

					int parseAsIndex = p.indexOf(":::"); //$NON-NLS-1$

				for (int index = 0; index < parmCount; ++index)

					try {

					setParameterAndType((String) parameters.get(index), index);

						if (isObject && (parseAsIndex >= 0))

			}

							// assume order: [object] before type:::param

							assert (objIndex < parseAsIndex);

			string = parser.tail().trim();

						if (parseAsIndex >= 0) {

							// "type:::param"

			if (string.length() == 0)

							String parseAs =

				next = null;

								p.substring((isObject ? 8 : 0), parseAsIndex);

			else if (string.charAt(0) == '.')

							String value =

				next = new MethodDescriptor(string.substring(1).trim());

								p.substring(parseAsIndex + 3, p.length());

			else

							if (parseAs.equalsIgnoreCase("int")) { //$NON-NLS-1$

				throw new IllegalArgumentException();

								parameterTypes[i] = Integer.class;

								parameterObjects[i] = Integer.decode(value);

			signature = new MethodSignature(this);

							} else if (parseAs.equalsIgnoreCase("bool")) { //$NON-NLS-1$

		}

								parameterTypes[i] = Boolean.class;

								parameterObjects[i] = Boolean.valueOf(value);

		protected void setParameterAndType(String parameter, int index) {

							} else if (parseAs.equalsIgnoreCase("double")) { //$NON-NLS-1$

			boolean isObject = parameter.startsWith("[object]"); //$NON-NLS-1$

								parameterTypes[i] = Double.class;

			int parseAsIndex = parameter.indexOf(":::"); //$NON-NLS-1$

								parameterObjects[i] = Double.valueOf(value);

			Class clazz;

							}

			Object object;

							// if [object] present, set type to Object

							if (isObject)

			try {

								parameterTypes[i] = Object.class;

				if (parseAsIndex >= 0) { // "type:::param"

						} else if (isObject) { // "[object]param"

					String type = parameter.substring(isObject ? 8 : 0, parseAsIndex);

							String value = p.substring(8, p.length());

					String value = parameter.substring(parseAsIndex + 3);

							parameterTypes[i] = Object.class;

							parameterObjects[i] = value;

					if (type.equalsIgnoreCase("int")) { //$NON-NLS-1$

						} else // "param"

						clazz = Integer.class;

							parameterTypes[i] = String.class;

						object = Integer.decode(value);

					} catch (Exception e) {

					} else if (type.equalsIgnoreCase("bool")) { //$NON-NLS-1$

						String value =

						clazz = Boolean.class;

							p.substring(

						object = Boolean.valueOf(value);

								((parseAsIndex >= 0) ? parseAsIndex + 3 : 0),

					} else if (type.equalsIgnoreCase("double")) { //$NON-NLS-1$

								p.length());

						clazz = Double.class;

						parameterObjects[i] = value;

						object = Double.valueOf(value);

						parameterTypes[i] = String.class;

					} else {

						clazz = Object.class;

						object = value;

			// set method parameters

			return method;

			if (string.length() != 0) {

				if (string.charAt(0) != '.')

					throw new IllegalArgumentException();

				next = new MethodDescriptor(string.substring(1).trim());

			}

		 if (this.name != null)

				name = name.intern();

		/**

		public Object invoke(Object object) {

		 * Parses and returns the method name in a method invocation string.

			for (MethodDescriptor desc = this; object != null;) {

		 * 

				Method method = getMethod(object.getClass());

		 * @param string

		 *            the method invocation string

		 * @return the method name

		 */

		protected String parseName(String string) {

			int index = string.indexOf('(');

			if (index == -1)

				throw new IllegalArgumentException(); //$NON-NLS-1$

			name = string.substring(0, index).trim();

			return string.substring(index + 1);

		}

		/**

				if (method == null)

		 * Parses a method invocation string for the list of parameters, which

					break;

		 * are placed in the <code>parameters</code> field.

		 * 

				try {

		 * @param string

					object = method.invoke(object, desc.parameterObjects);

		 *            the method invocation string

				} catch (Exception e) {

		 * @return the end part of the method invocation string that has not

					break;

		 *         been parsed.

				}

		 */

		protected String parseParameterList(String string) {

				if ((desc = desc.next) == null)

			int index = -1;

					return object;

			String paramStr = null;

			while (paramStr == null) {

				index = string.indexOf(')', index + 1);

				if (index == -1)

					throw new IllegalArgumentException(); //$NON-NLS-1$

				if (index == 0 || string.charAt(index - 1) != '\\')

					paramStr = string.substring(0, index);

			}

			if (paramStr.length() != 0) {

				parameters = new ArrayList();

				parseParameters(paramStr.trim());

		/**

			return null;

		 * Parses a string containing a list of method parameters and stores

		 * them in the <code>parameters</code> field.

		 * 

		 * @param string

		 *            the comma-separated list of method parameters.

		 */

		private void parseParameters(String string) {

			int index = string.indexOf(',');

			if (index != -1 && string.charAt(index - 1) != '\\') {

				parseParameters(string.substring(index + 1).trim());

				parameters.add(string.substring(0, index));

			} else

				parameters.add(string);

		/**

	private static final class MethodSignature {

		 * Returns the method name.

		 * 

		 * @return the method name

		 */

		public String getName() {

			return name;

		}

		/**

		 * Sets the method name.

		 * @param the method name

		 */

		public void setName(String name) {

			this.name = name;

		}

		/**

		private final int hashCode;

		 * Returns an array of string params.

		private final MethodDescriptor method;

		 * 

		 * @return the parameters

		 */

		public Object[] getParameters() {

			return parameterObjects;

		}

		/**

		public MethodSignature(MethodDescriptor method) {

		 * Returns an array of parameter classes.

			super();

		 * 

		 * @return the parameter types

		 */

		public Class[] getParameterTypes() {

			return parameterTypes;

		}

		/**

		 * sets the the array of params.

		 * @param paramters

		 */

		protected void setParameters(Object[] paramters) {

			parameterObjects = paramters;

		}

		/**

			int hash = method.name.hashCode();

		 * sets the the array of parameter types.

			Class[] types = method.parameterTypes;

		 * @param paramtersTypes

		 */

		public void setParameterTypes(Class[] paramterTypes) {

			this.parameterTypes = paramterTypes;

		}

		/**

			for (int i = 0, n = types.length; i < n; ++i)

		 * Returns the next cascading method descriptor, if any.

				hash = HashUtil.hash(hash, types[i]);

		 * 

		 * @return the next method descriptor, or <code>null</code> if there

		 *         is none

		 */

		public MethodDescriptor getNext() {

			return next;

		}

		/**

		 * sets the next cascading method descriptor, if any.

		 * @param next

		 */

		protected void setNext(MethodDescriptor next) {

			this.next = next;

		}

		/**

			this.hashCode = hash;

		 * Gets the method call.

			this.method = method;

		 * 

		 * @return the method call.

		 */

		public String getCall() {

			return call;

		}

		/**

		 * Sets the method call.

		 * 

		 * @param call

		 *            the new method call

		 */

		public void setCall(String call) {

			this.call = call;

		}

		/**

		 * Gets the Paramters List

		 * @return The list of method parameters.

		 */

		protected List getParamtersList(){

			return parameters;

		/**

		public boolean equals(Object other) {

		 * Sets the Paramters List

			if (other == this)

		 * @param Parameterlist

				return true;

		 */

		protected void setParamtersList(List parameters1){

			if (other instanceof MethodSignature == false)

			this.parameters = parameters1;

				return false;

			MethodSignature otherSignature = (MethodSignature) other;

			if (hashCode != otherSignature.hashCode)

				return false;

			MethodDescriptor thisMethod = this.method;

			MethodDescriptor thatMethod = otherSignature.method;

			if (thisMethod.name == thatMethod.name)

				return false;

			Class[] theseTypes = thisMethod.parameterTypes;

			Class[] thoseTypes = thatMethod.parameterTypes;

			int typeCount = theseTypes.length;

			if (typeCount != thoseTypes.length)

				return false;

			for (int i = 0; i < typeCount; ++i)

				if (theseTypes[i] != thoseTypes[i])

					return false;

			return true;

		/**

		public int hashCode() {

		 * utility method used to get the signature of the method this method descriptor

			return hashCode;

		 * descripe.

		 * @return the signature of the method

		 */

		public String getSignature(){

			if (this.signature==null){

				StringBuffer sb = 

					new StringBuffer();

				sb.append(name);

				sb.append('(');

				if(parameterTypes!=null)

					for(int index= 0 ; index < parameterTypes.length ; index++){

						Class clazz = parameterTypes[index];

						sb.append(clazz.getName());

						if(index<parameterTypes.length-1)

							sb.append(',');

					}

				sb.append(')');

				signature = sb.toString();

			}

			return signature;

	private static final class StaticMethodDescriptor extends MethodDescriptor {

	private static class StaticMethodDescriptor extends MethodDescriptor {

		/**

		private static boolean anyContextParameters(Object[] parameterObjects) {

		 * the plugin Name

			for (int index = parameterObjects.length; --index >= 0;)

		 */

				if (parameterObjects[index] == contextParam)

		private String pluginID;

					return true;

		/**

			return false;

		 * the Class Name

		}

		 */

		private String className;

		 * <code>PluginID\ClassName.method_name([params])[.method_name([params])]*</code>

		 * <code>PluginID/ClassName.method_name([params])[.method_name([params])]*</code>

		 * <code>MyPluginID\MyClass.MyStaticFunction(%,"some value")</code>

		 * <code>MyPluginID/MyClass.MyStaticFunction(%Context,"some value")</code>

		 * 

		 *

		public StaticMethodDescriptor(String string) {

		public static StaticMethodDescriptor create(String string) {

			// set plugin ID

			SimpleParser parser = new SimpleParser(string);

			string = parsePluginID(string.trim());

			// set class Name 

			string = parseClassName(string.trim());

			// set method name

			string = parseName(string.trim());

			// set method parameters

			string = parseParameterList(string.trim());

			List parameters = getParamtersList();

			// get plugin ID

			String pluginId = parser.nextToken('/', true);

			// fill the parameter objects and types arrays

			if (parameters != null && !parameters.isEmpty()) {

				Collections.reverse(parameters);

				Object[] parameterObjects = parameters.toArray();

				Class[] parameterTypes = new Class[parameterObjects.length];

				for (int i = 0; i < parameterObjects.length; i++) {

					String p = (String) parameterObjects[i];

					int objIndex = p.indexOf("[object]"); //$NON-NLS-1$

					boolean isObject = objIndex >= 0;

					int parseAsIndex = p.indexOf(":::"); //$NON-NLS-1$

					try {

						if (isObject && (parseAsIndex >= 0))

							// assume order: [object] before type:::param

							assert (objIndex < parseAsIndex);

						if (parseAsIndex >= 0) {

							// "type:::param"

							String parseAs =

								p.substring((isObject ? 8 : 0), parseAsIndex);

							String value =

								p.substring(parseAsIndex + 3, p.length());

							if (parseAs.equalsIgnoreCase("int")) { //$NON-NLS-1$

								parameterTypes[i] = Integer.class;

								parameterObjects[i] = Integer.decode(value);

							} else if (parseAs.equalsIgnoreCase("bool")) { //$NON-NLS-1$

								parameterTypes[i] = Boolean.class;

								parameterObjects[i] = Boolean.valueOf(value);

							} else if (parseAs.equalsIgnoreCase("double")) { //$NON-NLS-1$

								parameterTypes[i] = Double.class;

								parameterObjects[i] = Double.valueOf(value);

							}

							// if [object] present, set type to Object

							if (isObject)

								parameterTypes[i] = Object.class;

						} else if (isObject) { // "[object]param"

							String value = p.substring(8, p.length());

							parameterTypes[i] = Object.class;

							parameterObjects[i] = value;

						} else if (p.startsWith(contextParam)){// "param" //$NON-NLS-1$

							parameterTypes[i] = getParameterType(p);

							parameterObjects[i] = "%Context"; //$NON-NLS-1$

						}

						else

							parameterTypes[i] = String.class;

					} catch (Exception e) {

						String value =

							p.substring(

								((parseAsIndex >= 0) ? parseAsIndex + 3 : 0),

								p.length());

						parameterObjects[i] = value;

						parameterTypes[i] = String.class;

					}

				}

				setParameters(parameterObjects);

				setParameterTypes(parameterTypes);

			}

			parameters = null;

			// set method parameters

			// get class name

			if (string.length() != 0) {

			String className = parser.nextTokenBefore('.', '(');

				if (string.charAt(0) != '.')

					throw new IllegalArgumentException();

			return new StaticMethodDescriptor(pluginId, className, parser.tail());

				setNext(new MethodDescriptor(string.substring(1).trim()));

			}

		 if (getName() != null)

				setName(getName().intern());

		}

		/**

		 * parse the passed paramter to extract the paramter's class

		 * @param p		the parapemter 

		 * @return

		 */

		private Class getParameterType(String parameter) {

			int startIndex = parameter.indexOf("["); //$NON-NLS-1$

			int endIndex = parameter.indexOf("]"); //$NON-NLS-1$

			if(startIndex==-1 || endIndex==-1)

				throw new IllegalArgumentException(); //$NON-NLS-1$

			String parameterTypeString= parameter.substring(startIndex+1,endIndex).trim();

			endIndex = parameterTypeString.indexOf('/');

			if(endIndex==-1 || endIndex==parameterTypeString.length()-1)

				throw new IllegalArgumentException(); //$NON-NLS-1$

			String parameterPluginID = parameterTypeString.substring(0,endIndex).trim();

			String parameterClassName = parameterTypeString.substring(endIndex + 1);

			Class clazz = loadClass(parameterClassName,parameterPluginID);

			if(clazz==null)

				clazz =  Object.class;

			return clazz;

		 * Parses and returns the Plugin ID in a method invocation string.

		 * Does this object have any "%Context" parameters?

		 * 

		 */

		 * @param string

		private final boolean hasContextParameters;

		 *            the method invocation string

		 * @return the plugin name

		/**

		 * the Class Name

		private String parsePluginID(String string) {

		public final String className;

			int index = string.indexOf('/');

			if (index == -1)

		/**

				throw new IllegalArgumentException(); //$NON-NLS-1$

		 * the plugin Name

			pluginID = string.substring(0, index).trim();

		 */

			return string.substring(index + 1);

		public final String pluginID;

		private StaticMethodDescriptor(

				String pluginID,

				String className,

				String method) {

			super(method);

			this.className = className.intern();

			this.pluginID = pluginID.intern();

			this.hasContextParameters = anyContextParameters(parameterObjects);

		}

		private Object[] getParametersFor(Object context) {

			Object[] parameters = parameterObjects;

			if (hasContextParameters) {

				parameters = (Object[]) parameters.clone();

				for (int i = parameters.length; --i >= 0;)

					if (parameters[i] == contextParam)

						parameters[i] = context;

			}

			return parameters;

		protected void setParameterAndType(String parameter, int index) {

			if (!parameter.startsWith(contextParam)) {

				super.setParameterAndType(parameter, index);

				return;

			}

			SimpleParser parser = new SimpleParser(parameter);

			// parse "%Context[pluginID/className]"

			parser.nextToken('[', true); // skip "%Context"

			String parmPluginID = parser.nextToken('/', true).trim();

			String parmClassName = parser.nextToken(']', true).trim();

			Class type = loadClass(parmClassName, parmPluginID); // TODO delay loading classes

			if (type == null)

				type = Object.class;

			parameterTypes[index] = type;

			parameterObjects[index] = contextParam;

		}

		 * Parses and returns the Plugin ID in a method invocation string.

		 * A utility method to invoke a cascading list of methods.

		 * 

		 *

		 * @param string

		 * @param object

		 *            the method invocation string

		 *            The context object to use (it could be null)

		 * @return the plugin name

		 * @return the value of the invokation

		private String parseClassName(String string) {

		public Object invoke(Object object) {

			int index = string.indexOf('(');

			Class clazz = loadClass(className, pluginID);

			if (index == -1)

				throw new IllegalArgumentException(); //$NON-NLS-1$

			if (clazz == null)

			index = string.lastIndexOf('.',index);

				return null;

			if (index == -1)

				throw new IllegalArgumentException(); //$NON-NLS-1$

			Method method = getMethod(clazz);

			className = string.substring(0, index).trim();

			return string.substring(index + 1);

			if (method == null)

		}

				return null;

	public String getPluginID(){

			try {

			return pluginID;

				object = method.invoke(null, getParametersFor(object));

		}

			} catch (Exception e) {

				return null;

		public String getClassName(){

			}

			return className;

			return next == null ? object : next.invoke(object);

 	}

	}

	private static class ValueDescriptor {

	private static final class ValueDescriptor {

		 * The valid value literals.

		 * The value literals map. Keyed by a string, the corresponding value

		 * indicates whether that value is permitted or disallowed.

		private Set valueLiterals;

		private final Map valueMap;

		 * The invalid valud literals.

		 * Are there any permitted values specified?

		private Set notValueLiterals;

		private final boolean valuesSpecified;

		private List valueObjects;

		private final ObjectDescriptor[] valueObjects;

		private List notValueObjects;

		private final ObjectDescriptor[] notValueObjects;

		 * 

		 *

		 * @param configElement

		 * @param element

		public ValueDescriptor(IConfigurationElement configElement) {

		public ValueDescriptor(IConfigurationElement element) {

			valueLiterals = new HashSet();

			super();

			String s = configElement.getAttribute(VALUE);

			valueObjects = parseObjects(element.getChildren(VALUE));

			if (s != null)

			notValueObjects = parseObjects(element.getChildren(NOT_VALUE));

				parseValueLiteralString(s, valueLiterals);

			Map literals = new HashMap();

			notValueLiterals = new HashSet();

			s = configElement.getAttribute(NOT_VALUE);

			// For backwards compatibility when values and not-values overlap

			if (s != null)

			// we add not-values first so values continue to take precedence.

				parseValueLiteralString(s, notValueLiterals);

			addLiterals(element.getAttribute(NOT_VALUE), literals, Boolean.FALSE);

			valuesSpecified = addLiterals(element.getAttribute(VALUE), literals, Boolean.TRUE);

			IConfigurationElement[] valueConfigs = configElement.getChildren(VALUE);

			valueObjects = new ArrayList(valueConfigs.length);

			switch (literals.size()) {

			for (int i=0; i<valueConfigs.length; i++)

				case 0:

				valueObjects.add(new ObjectDescriptor(valueConfigs[i]));

					valueMap = null;

					break;

			IConfigurationElement[] notValueConfigs = configElement.getChildren(NOT_VALUE);

				case 1:

			notValueObjects = new ArrayList(notValueConfigs.length);

					Entry entry = (Entry) literals.entrySet().iterator().next();

			for (int i=0; i<notValueConfigs.length; i++)

					valueMap = Collections.singletonMap(entry.getKey(), entry.getValue());

				notValueObjects.add(new ObjectDescriptor(notValueConfigs[i]));

					break;

		}

				default:

					valueMap = literals;

		/**

					break;

		 * Parse the string <code>s</code>, which is a comma-separated list

		 * of value literals and place them in the given <code>list</code>.

		 * 

		 * @param s

		 *            the string to be parsed

		 * @param list

		 *            the set of literal string values from <code>s</code>.

		 */

		private void parseValueLiteralString(String s, Set list) {

			// parse the string comma-separated string literals ignoring escaped commas

			int start = 0;

			int end = s.indexOf(',');

			while (end != -1) {

				if (s.charAt(end-1) == '\\') {

					s = s.substring(0, end-1) + s.substring(end);

					end = s.indexOf(',', end);

					continue;

				}

				list.add(s.substring(start, end).trim().intern());

				start = end +1;

				end = s.indexOf(',', start);

		/**

		 * Parse the given string, which is a comma-separated list of value

		 * literals and use them as keys in the given map where value is to be

		 * stored.

		 *

		 * @param string

		 *            the string of literals

		 * @param literals

		 *            the map in which the entries are to be stored

		 * @param value

		 *            the value to be associated with each literal

		 * @return boolean whether the string was non-null

		 */

		private static boolean addLiterals(String string, Map literals, Boolean value) {

			if (string == null)

				return false;

			// parse the string comma-separated string literals

			// (ignoring escaped commas)

			SimpleParser parser = new SimpleParser(string);

			do {

				String token = parser.nextToken(',', false);

				literals.put(token.trim().intern(), value);

			} while (parser.moreInput());

			return true;

		}

		private static ObjectDescriptor[] parseObjects(IConfigurationElement[] configs) {

			int length = configs.length;

			if (length == 0)

				return null;

			ObjectDescriptor[] descriptors = new ObjectDescriptor[length];

			for (int i = 0; i < length; ++i)

				descriptors[i] = new ObjectDescriptor(configs[i]);

			return descriptors;

		}

		 * 

		 *

			if (!valueLiterals.isEmpty()) {

			if (valueMap != null) {

				if (!valueLiterals.contains(object.toString()))

				Object bool = valueMap.get(object.toString());

					return false;

			}

				if (bool == Boolean.FALSE)

			if (!notValueLiterals.isEmpty()) {

					// one of the specified not-values

				if (notValueLiterals.contains(object.toString()))

					return false;

			}

			if (!valueObjects.isEmpty()) {

				if (!isObjectinList(object, valueObjects))

			}

				else if (valuesSpecified && bool == null)

			if (!notValueObjects.isEmpty()) {

					// not one of the specified values

				if (isObjectinList(object, notValueObjects))

		 * 

		 *

		private boolean isObjectinList(Object object, List list) {

		private static boolean isObjectInList(Object object, ObjectDescriptor[] list) {

			Iterator i = list.iterator();

			for (int i = 0, n = list.length; i < n; ++i)

			while (i.hasNext()) {

				if (list[i].sameAs(object))

				if (((ObjectDescriptor)i.next()).sameAs(object))

			}

	private static class MethodValueEntry {

	private static final class MethodValueEntry {

		public MethodDescriptor method;

		private final MethodDescriptor method;

		public ValueDescriptor value;

		private final ValueDescriptor value;

	 * 

	 *

				Log.error(CommonCorePlugin.getDefault(), CommonCoreStatusCodes.SERVICE_FAILURE, configElement.getDeclaringExtension().getNamespace()+ ".plugin.xml extension [" + configElement.getDeclaringExtension().getExtensionPointUniqueIdentifier() + "]: object id (" + objectId + ") is not in the list " + objectMap.keySet());  //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$

				IExtension extension = configElement.getDeclaringExtension();

				Log.error(CommonCorePlugin.getDefault(), CommonCoreStatusCodes.SERVICE_FAILURE, extension.getNamespace()+ ".plugin.xml extension [" + extension.getExtensionPointUniqueIdentifier() + "]: object id (" + objectId + ") is not in the list " + objectMap.keySet()); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

	 * 

	 *

	 * 

	 *

	 * 

	 *