| gvSIG desktop 1

import org.gvsig.tools.dynobject.DynMethod;

import org.gvsig.tools.dynobject.exception.DynMethodException;

import org.gvsig.tools.dynobject.exception.DynMethodIllegalCodeException;

import org.gvsig.tools.dynobject.exception.DynMethodNotSupportedException;

import org.gvsig.tools.dynobject.exception.IllegalDynMethodException;

import org.gvsig.tools.dynobject.exception.IllegalDynMethodInvocationException;

import org.gvsig.tools.operations.Operation;

	private class MethodInfo {

		int code;

		DynClass dynClass;

		DynMethod dynMethod;

		Class theClass;

		MethodInfo(Class theClass, DynClass dynClass, DynMethod dynMethod, int code) {

			this.code = code;

			this.dynClass = dynClass;

			this.dynMethod = dynMethod;

			this.theClass = theClass;

		}

		String getKey() {

			return DefaultDynObjectManager.getKey(theClass, dynClass, dynMethod);

		}

		void check(Class theClass, int code) throws DynMethodException {

			if( code != this.code) {

				throw new DynMethodIllegalCodeException(dynMethod.getName(),this.code, code);

			}

			if( theClass != null ) {

				if( this.theClass == null ) {

					throw new IllegalDynMethodInvocationException(dynMethod.getName(), theClass);

				}

				if (!this.theClass.isAssignableFrom(theClass)) {

					throw new IllegalDynMethodInvocationException(dynMethod.getName(),theClass);

				}

			}

		}

		void check(DynClass dynClass, int code) throws DynMethodException  {

			if( code != this.code) {

				throw new DynMethodIllegalCodeException(dynMethod.getName(),this.code, code);

			}

			if( dynClass != null ) {

				if( this.dynClass == null ) {

					throw new IllegalDynMethodInvocationException(dynMethod.getName(), dynClass);

				}

				if( dynClass != this.dynClass || !dynClass.getName().equalsIgnoreCase(this.dynClass.getName()) ) {

					throw new IllegalDynMethodInvocationException(dynMethod.getName(), dynClass);

				}

			}

		}

	}

	private Map methodsMap;

	private MethodInfo[] methods;

    static String getKey(Class theClass, DynClass dynClass, DynMethod dynMethod) {

    	return DefaultDynObjectManager.getKey(theClass, dynClass, dynMethod.getName());

    }

    static String getKey(Class theClass, DynClass dynClass, String methodName) {

		if( dynClass == null ) {

			return theClass.getName() + ":" + methodName;

		} else {

			return dynClass.getName() + ":" + methodName;

		}	    	

    }

		this.methodsMap = new HashMap();

		this.methods = null;

	public int registerDynMethod(DynClass dynClass, DynMethod dynMethod) {

		((DefaultDynClass)dynClass).addMethod(dynMethod);

		return registerDynMethod(null, dynClass, dynMethod); 

	}

	public int registerDynMethod(Class theClass, DynMethod dynMethod) {

		return registerDynMethod(theClass, null, dynMethod); 

	}

	int registerDynMethod(Class theClass, DynClass dynClass, DynMethod dynMethod) {

		MethodInfo info = new MethodInfo(theClass, dynClass, dynMethod, 0);

		MethodInfo oldInfo = (MethodInfo) methodsMap.get(info.getKey());

		if (oldInfo != null) {

			// Update the method info

			oldInfo.dynClass = dynClass;

			oldInfo.dynMethod = dynMethod;

			return oldInfo.code;

		}

		if (methods == null) {

			methods = new MethodInfo[1];

			info.code = 0;

		} else {

			Operation[] temp1 = new Operation[methods.length + 1];

			System.arraycopy(methods, 0, temp1, 0, methods.length);

			info.code = methods.length - 1;

		}

		methods[info.code] = info;

		methodsMap.put(info.getKey(), info);

		return info.code;

	}

	public Object invokeDynMethod(Object self, int code, DynObject context) throws DynMethodException{

		try {

			/*

			 * Intentamos ejecutar la operacion, y si peta ya haremos las

			 * comprobaciones oportunas para lanzar la excepcion que toque.

			 *

			 * Asi evitamos codigo de comprobacion para los casos que valla bien

			 * que deberian ser la mayoria.

			 */

			return methods[code].dynMethod.invoke(self, context);

		} catch (RuntimeException e) {

			getDynMethod(self, code);

			throw e;

		} catch (DynMethodException e) {

			getDynMethod(self, code);

			throw e;

		}

	}

	public int getDynMethodCode(DynClass dynClass, String methodName) throws DynMethodException  {

		String key = DefaultDynObjectManager.getKey(null, dynClass, methodName);

		MethodInfo info = (MethodInfo) methodsMap.get(key);

		if( info == null ) {

			throw new IllegalDynMethodException(methodName, dynClass);

		}

		info.check(dynClass, info.code);

		return info.code;

	}

	public int getDynMethodCode(Class theClass, String methodName) throws DynMethodException {

		String key = DefaultDynObjectManager.getKey(theClass, null, methodName);

		MethodInfo info = (MethodInfo) methodsMap.get(key);

		if( info == null ) {

			throw new IllegalDynMethodException(methodName, theClass);

		}

		info.check(theClass, info.code);

		return info.code;

	}

	public DynMethod getDynMethod(int code) throws DynMethodException {

		if (code >= methods.length) {

			throw new DynMethodNotSupportedException(code);

		}

		MethodInfo info = methods[code];

		info.check((Class)null, code);

		return info.dynMethod;

	}

	public DynMethod getDynMethod(Object obj, int code)

			throws DynMethodException {

		return getDynMethod(obj.getClass(), code);

	}

	public DynMethod getDynMethod(Class theClass, int code)

			throws DynMethodException {

		if (code >= methods.length) {

			throw new DynMethodNotSupportedException(code);

		}

		MethodInfo info = methods[code];

		info.check(theClass, code);

		return info.dynMethod;

	}

	public DynMethod getDynMethod(DynClass dynClass, int code)

			throws DynMethodException {

		if (code >= methods.length) {

			throw new DynMethodNotSupportedException(code);

		}

		MethodInfo info = methods[code];

		info.check(dynClass, code);

		return info.dynMethod;

	}

	public DynMethod getDynMethod(DynObject dynObject, int code)

			throws DynMethodException {

		return getDynMethod(dynObject.getDynClass(), code);

	}