//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void setValue(Bindings bindings, org.camunda.bpm.engine.impl.javax.el.ELContext context, Object value) throws org.camunda.bpm.engine.impl.javax.el.ELException
public override void setValue(Bindings bindings, ELContext context, object value)
{
if (!lvalue)
{
throw new ELException(LocalMessages.get("error.value.set.rvalue", getStructuralId(bindings)));
}
object @base = prefix.eval(bindings, context);
if (@base == null)
{
throw new PropertyNotFoundException(LocalMessages.get("error.property.base.null", prefix));
}
object property = getProperty(bindings, context);
if (property == null && strict)
{
throw new PropertyNotFoundException(LocalMessages.get("error.property.property.notfound", "null", @base));
}
context.PropertyResolved = false;
context.ELResolver.setValue(context, @base, property, value);
if (!context.PropertyResolved)
{
throw new PropertyNotFoundException(LocalMessages.get("error.property.property.notfound", property, @base));
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public boolean isReadOnly(Bindings bindings, org.camunda.bpm.engine.impl.javax.el.ELContext context) throws org.camunda.bpm.engine.impl.javax.el.ELException
public override bool isReadOnly(Bindings bindings, ELContext context)
{
if (!lvalue)
{
return(true);
}
object @base = prefix.eval(bindings, context);
if (@base == null)
{
throw new PropertyNotFoundException(LocalMessages.get("error.property.base.null", prefix));
}
object property = getProperty(bindings, context);
if (property == null && strict)
{
throw new PropertyNotFoundException(LocalMessages.get("error.property.property.notfound", "null", @base));
}
context.PropertyResolved = false;
bool result = context.ELResolver.isReadOnly(context, @base, property);
if (!context.PropertyResolved)
{
throw new PropertyNotFoundException(LocalMessages.get("error.property.property.notfound", property, @base));
}
return(result);
}
protected internal virtual float?coerceToFloat(object value)
{
if (value == null || "".Equals(value))
{
return(Convert.ToSingle(0));
}
if (value is float?)
{
return((float?)value);
}
if (value is Number)
{
return(Convert.ToSingle(((Number)value).floatValue()));
}
if (value is string)
{
try
{
return(Convert.ToSingle((string)value));
}
catch (System.FormatException)
{
throw new ELException(LocalMessages.get("error.coerce.value", value, typeof(Float)));
}
}
if (value is char?)
{
return(Convert.ToSingle((short)((char?)value).Value));
}
throw new ELException(LocalMessages.get("error.coerce.type", value.GetType(), typeof(Float)));
}
public override object invoke(Bindings bindings, ELContext context, Type returnType, Type[] paramTypes, object[] paramValues)
{
object @base = property.Prefix.eval(bindings, context);
if (@base == null)
{
throw new PropertyNotFoundException(LocalMessages.get("error.property.base.null", property.Prefix));
}
object method = property.getProperty(bindings, context);
if (method == null)
{
throw new PropertyNotFoundException(LocalMessages.get("error.property.method.notfound", "null", @base));
}
string name = bindings.convert(method, typeof(string));
paramValues = @params.eval(bindings, context);
context.PropertyResolved = false;
object result = context.ELResolver.invoke(context, @base, name, paramTypes, paramValues);
if (!context.PropertyResolved)
{
throw new MethodNotFoundException(LocalMessages.get("error.property.method.notfound", name, @base.GetType()));
}
// if (returnType != null && !returnType.isInstance(result)) { // should we check returnType for method invocations?
// throw new MethodNotFoundException(LocalMessages.get("error.property.method.notfound", name, base.getClass()));
// }
return(result);
}
/// <summary>
/// Create a bindings. </summary>
/// <param name="fnMapper"> the function mapper to use </param>
/// <param name="varMapper"> the variable mapper to use </param>
/// <param name="converter"> custom type converter </param>
/// <returns> tree bindings </returns>
public virtual Bindings bind(FunctionMapper fnMapper, VariableMapper varMapper, TypeConverter converter)
{
System.Reflection.MethodInfo[] methods = null;
if (functions.Count > 0)
{
if (fnMapper == null)
{
throw new ELException(LocalMessages.get("error.function.nomapper"));
}
methods = new System.Reflection.MethodInfo[functions.Count];
foreach (FunctionNode node in functions)
{
string image = node.Name;
System.Reflection.MethodInfo method = null;
int colon = image.IndexOf(':');
if (colon < 0)
{
method = fnMapper.resolveFunction("", image);
}
else
{
method = fnMapper.resolveFunction(image.Substring(0, colon), image.Substring(colon + 1));
}
if (method == null)
{
throw new ELException(LocalMessages.get("error.function.notfound", image));
}
if (node.VarArgs && method.VarArgs)
{
if (method.ParameterTypes.length > node.ParamCount + 1)
{
throw new ELException(LocalMessages.get("error.function.params", image));
}
}
else
{
if (method.ParameterTypes.length != node.ParamCount)
{
throw new ELException(LocalMessages.get("error.function.params", image));
}
}
methods[node.Index] = method;
}
}
ValueExpression[] expressions = null;
if (identifiers.Count > 0)
{
expressions = new ValueExpression[identifiers.Count];
foreach (IdentifierNode node in identifiers)
{
ValueExpression expression = null;
if (varMapper != null)
{
expression = varMapper.resolveVariable(node.Name);
}
expressions[node.Index] = expression;
}
}
return(new Bindings(methods, expressions, converter));
}
protected internal virtual sbyte?coerceToByte(object value)
{
if (value == null || "".Equals(value))
{
return(Convert.ToSByte((sbyte)0));
}
if (value is sbyte?)
{
return((sbyte?)value);
}
if (value is Number)
{
return(Convert.ToSByte(((Number)value).byteValue()));
}
if (value is string)
{
try
{
return(Convert.ToSByte((string)value));
}
catch (System.FormatException)
{
throw new ELException(LocalMessages.get("error.coerce.value", value, typeof(Byte)));
}
}
if (value is char?)
{
return(Convert.ToSByte(Convert.ToInt16((short)((char?)value).Value).byteValue()));
}
throw new ELException(LocalMessages.get("error.coerce.type", value.GetType(), typeof(Byte)));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") protected Object coerceToType(Object value, Class type)
protected internal virtual object coerceToType(object value, Type type)
{
if (type == typeof(string))
{
return(coerceToString(value));
}
if (type == typeof(Long) || type == typeof(long))
{
return(coerceToLong(value));
}
if (type == typeof(Double) || type == typeof(double))
{
return(coerceToDouble(value));
}
if (type == typeof(Boolean) || type == typeof(bool))
{
return(coerceToBoolean(value));
}
if (type == typeof(Integer) || type == typeof(int))
{
return(coerceToInteger(value));
}
if (type == typeof(Float) || type == typeof(float))
{
return(coerceToFloat(value));
}
if (type == typeof(Short) || type == typeof(short))
{
return(coerceToShort(value));
}
if (type == typeof(Byte) || type == typeof(sbyte))
{
return(coerceToByte(value));
}
if (type == typeof(Character) || type == typeof(char))
{
return(coerceToCharacter(value));
}
if (type == typeof(decimal))
{
return(coerceToBigDecimal(value));
}
if (type == typeof(BigInteger))
{
return(coerceToBigInteger(value));
}
if (type.BaseType == typeof(Enum))
{
return(coerceToEnum(value, (Type)type));
}
if (value == null || value.GetType() == type || type.IsInstanceOfType(value))
{
return(value);
}
if (value is string)
{
return(coerceStringToType((string)value, type));
}
throw new ELException(LocalMessages.get("error.coerce.type", value.GetType(), type));
}
/// <summary>
/// Create a new method expression.
/// The expression must be an lvalue expression or literal text.
/// The expected return type may be <code>null</code>, meaning "don't care".
/// If it is an lvalue expression, the parameter types must not be <code>null</code>.
/// If it is literal text, the expected return type must not be <code>void</code>. </summary>
/// <param name="store"> used to get the parse tree from. </param>
/// <param name="functions"> the function mapper used to bind functions </param>
/// <param name="variables"> the variable mapper used to bind variables </param>
/// <param name="expr"> the expression string </param>
/// <param name="returnType"> the expected return type (may be <code>null</code>) </param>
/// <param name="paramTypes"> the expected parameter types (must not be <code>null</code> for lvalues) </param>
public TreeMethodExpression(TreeStore store, FunctionMapper functions, VariableMapper variables, TypeConverter converter, string expr, Type returnType, Type[] paramTypes) : base()
{
Tree tree = store.get(expr);
this.builder = store.Builder;
this.bindings = tree.bind(functions, variables, converter);
this.expr = expr;
this.type = returnType;
this.types = paramTypes;
this.node = tree.Root;
this.deferred = tree.Deferred;
if (node.LiteralText)
{
if (returnType == typeof(void))
{
throw new ELException(LocalMessages.get("error.method.literal.void", expr));
}
}
else if (!node.MethodInvocation)
{
if (!node.LeftValue)
{
throw new ELException(LocalMessages.get("error.method.invalid", expr));
}
if (paramTypes == null)
{
throw new ELException(LocalMessages.get("error.method.notypes"));
}
}
}
protected internal virtual decimal coerceToBigDecimal(object value)
{
if (value == null || "".Equals(value))
{
return(decimal.valueOf(0l));
}
if (value is decimal)
{
return((decimal)value);
}
if (value is BigInteger)
{
return(new decimal((BigInteger)value));
}
if (value is Number)
{
return(new decimal(((Number)value).doubleValue()));
}
if (value is string)
{
try
{
return(new decimal((string)value));
}
catch (System.FormatException)
{
throw new ELException(LocalMessages.get("error.coerce.value", value, typeof(decimal)));
}
}
if (value is char?)
{
return(new decimal((short)((char?)value).Value));
}
throw new ELException(LocalMessages.get("error.coerce.type", value.GetType(), typeof(decimal)));
}
public override object invoke(Bindings bindings, ELContext context, Type returnType, Type[] paramTypes, object[] paramValues)
{
object @base = prefix.eval(bindings, context);
if (@base == null)
{
throw new PropertyNotFoundException(LocalMessages.get("error.property.base.null", prefix));
}
object property = getProperty(bindings, context);
if (property == null && strict)
{
throw new PropertyNotFoundException(LocalMessages.get("error.property.method.notfound", "null", @base));
}
string name = bindings.convert(property, typeof(string));
System.Reflection.MethodInfo method = findMethod(name, @base.GetType(), returnType, paramTypes);
try
{
return(method.invoke(@base, paramValues));
}
catch (IllegalAccessException)
{
throw new ELException(LocalMessages.get("error.property.method.access", name, @base.GetType()));
}
catch (System.ArgumentException e)
{
throw new ELException(LocalMessages.get("error.property.method.invocation", name, @base.GetType()), e);
}
catch (InvocationTargetException e)
{
throw new ELException(LocalMessages.get("error.property.method.invocation", name, @base.GetType()), e.InnerException);
}
}
protected internal virtual long?coerceToLong(object value)
{
if (value == null || "".Equals(value))
{
return(Convert.ToInt64(0l));
}
if (value is long?)
{
return((long?)value);
}
if (value is Number)
{
return(Convert.ToInt64(((Number)value).longValue()));
}
if (value is string)
{
try
{
return(Convert.ToInt64((string)value));
}
catch (System.FormatException)
{
throw new ELException(LocalMessages.get("error.coerce.value", value, typeof(Long)));
}
}
if (value is char?)
{
return(Convert.ToInt64((short)((char?)value).Value));
}
throw new ELException(LocalMessages.get("error.coerce.type", value.GetType(), typeof(Long)));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") private static final boolean gt0(TypeConverter converter, Object o1, Object o2)
private static bool gt0(TypeConverter converter, object o1, object o2)
{
Type t1 = o1.GetType();
Type t2 = o2.GetType();
if (t1.IsAssignableFrom(typeof(decimal)) || t2.IsAssignableFrom(typeof(decimal)))
{
return(converter.convert(o1, typeof(decimal)).compareTo(converter.convert(o2, typeof(decimal))) > 0);
}
if (SIMPLE_FLOAT_TYPES.Contains(t1) || SIMPLE_FLOAT_TYPES.Contains(t2))
{
return(converter.convert(o1, typeof(Double)) > converter.convert(o2, typeof(Double)));
}
if (t1.IsAssignableFrom(typeof(BigInteger)) || t2.IsAssignableFrom(typeof(BigInteger)))
{
return(converter.convert(o1, typeof(BigInteger)).compareTo(converter.convert(o2, typeof(BigInteger))) > 0);
}
if (SIMPLE_INTEGER_TYPES.Contains(t1) || SIMPLE_INTEGER_TYPES.Contains(t2))
{
return(converter.convert(o1, typeof(Long)) > converter.convert(o2, typeof(Long)));
}
if (t1 == typeof(string) || t2 == typeof(string))
{
return(converter.convert(o1, typeof(string)).compareTo(converter.convert(o2, typeof(string))) > 0);
}
if (o1 is IComparable)
{
return(((IComparable)o1).CompareTo(o2) > 0);
}
if (o2 is IComparable)
{
return(((IComparable)o2).CompareTo(o1) < 0);
}
throw new ELException(LocalMessages.get("error.compare.types", o1.GetType(), o2.GetType()));
}
/// <summary>
/// Wrap an object into a value expression. </summary>
/// <param name="converter"> type converter </param>
/// <param name="object"> the object to wrap </param>
/// <param name="type"> the expected type this object will be coerced in <seealso cref="getValue(ELContext)"/>. </param>
public ObjectValueExpression(TypeConverter converter, object @object, Type type) : base()
{
this.converter = converter;
this.@object = @object;
this.type = type;
if (type == null)
{
throw new System.NullReferenceException(LocalMessages.get("error.value.notype"));
}
}
public static Number neg(TypeConverter converter, object value)
{
if (value == null)
{
return(LONG_ZERO);
}
if (value is decimal)
{
return(-((decimal)value));
}
if (value is BigInteger)
{
return(-((BigInteger)value));
}
if (value is double?)
{
return(Convert.ToDouble(-((double?)value).Value));
}
if (value is float?)
{
return(Convert.ToSingle(-((float?)value).Value));
}
if (value is string)
{
if (isDotEe((string)value))
{
return(Convert.ToDouble(-converter.convert(value, typeof(Double)).doubleValue()));
}
return(Convert.ToInt64(-converter.convert(value, typeof(Long)).longValue()));
}
if (value is long?)
{
return(Convert.ToInt64(-((long?)value).Value));
}
if (value is int?)
{
return(Convert.ToInt32(-((int?)value).Value));
}
if (value is short?)
{
return(Convert.ToInt16((short)-((short?)value).Value));
}
if (value is sbyte?)
{
return(Convert.ToSByte((sbyte)-((sbyte?)value).Value));
}
throw new ELException(LocalMessages.get("error.negate", value.GetType()));
}
public override object eval(Bindings bindings, ELContext context)
{
System.Reflection.MethodInfo method = bindings.getFunction(index);
try
{
return(invoke(bindings, context, null, method));
}
catch (IllegalAccessException e)
{
throw new ELException(LocalMessages.get("error.function.access", name), e);
}
catch (InvocationTargetException e)
{
throw new ELException(LocalMessages.get("error.function.invocation", name), e.InnerException);
}
}
/// <summary>
/// Create a new value expression. </summary>
/// <param name="store"> used to get the parse tree from. </param>
/// <param name="functions"> the function mapper used to bind functions </param>
/// <param name="variables"> the variable mapper used to bind variables </param>
/// <param name="expr"> the expression string </param>
/// <param name="type"> the expected type (may be <code>null</code>) </param>
public TreeValueExpression(TreeStore store, FunctionMapper functions, VariableMapper variables, TypeConverter converter, string expr, Type type) : base()
{
Tree tree = store.get(expr);
this.builder = store.Builder;
this.bindings = tree.bind(functions, variables, converter);
this.expr = expr;
this.type = type;
this.node = tree.Root;
this.deferred = tree.Deferred;
if (type == null)
{
throw new System.NullReferenceException(LocalMessages.get("error.value.notype"));
}
}
protected internal virtual bool?coerceToBoolean(object value)
{
if (value == null || "".Equals(value))
{
return(false);
}
if (value is bool?)
{
return((bool?)value);
}
if (value is string)
{
return(Convert.ToBoolean((string)value));
}
throw new ELException(LocalMessages.get("error.coerce.type", value.GetType(), typeof(Boolean)));
}
public override void setValue(Bindings bindings, ELContext context, object value)
{
ValueExpression expression = bindings.getVariable(index);
if (expression != null)
{
expression.setValue(context, value);
return;
}
context.PropertyResolved = false;
context.ELResolver.setValue(context, null, name, value);
if (!context.PropertyResolved)
{
throw new PropertyNotFoundException(LocalMessages.get("error.identifier.property.notfound", name));
}
}
protected internal virtual System.Reflection.MethodInfo findMethod(string name, Type clazz, Type returnType, Type[] paramTypes)
{
System.Reflection.MethodInfo method = null;
try
{
method = clazz.GetMethod(name, paramTypes);
}
catch (NoSuchMethodException)
{
throw new MethodNotFoundException(LocalMessages.get("error.property.method.notfound", name, clazz));
}
if (returnType != null && !returnType.IsAssignableFrom(method.ReturnType))
{
throw new MethodNotFoundException(LocalMessages.get("error.property.method.notfound", name, clazz));
}
return(method);
}
public override object eval(Bindings bindings, ELContext context)
{
ValueExpression expression = bindings.getVariable(index);
if (expression != null)
{
return(expression.getValue(context));
}
context.PropertyResolved = false;
object result = context.ELResolver.getValue(context, null, name);
if (!context.PropertyResolved)
{
throw new PropertyNotFoundException(LocalMessages.get("error.identifier.property.notfound", name));
}
return(result);
}
public override MethodInfo getMethodInfo(Bindings bindings, ELContext context, Type returnType, Type[] paramTypes)
{
object @base = prefix.eval(bindings, context);
if (@base == null)
{
throw new PropertyNotFoundException(LocalMessages.get("error.property.base.null", prefix));
}
object property = getProperty(bindings, context);
if (property == null && strict)
{
throw new PropertyNotFoundException(LocalMessages.get("error.property.method.notfound", "null", @base));
}
string name = bindings.convert(property, typeof(string));
System.Reflection.MethodInfo method = findMethod(name, @base.GetType(), returnType, paramTypes);
return(new MethodInfo(method.Name, method.ReturnType, paramTypes));
}
public override object invoke(Bindings bindings, ELContext context, Type returnType, Type[] paramTypes, object[] @params)
{
System.Reflection.MethodInfo method = getMethod(bindings, context, returnType, paramTypes);
try
{
return(method.invoke(null, @params));
}
catch (IllegalAccessException)
{
throw new ELException(LocalMessages.get("error.identifier.method.access", name));
}
catch (System.ArgumentException e)
{
throw new ELException(LocalMessages.get("error.identifier.method.invocation", name, e));
}
catch (InvocationTargetException e)
{
throw new ELException(LocalMessages.get("error.identifier.method.invocation", name, e.InnerException));
}
}
protected internal virtual char?coerceToCharacter(object value)
{
if (value == null || "".Equals(value))
{
return(Convert.ToChar((char)0));
}
if (value is char?)
{
return((char?)value);
}
if (value is Number)
{
return(Convert.ToChar((char)((Number)value).shortValue()));
}
if (value is string)
{
return(Convert.ToChar(((string)value)[0]));
}
throw new ELException(LocalMessages.get("error.coerce.type", value.GetType(), typeof(Character)));
}
protected internal virtual object coerceStringToType(string value, Type type)
{
PropertyEditor editor = PropertyEditorManager.findEditor(type);
if (editor == null)
{
if ("".Equals(value))
{
return(null);
}
throw new ELException(LocalMessages.get("error.coerce.type", typeof(string), type));
}
else
{
if ("".Equals(value))
{
try
{
editor.AsText = value;
}
catch (System.ArgumentException)
{
return(null);
}
}
else
{
try
{
editor.AsText = value;
}
catch (System.ArgumentException)
{
throw new ELException(LocalMessages.get("error.coerce.value", value, type));
}
}
return(editor.Value);
}
}
protected internal virtual System.Reflection.MethodInfo getMethod(Bindings bindings, ELContext context, Type returnType, Type[] paramTypes)
{
object value = eval(bindings, context);
if (value == null)
{
throw new MethodNotFoundException(LocalMessages.get("error.identifier.method.notfound", name));
}
if (value is System.Reflection.MethodInfo)
{
System.Reflection.MethodInfo method = (System.Reflection.MethodInfo)value;
if (returnType != null && !returnType.IsAssignableFrom(method.ReturnType))
{
throw new MethodNotFoundException(LocalMessages.get("error.identifier.method.notfound", name));
}
if (!Arrays.Equals(method.ParameterTypes, paramTypes))
{
throw new MethodNotFoundException(LocalMessages.get("error.identifier.method.notfound", name));
}
return(method);
}
throw new MethodNotFoundException(LocalMessages.get("error.identifier.method.notamethod", name, value.GetType()));
}
public override object eval(Bindings bindings, ELContext context)
{
object @base = prefix.eval(bindings, context);
if (@base == null)
{
return(null);
}
object property = getProperty(bindings, context);
if (property == null && strict)
{
return(null);
}
context.PropertyResolved = false;
object result = context.ELResolver.getValue(context, @base, property);
if (!context.PropertyResolved)
{
throw new PropertyNotFoundException(LocalMessages.get("error.property.property.notfound", property, @base));
}
return(result);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") protected <T extends Enum<T>> T coerceToEnum(Object value, Class<T> type)
protected internal virtual T coerceToEnum <T>(object value, Type type) where T : Enum <T>
{
type = typeof(T);
if (value == null || "".Equals(value))
{
return(null);
}
if (type.IsInstanceOfType(value))
{
return((T)value);
}
if (value is string)
{
try
{
return(Enum.valueOf(type, (string)value));
}
catch (System.ArgumentException)
{
throw new ELException(LocalMessages.get("error.coerce.value", value, type));
}
}
throw new ELException(LocalMessages.get("error.coerce.type", value.GetType(), type));
}
public override void setValue(Bindings bindings, ELContext context, object value)
{
throw new ELException(LocalMessages.get("error.value.set.rvalue", getStructuralId(bindings)));
}
public sealed override object invoke(Bindings bindings, ELContext context, Type returnType, Type[] paramTypes, object[] paramValues)
{
throw new ELException(LocalMessages.get("error.method.invalid", getStructuralId(bindings)));
}
public TreeBuilderException(string expression, int position, string encountered, string expected, string message) : base(LocalMessages.get("error.build", expression, message))
{
this.expression = expression;
this.position = position;
this.encountered = encountered;
this.expected = expected;
}
