public AstFunction(string name, int index, AstParameters @params, bool varargs)
{
this.name = name;
this.index = index;
this.@params = @params;
this.varargs = varargs;
}
protected internal AstFunction function(string name, AstParameters @params)
{
if (functions.Count == 0)
{
functions = new List <FunctionNode>(4);
}
AstFunction function = createAstFunction(name, functions.Count, @params);
functions.Add(function);
return(function);
}
public AstMethod(AstProperty property, AstParameters @params)
{
this.property = property;
this.@params = @params;
}
/// <summary>
/// Invoke method. </summary>
/// <param name="bindings"> </param>
/// <param name="context"> </param>
/// <param name="base"> </param>
/// <param name="method"> </param>
/// <returns> method result </returns>
/// <exception cref="InvocationTargetException"> </exception>
/// <exception cref="IllegalAccessException"> </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: protected Object invoke(Bindings bindings, org.camunda.bpm.engine.impl.javax.el.ELContext context, Object super, Method method) throws InvocationTargetException, IllegalAccessException
protected internal virtual object invoke(Bindings bindings, ELContext context, object @base, System.Reflection.MethodInfo method)
{
Type[] types = method.ParameterTypes;
object[] @params = null;
if (types.Length > 0)
{
@params = new object[types.Length];
if (varargs && method.VarArgs)
{
for (int i = 0; i < @params.Length - 1; i++)
{
object param = getParam(i).eval(bindings, context);
if (param != null || types[i].IsPrimitive)
{
@params[i] = bindings.convert(param, types[i]);
}
}
int varargIndex = types.Length - 1;
Type varargType = types[varargIndex].GetElementType();
int length = ParamCount - varargIndex;
object array = null;
if (length == 1)
{ // special: eventually use argument as is
object param = getParam(varargIndex).eval(bindings, context);
if (param != null && param.GetType().IsArray)
{
if (types[varargIndex].IsInstanceOfType(param))
{
array = param;
}
else
{ // coerce array elements
length = Array.getLength(param);
array = Array.CreateInstance(varargType, length);
for (int i = 0; i < length; i++)
{
object elem = Array.get(param, i);
if (elem != null || varargType.IsPrimitive)
{
((Array)array).SetValue(bindings.convert(elem, varargType), i);
}
}
}
}
else
{ // single element array
array = Array.CreateInstance(varargType, 1);
if (param != null || varargType.IsPrimitive)
{
((Array)array).SetValue(bindings.convert(param, varargType), 0);
}
}
}
else
{
array = Array.CreateInstance(varargType, length);
for (int i = 0; i < length; i++)
{
object param = getParam(varargIndex + i).eval(bindings, context);
if (param != null || varargType.IsPrimitive)
{
((Array)array).SetValue(bindings.convert(param, varargType), i);
}
}
}
@params[varargIndex] = array;
}
else
{
for (int i = 0; i < @params.Length; i++)
{
object param = getParam(i).eval(bindings, context);
if (param != null || types[i].IsPrimitive)
{
@params[i] = bindings.convert(param, types[i]);
}
}
}
}
return(method.invoke(@base, @params));
}
public AstFunction(string name, int index, AstParameters @params) : this(name, index, @params, false)
{
}
protected internal virtual AstMethod createAstMethod(AstProperty property, AstParameters @params)
{
return(new AstMethod(property, @params));
}
protected internal virtual AstFunction createAstFunction(string name, int index, AstParameters @params)
{
return(new AstFunction(name, index, @params, context.isEnabled(Feature.VARARGS)));
}
