public MethodBindingValueChangeListener() 
{

}

 public MethodBindingValueChangeListener(MethodBinding methodBinding) 
{
        super();
        this.methodBinding = methodBinding;
}

Construct a ValueChangeListener that contains a MethodBinding .

 public MethodBinding getWrapped() 
{
	return methodBinding;
}

 public boolean isTransient() 
{
	return tranzient;
}

 public  void processValueChange(ValueChangeEvent actionEvent) throws AbortProcessingException 
{
                         
        if (actionEvent == null) {
            throw new NullPointerException();
        }
        try {
            FacesContext context = FacesContext.getCurrentInstance();
            methodBinding.invoke(context, new Object[] {actionEvent});
        } 
	catch (EvaluationException ee) {
	    Throwable cause = 
		this.getExpectedCause(AbortProcessingException.class, ee);
	    if (cause instanceof AbortProcessingException) {
		throw  ((AbortProcessingException) cause);
	    }
	    if (cause instanceof RuntimeException) {
		throw ((RuntimeException) cause);
	    }
	    throw new IllegalStateException(ee);
        }
}

 public  void restoreState(FacesContext context,
    Object state) 
{
        if (context == null) {
            throw new NullPointerException();
        }
	// if we have state
	if (null == state) {
	    return;
	}
	if (!(state instanceof MethodBinding)) {
	    Object [] stateStruct = (Object []) state;
	    Object savedState = stateStruct[0];
	    String className = stateStruct[1].toString();
	    MethodBinding result = null;
	    Class toRestoreClass;
	    if (null != className) {
		try {
		    toRestoreClass = loadClass(className, this);
		}
		catch (ClassNotFoundException e) {
		    throw new IllegalStateException(e);
		}
		if (null != toRestoreClass) {
		    try {
			result = 
			    (MethodBinding) toRestoreClass.newInstance();
		    }
		    catch (InstantiationException e) {
			throw new IllegalStateException(e);
		    }
		    catch (IllegalAccessException a) {
			throw new IllegalStateException(a);
		    }
		}
		if (null != result && null != savedState) {
		    // don't need to check transient, since that was
		    // done on the saving side.
		    ((StateHolder)result).restoreState(context, savedState);
		}
		methodBinding = result;
	    }
	}
	else {
	    methodBinding = (MethodBinding) state;
	}
}

 public Object saveState(FacesContext context) 
{
        if (context == null) {
            throw new NullPointerException();
        }
	Object result = null;
	if (!tranzient) {
	    if (methodBinding instanceof StateHolder) {
		Object [] stateStruct = new Object[2];
		// save the actual state of our wrapped methodBinding
		stateStruct[0] = ((StateHolder)methodBinding).saveState(context);
		// save the class name of the methodBinding impl
		stateStruct[1] = methodBinding.getClass().getName();
		result = stateStruct;
	    }
	    else {
		result = methodBinding;
	    }
	}
	return result;
}

 public  void setTransient(boolean newTransientValue) 
{
	tranzient = newTransientValue;
}