/*******************************************************************************
 * Copyright (c)  2005 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.proxy.remote;

import java.util.*;
import java.util.Map.Entry;

import org.eclipse.jem.internal.proxy.core.*;
import org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent;


/**
 * MethodProxyConstants is a cache of IMethodProxies to avoid repeated lookup
 * and thereby avoid the relatively expensive java.lang.reflect calls to repeatedly
 * lookup method by name
 * 
 * @since 1.1.0
 */
public class REMProxyConstants {

	private Map methodsCache = new HashMap(80);
	private Map invokablesCache = new HashMap(80);	
	private Map fieldsCache = new HashMap(80);
	
	private REMProxyFactoryRegistry registry;
	
	public REMProxyConstants(REMProxyFactoryRegistry registry) {
		this.registry = registry;
	}
	
	/*
	 * Used as the key to the methodCache and invokablesCache when there are parms.
	 * It allows the parms to be either strings or IBeanTypeProxies without the
	 * overhead of creating complicated strings.
	 * 
	 * It will compare method name and each individual parm name without fluffing
	 * up a string and building it up.
	 * 
	 * For no parm methods, just the name of the method as a string will be the key.
	 * 
	 * @since 1.1.0
	 */
	private abstract static class MethodKey {
		public String methodName;
		public MethodKey(String methodName) {
			this.methodName = methodName;
		}
				
		protected abstract boolean compareParms(IProxyBeanType[] parms);
		protected abstract boolean compareParms(String[] parms);
		
		
		/* (non-Javadoc)
		 * @see java.lang.Object#hashCode()
		 */
		public int hashCode() {
			return methodName.hashCode();
		}
	}
	
	private static class MethodKeyStringParms extends MethodKey {
		public String[] parmNames;
		
		public MethodKeyStringParms(String methodName, String[] parmNames) {
			super(methodName);
			this.parmNames = parmNames;
		}
		
		/* (non-Javadoc)
		 * @see java.lang.Object#equals(java.lang.Object)
		 */
		public boolean equals(Object obj) {
			if (this == obj)
				return true;
			try {
				return ((MethodKey) obj).compareParms(parmNames);
			} catch (ClassCastException e) {
				return false;
			}
		}
		
		
		/* (non-Javadoc)
		 * @see org.eclipse.jem.internal.proxy.remote.REMProxyConstants.MethodKey#hashCode()
		 */
		public int hashCode() {
			int h = super.hashCode();
			for (int i = 0; i < parmNames.length; i++) {
				h += parmNames[i].hashCode();
			}
			return h;
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.jem.internal.proxy.remote.REMProxyConstants.MethodKey#compareParms(org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
		 */
		protected boolean compareParms(IProxyBeanType[] parms) {
			if (parms.length != parmNames.length)
				return false;
			for (int i = 0; i < parms.length; i++) {
				if (!parms[i].getTypeName().equals(parmNames[i]))
					return false;
			}
			return true;
		}
		
		
		/* (non-Javadoc)
		 * @see org.eclipse.jem.internal.proxy.remote.REMProxyConstants.MethodKey#compareParms(java.lang.String[])
		 */
		protected boolean compareParms(String[] parms) {
			return Arrays.equals(parms, parmNames);
		}
	}
	
	private static class MethodKeyProxyParms extends MethodKey {
		public IProxyBeanType[] parmTypes;
		
		public MethodKeyProxyParms(String methodName, IProxyBeanType[] parmTypes) {
			super(methodName);
			this.parmTypes = parmTypes;
		}
		
		public Object toMethodKeyStringParms() {
			String[] parms = new String[parmTypes.length];
			for (int i = 0; i < parmTypes.length; i++) {
				parms[i] = parmTypes[i].getTypeName();
			}
			return new MethodKeyStringParms(methodName, parms);
		}
		
		/* (non-Javadoc)
		 * @see java.lang.Object#equals(java.lang.Object)
		 */
		public boolean equals(Object obj) {
			if (this == obj)
				return true;
			try {
				return ((MethodKey) obj).compareParms(parmTypes);
			} catch (ClassCastException e) {
				return false;
			}
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.jem.internal.proxy.remote.REMProxyConstants.MethodKey#hashCode()
		 */
		public int hashCode() {
			int h = super.hashCode();
			for (int i = 0; i < parmTypes.length; i++) {
				h += parmTypes[i].getTypeName().hashCode();
			}
			return h;
		}
		
		/* (non-Javadoc)
		 * @see org.eclipse.jem.internal.proxy.remote.REMProxyConstants.MethodKey#compareParms(org.eclipse.jem.internal.proxy.core.IBeanTypeProxy[])
		 */
		protected boolean compareParms(String[] parms) {
			if (parms.length != parmTypes.length)
				return false;
			for (int i = 0; i < parms.length; i++) {
				if (!parmTypes[i].getTypeName().equals(parms[i]))
					return false;
			}
			return true;
		}
		
		
		/* (non-Javadoc)
		 * @see org.eclipse.jem.internal.proxy.remote.REMProxyConstants.MethodKey#compareParms(java.lang.String[])
		 */
		protected boolean compareParms(IProxyBeanType[] parms) {
			if (parms.length != parmTypes.length)
				return false;
			for (int i = 0; i < parms.length; i++) {
				if (!parmTypes[i].getTypeName().equals(parms[i].getTypeName()))
					return false;
			}
			return true;
		}		
	}
		
	static int REMMETHODCOUNT = 0;
	static int UNIQUEMETHODCOUNT = 0;	
	static int REMINVOKABLECOUNT = 0;
	static int UNIQUEINVOKABLECOUNT = 0;
	static int INVOKEINVOKECOUNT = 0;
	static int METHODPROXYINVOKECOUNT = 0;
	static int REMFIELDCOUNT = 0;
	static int UNIQUEFIELDCOUNT = 0;
	static int REMCONSTRUCTORCALLED = 0;
	static HashMap METHODCOUNTMAP;
	static HashMap FIELDCOUNTMAP;	 
	static HashMap FIELDSETCOUNTMAP;
	static boolean GATHER_COUNTS;
	
	/**
	 * Set if counts should be gathered.
	 * 
	 * @param gatherCounts
	 * 
	 * @since 1.1.0
	 */
	public static void setGatherCounts(boolean gatherCounts) {
		if (gatherCounts != GATHER_COUNTS) {
			reset();
			if (gatherCounts) {
				if (METHODCOUNTMAP == null) {
					METHODCOUNTMAP = new HashMap();
					FIELDCOUNTMAP = new HashMap();
					FIELDSETCOUNTMAP = new HashMap();
				}
			}
			GATHER_COUNTS = gatherCounts;
		}
	}
	
	
	public static void reset(){
		REMMETHODCOUNT = UNIQUEMETHODCOUNT = REMINVOKABLECOUNT = UNIQUEINVOKABLECOUNT = REMCONSTRUCTORCALLED = METHODPROXYINVOKECOUNT = INVOKEINVOKECOUNT = REMFIELDCOUNT = UNIQUEFIELDCOUNT = 0;
		if (GATHER_COUNTS) {
			METHODCOUNTMAP.clear();
			FIELDCOUNTMAP.clear();
			FIELDSETCOUNTMAP.clear();
		}
	}
	
	public static void println(){
		
		if (GATHER_COUNTS) {
			System.out.println("--------------------------------------------------"); //$NON-NLS-1$
			System.out.println("Method proxies invokes = " + METHODPROXYINVOKECOUNT); //$NON-NLS-1$
			System.out.println("Invoke invokes = " + INVOKEINVOKECOUNT); //$NON-NLS-1$
			System.out.println(".................................................."); //$NON-NLS-1$
			System.out.println("Methods retrieved = " + REMMETHODCOUNT + "(" + UNIQUEMETHODCOUNT + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
			System.out.println("Invokes retrieved = " + REMINVOKABLECOUNT + "(" + UNIQUEINVOKABLECOUNT + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
			System.out.println("Fields retrieved = " + REMFIELDCOUNT + "(" + UNIQUEFIELDCOUNT + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
			System.out.println("Constructor calls = " + REMCONSTRUCTORCALLED); //$NON-NLS-1$
			System.out.println("--------------------------------------------------"); //$NON-NLS-1$
			System.out.println("-Count of methods invoked-------------------------"); //$NON-NLS-1$
			System.out.println("--------------------------------------------------"); //$NON-NLS-1$

			// Collate the methods called
			Iterator entries = METHODCOUNTMAP.entrySet().iterator();
			while (entries.hasNext()) {
				Map.Entry entry = (Entry) entries.next();
				REMMethodProxy methodProxy = (REMMethodProxy) entry.getKey();
				System.out.println(methodProxy.getClassType().getTypeName() + "," + methodProxy.getName() + "," + entry.getValue()); //$NON-NLS-1$ //$NON-NLS-2$
			}

			System.out.println("--------------------------------------------------"); //$NON-NLS-1$
			System.out.println("-Count of fields get called ----------------------"); //$NON-NLS-1$
			System.out.println("--------------------------------------------------"); //$NON-NLS-1$

			// Collate the fields accessed
			entries = FIELDCOUNTMAP.entrySet().iterator();
			while (entries.hasNext()) {
				Map.Entry entry = (Entry) entries.next();
				REMFieldProxy fieldProxy = (REMFieldProxy) entry.getKey();
				System.out.println(fieldProxy.toBeanString() + "," + entry.getValue()); //$NON-NLS-1$
			}

			System.out.println("--------------------------------------------------"); //$NON-NLS-1$
			System.out.println("-Count of fields set called ----------------------"); //$NON-NLS-1$
			System.out.println("--------------------------------------------------"); //$NON-NLS-1$

			// Collate the fields set
			entries = FIELDSETCOUNTMAP.entrySet().iterator();
			while (entries.hasNext()) {
				Map.Entry entry = (Entry) entries.next();
				REMFieldProxy fieldProxy = (REMFieldProxy) entry.getKey();
				System.out.println(fieldProxy.toBeanString() + "," + entry.getValue()); //$NON-NLS-1$
			} 
		}
		
	}
	
/**
 * @param aBeanTypeProxy = BeanTypeProxy for the method
 * @param methodName = methodName to be looked for
 * @param parmTypes = array of qualified type names for the method arguments, null if no methods
 */ 
	public IMethodProxy getMethodProxy(IBeanTypeProxy aBeanTypeProxy, String methodName, String[] parmTypes){
		if (!registry.isValid())
			return null;

		REMMETHODCOUNT++;
		Map methods;
		Object key;
		synchronized (this) {
			// The classCache map is keyed by the BeanTypeProxy and holds a further map of cache'd methods
			methods = getMethods(aBeanTypeProxy);

			// The syntax of the key is methodName(parmType1,parmType2)
			if (parmTypes == null || parmTypes.length == 0) {
				key = methodName;
			} else {
				key = new MethodKeyStringParms(methodName, parmTypes);
			}

			IMethodProxy result = (IMethodProxy) methods.get(key);
			if (result != null)
				return result;
		}
		
		UNIQUEMETHODCOUNT++;
		// Get the method proxy and cache this before returning it
		// Get the method proxy and cache this before returning it
		REMMethodProxyFactory proxyFactory = (REMMethodProxyFactory) registry.getMethodProxyFactory();
		IMethodProxy result = proxyFactory.getMethodProxy((IREMBeanTypeProxy)aBeanTypeProxy,methodName,parmTypes);
		synchronized (this) {
			// Get it again to make sure it hasn't changed due to a race condition. We don't sync for the getMethodProxy because that goes to the remote vm and could deadlock.
			IMethodProxy mValue = (IMethodProxy) methods.get(key);
			if (mValue != null && mValue != result) {
				registry.releaseProxy(result); // Don't need the result now, got it through a race condition.
				return mValue; // We have a real value now.
			}
			methods.put(key, result);
		}		
		return result;				
	}
/**
 * @param aBeanTypeProxy
 * @return Map of cache'd methods
 */
private Map getMethods(IProxyBeanType aBeanTypeProxy) {
	Map methods = (Map) methodsCache.get(aBeanTypeProxy.getTypeName());
	if(methods == null){
		methods = new HashMap(20);
		methodsCache.put(aBeanTypeProxy.getTypeName(),methods);
	}
	return methods;
}
/**
 * @param aBeanTypeProxy
 * @return Map of cache'd invokables
 */
private Map getInvokables(IBeanTypeProxy aBeanTypeProxy) {
	Map invokables = (Map) invokablesCache.get(aBeanTypeProxy);
	if(invokables == null){
		invokables = new HashMap(20);
		invokablesCache.put(aBeanTypeProxy,invokables);
	}
	return invokables;
}
/**
 * @param aBeanTypeProxy
 * @return Map of cache'd fields
 */
private Map getFields(IProxyBeanType aBeanTypeProxy) {
	Map fields = (Map) fieldsCache.get(aBeanTypeProxy.getTypeName());
	if(fields == null){
		fields = new HashMap(20);
		fieldsCache.put(aBeanTypeProxy.getTypeName(),fields);
	}
	return fields;
}
/**
 * @param aBeanTypeProxy = BeanTypeProxy for the method
 * @param methodName = methodName to be looked for
 * @param parmTypes = array of qualified type names for the method arguments, null if no arguments
 */ 
	public IInvokable getInvokable(IBeanTypeProxy aBeanTypeProxy, String invokableName, String[] parmTypeNames){
		
		REMINVOKABLECOUNT++;
		// The classCache map is keyed by the BeanTypeProxy and holds a further map of cache'd methods
		Map invokables = getInvokables(aBeanTypeProxy);	
		
		Object key = null; 
		if(parmTypeNames == null || parmTypeNames.length == 0){
			key = invokableName;
		} else {
			key = new MethodKeyStringParms(invokableName, parmTypeNames);
		}			
		
		IInvokable result = (IInvokable) invokables.get(key);
		if(result != null) return result;
		
		UNIQUEINVOKABLECOUNT++;
		// Get the method proxy and cache this before returning it
		// Get the method proxy and cache this before returning it
		REMMethodProxyFactory proxyFactory = (REMMethodProxyFactory) aBeanTypeProxy.getProxyFactoryRegistry().getMethodProxyFactory();
		result = proxyFactory.getInvokable((IREMBeanTypeProxy)aBeanTypeProxy,invokableName,parmTypeNames);
		invokables.put(key,result);		
		return result;				
				
	}
	/**
	 * @param aBeanTypeProxy = BeanTypeProxy for the method
	 * @param methodName = methodName to be looked for
	 * @param parmTypes = array of IBeanTypeProxy types for the method arguments, null if no arguments
	 */ 
		public IInvokable getInvokable(IBeanTypeProxy aBeanTypeProxy, String invokableName, IBeanTypeProxy[] parmTypes){
			
			REMINVOKABLECOUNT++;
			// The classCache map is keyed by the BeanTypeProxy and holds a further map of cache'd methods
			Map invokables = getInvokables(aBeanTypeProxy);	
			
			Object key = null; 
			if(parmTypes == null || parmTypes.length == 0){
				key = invokableName;
			} else {
				key = new MethodKeyProxyParms(invokableName, parmTypes);
			}			
			
			IInvokable result = (IInvokable) invokables.get(key);
			if(result != null) return result;
			
			UNIQUEINVOKABLECOUNT++;
			// Get the method proxy and cache this before returning it
			// Get the method proxy and cache this before returning it
			REMMethodProxyFactory proxyFactory = (REMMethodProxyFactory) aBeanTypeProxy.getProxyFactoryRegistry().getMethodProxyFactory();
			result = proxyFactory.getInvokable((IREMBeanTypeProxy)aBeanTypeProxy,invokableName,parmTypes);
			invokables.put(key,result);		
			return result;				
					
		}	
/**
 * @param aBeanTypeProxy = BeanTypeProxy for the method
 * @param methodName = methodName to be looked for
 * @param parmTypes = array of qualified type names for the method arguments, null if no methods
 */ 
	public IMethodProxy getMethodProxy(IBeanTypeProxy aBeanTypeProxy, String methodName, IBeanTypeProxy[] parmTypes){
		if (!registry.isValid())
			return null;
		
		REMMETHODCOUNT++;		
		// The classCache map is keyed by the BeanTypeProxy and holds a further map of cache'd methods
		Map methods;
		Object key;
		synchronized (this) {
			methods = getMethods(aBeanTypeProxy);

			key = null;
			if (parmTypes == null || parmTypes.length == 0) {
				key = methodName;
			} else {
				key = new MethodKeyProxyParms(methodName, parmTypes);
			}

			IMethodProxy result = (IMethodProxy) methods.get(key);
			if (result != null)
				return result;
		}
		
		UNIQUEMETHODCOUNT++;
		// Get the method proxy and cache this before returning it
		// Get the method proxy and cache this before returning it
		REMMethodProxyFactory proxyFactory = (REMMethodProxyFactory) registry.getMethodProxyFactory();
		IMethodProxy result = proxyFactory.getMethodProxy((IREMBeanTypeProxy)aBeanTypeProxy,methodName,parmTypes);
		synchronized (this) {
			// Get it again to make sure it hasn't changed due to a race condition. We don't sync for the getMethodProxy because that goes to the remote vm and could deadlock.
			IMethodProxy mValue = (IMethodProxy) methods.get(key);
			if (mValue != null && mValue != result) {
				registry.releaseProxy(result); // Don't need result now, got it already through a race condition.
				return mValue; // We have a real value now.
			}
			methods.put(key, result);
		}		

		return result;				
	}

	/**
	 * Return the proxy method for the method through the expression. 
	 * @param expression
	 * @param aBeanTypeProxy
	 * @param methodName
	 * @param parmTypes
	 * @return either the IMethodProxy if already resolved or an ExpressionProxy if not yet resolved.
	 * 
	 * @since 1.1.0
	 */
	public IProxyMethod getMethodProxy(IExpression expression, IProxyBeanType aBeanTypeProxy, String methodName, IProxyBeanType[] parmTypes){
		if (!registry.isValid())
			return null;
		
		REMMETHODCOUNT++;	
		Map methods;
		Map epMethods;
		Object key;
		boolean isKey;
		synchronized (this) {
			// The classCache map is keyed by the BeanTypeProxy name and holds a further map of cache'd methods
			methods = getMethods(aBeanTypeProxy);

			if (parmTypes == null || parmTypes.length == 0) {
				key = methodName;
				isKey = false;
			} else {
				key = new MethodKeyProxyParms(methodName, parmTypes);
				isKey = true;
			}

			IProxyMethod result = (IProxyMethod) methods.get(key);
			if (result != null)
				return result;
			
			// See if stored in the expression.
			epMethods = ((REMExpression) expression).getMethods(aBeanTypeProxy);
			result = (IProxyMethod) epMethods.get(key);
			if (result != null)
				return result;
		}
		
		UNIQUEMETHODCOUNT++;
		// Get the method expression proxy and cache this before returning it
		IProxyMethod result = ((Expression) expression).createMethodExpressionProxy(aBeanTypeProxy,methodName,parmTypes);
		epMethods.put(key, result);
		final Object epKey = key;
		final Map rMethods = methods; 
		final Map fepMethods = epMethods;
		final boolean isKeyType = isKey;
		((ExpressionProxy) result).addProxyListener(new ExpressionProxy.ProxyAdapter() {
			public void proxyResolved(ProxyEvent event) {
				synchronized (REMProxyConstants.this) {
					if (rMethods.containsKey(epKey))
						return;	// We already have a true method proxy in there. A race condition occurred.
					
					// Now put this resolved guy into the methods.
					// We don't want the key to contain expression proxies in the final map, so if it is a key type
					// we will turn it into a string type key.
					Object key;
					if (isKeyType) {
						key = ((MethodKeyProxyParms) epKey).toMethodKeyStringParms();	// So that we don't put a ket that contains expression proxy parm types into the main map.
					} else
						key = epKey;
					
					rMethods.put(key, event.getProxy());
				}
			}
			
			public void proxyNotResolved(ExpressionProxy.ProxyEvent event) {
				synchronized (REMProxyConstants.this) {
					fepMethods.remove(epKey);
				}
				}
			
		});
		return result;				
	}

	/**
	 * @param proxy
	 */
	static void methodInvoked(REMMethodProxy proxy) {
	
		if (GATHER_COUNTS) {
			Integer count = (Integer) METHODCOUNTMAP.get(proxy);
			if (count == null) {
				METHODCOUNTMAP.put(proxy, new Integer(1));
			} else {
				METHODCOUNTMAP.put(proxy, new Integer(count.intValue() + 1));
			}
		}
	}

	static void fieldGetInvoked(IBeanProxy proxy) {

		if (GATHER_COUNTS) {
			Integer count = (Integer) FIELDCOUNTMAP.get(proxy);
			if (count == null) {
				FIELDCOUNTMAP.put(proxy, new Integer(1));
			} else {
				FIELDCOUNTMAP.put(proxy, new Integer(count.intValue() + 1));
			} 
		}		
	}

	static void fieldSetInvoked(IBeanProxy proxy, IBeanProxy value) {

		if (GATHER_COUNTS) {
			Integer count = (Integer) FIELDSETCOUNTMAP.get(proxy);
			if (count == null) {
				FIELDSETCOUNTMAP.put(proxy, new Integer(1));
			} else {
				FIELDSETCOUNTMAP.put(proxy, new Integer(count.intValue() + 1));
			} 
		}				
	}

	/**
	 * @param proxy for the BeanType of the field
	 * @param fieldName of the field, e.g. (java.awt.Dimension, width) for the "width" field on Dimension
	 * @return The field proxy that is cache'd for performance
	 */
	public IFieldProxy getFieldProxy(REMAbstractBeanTypeProxy aBeanTypeProxy, String fieldName) {
		if (!registry.isValid())
			return null;
		
		REMFIELDCOUNT++;
		Map fields;
		synchronized (this) {
			// The field map is keyed by the BeanTypeProxy and holds a further map of cache'd fields
			fields = getFields(aBeanTypeProxy);	
				
			// Lookup the cache'd Field proxy
			IFieldProxy result = (IFieldProxy) fields.get(fieldName);
			if (result != null)
				return result;
		}
		
		UNIQUEFIELDCOUNT++;
		IFieldProxy result = (IFieldProxy) REMStandardBeanProxyConstants.getConstants(aBeanTypeProxy.getProxyFactoryRegistry()).getClassGetField().invokeCatchThrowableExceptions(
				aBeanTypeProxy,
				registry.getBeanProxyFactory().createBeanProxyWith(fieldName));	
		synchronized (this) {
			IFieldProxy fValue = (IFieldProxy) fields.get(fieldName);
			if (fValue != null) {
				registry.releaseProxy(result);	// Don't need it now. A race had put another one in.
				return fValue;
			}
			fields.put(fieldName,result);
		}
		return result;				
	}
	
	public IProxyField getFieldProxy(IExpression expression, IProxyBeanType aBeanTypeProxy, final String fieldName){
		if (!registry.isValid())
			return null;
		
		REMFIELDCOUNT++;
		Map fields;
		Map epFields;
		synchronized (this) {
			// The classCache map is keyed by the BeanTypeProxy name and holds a further map of cache'd methods
			fields = getFields(aBeanTypeProxy);	
		
			IProxyField result = (IProxyField) fields.get(fieldName);
			if (result != null)
				return result;
			
			// See if stored in the expression.
			epFields = ((REMExpression) expression).getFields(aBeanTypeProxy);
			result = (IProxyField) epFields.get(fieldName);
			if (result != null)
				return result;			
		}
		
		UNIQUEFIELDCOUNT++;
		// Get the field expression proxy and cache this before returning it
		IProxyField result = ((REMExpression) expression).createFieldExpressionProxy(aBeanTypeProxy, fieldName);
		epFields.put(fieldName, result);
		final Map fpFields = fields;
		final Map fepFields = epFields;
		((ExpressionProxy) result).addProxyListener(new ExpressionProxy.ProxyAdapter() {

			public void proxyResolved(ProxyEvent event) {
				synchronized (REMProxyConstants.this) {
					if (fpFields.containsKey(fieldName))
						return;	// Already set to resolved value by someone else.
					fpFields.put(fieldName, event.getProxy());
				}
			}
			 public void proxyNotResolved(ExpressionProxy.ProxyEvent event) {
				 synchronized (REMProxyConstants.this) {
					 fepFields.remove(fieldName);
				}
			 }
		});
		
		return result;				
	}
}