public ValueExpressionValueBindingAdapter() 
{

}

 ValueExpressionValueBindingAdapter(ValueBinding binding) 
{
	assert(null != binding);
	this.binding = binding;
}

 public boolean equals(Object other) 
{
    
        if (other == this) {
            return true;
        }
        if (other instanceof ValueExpressionValueBindingAdapter) {
            ValueBinding vb = 
                ((ValueExpressionValueBindingAdapter) other).getWrapped();
            return (binding.equals(vb));
        } else if (other instanceof ValueExpression) {
            FacesContext context = FacesContext.getCurrentInstance();
            ValueExpression otherVE = (ValueExpression) other;
            Class type = binding.getType(context);
            if (type != null) {
                return type.equals(otherVE.getType(context.getELContext()));
            }            
        }
        return false;
}

 public String getDelimiterSyntax() 
{
        // PENDING (visvan) Implementation
        return "";
}

 public Class<?> getExpectedType() 
{
	assert(null != binding);
	Class result = null;
	FacesContext context = FacesContext.getCurrentInstance();
	try {
	    Object value = binding.getValue(context);
	    result = value.getClass();
	}
	catch (Throwable e) {
	    result = null;
	}
	return result;
}

 public String getExpressionString() 
{
	assert(null != binding);
	return binding.getExpressionString();
}

 public Class<?> getType(ELContext context) throws ELException 
{
	assert(null != binding);
	if (context == null) {
	    throw new NullPointerException("ELContext - > null");
    }
	Class result = null;
	FacesContext facesContext = (FacesContext) 
	    context.getContext(FacesContext.class);
	assert(null != facesContext);
	try {
	    result = binding.getType(facesContext);
	}
	catch (Throwable e) {
	    throw new ELException(e);
	}
	return result;
}

 public Object getValue(ELContext context) throws ELException 
{
	assert(null != binding);
	if (context == null) {
	    throw new NullPointerException("ELContext - > null");
    }
	Object result = null;
	FacesContext facesContext = (FacesContext) 
	    context.getContext(FacesContext.class);
	assert(null != facesContext);
	try {
	    result = binding.getValue(facesContext);
	}
	catch (Throwable e) {
	    throw new ELException(e);
	}
	return result;
}

 public ValueBinding getWrapped() 
{
	return binding;
}

 public int hashCode() 
{
	assert(null != binding);
	return binding.hashCode();
}

 public boolean isLiteralText() 
{
	return false;
}

Always return false since we can't possibly know if this is a literal text binding or not.

 public boolean isReadOnly(ELContext context) throws ELException 
{
	assert(null != binding);
	if (context == null) {
	    throw new NullPointerException("ELContext - > null");
    }
	boolean result = false;
	FacesContext facesContext = (FacesContext) 
	    context.getContext(FacesContext.class);
	assert(null != facesContext);
	try {
	    result = binding.isReadOnly(facesContext);
	}
	catch (Throwable e) {
	    throw new ELException(e);
	}
	return result;
}

 public boolean isTransient() 
{
	return tranzient;
}

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

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

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

 public  void setValue(ELContext context,
    Object value) throws ELException 
{
	assert(null != binding);
	if (context == null) {
	    throw new NullPointerException("ELContext - > null");
    }
	FacesContext facesContext = (FacesContext) 
	    context.getContext(FacesContext.class);
	assert(null != facesContext);
	try {
	    binding.setValue(facesContext, value);
	}
	catch (Throwable e) {
	    throw new ELException(e);
	}
}