//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.boris.expr.Expr evaluate(org.boris.expr.IEvaluationContext paramIEvaluationContext, org.boris.expr.Expr[] paramArrayOfExpr) throws org.boris.expr.ExprException
public virtual Expr evaluate(IEvaluationContext paramIEvaluationContext, Expr[] paramArrayOfExpr)
{
assertMinArgCount(paramArrayOfExpr, 2);
ExprArray exprArray1 = asArray(paramIEvaluationContext, paramArrayOfExpr[0], true);
int?[] arrayOfInteger = new int?[paramArrayOfExpr.Length - 1];
for (sbyte b1 = 1; b1 < paramArrayOfExpr.Length; b1++)
{
arrayOfInteger[b1 - true] = Convert.ToInt32(paramIEvaluationContext, paramArrayOfExpr[b1], true);
}
ExprArray exprArray2 = new ExprArray(arrayOfInteger.Length, exprArray1.columns());
for (sbyte b2 = 0; b2 < exprArray1.columns(); b2++)
{
for (sbyte b = 0; b < arrayOfInteger.Length; b++)
{
int i = arrayOfInteger[b].Value - 1;
if (i < 0 || i >= exprArray1.rows())
{
ExprInteger exprInteger = new ExprInteger(1);
exprArray2.set(b, b2, exprInteger);
}
else
{
Expr expr = exprArray1.get(i, b2);
exprArray2.set(b, b2, expr);
}
}
}
return(exprArray2);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.boris.expr.Expr evaluate(org.boris.expr.IEvaluationContext paramIEvaluationContext, org.boris.expr.Expr[] paramArrayOfExpr) throws org.boris.expr.ExprException
public virtual Expr evaluate(IEvaluationContext paramIEvaluationContext, Expr[] paramArrayOfExpr)
{
assertMinArgCount(paramArrayOfExpr, 2);
ExprArray exprArray1 = asArray(paramIEvaluationContext, paramArrayOfExpr[0], true);
int? integer1;
int? integer2 = (integer2 = (integer1 = Convert.ToInt32(paramArrayOfExpr.Length - 1)).valueOf(exprArray1.rows() * exprArray1.columns() / integer1.Value)).valueOf(integer2.Value + 1);
ExprArray exprArray2 = new ExprArray(integer2.Value, integer1.Value);
try
{
sbyte b;
for (b = 0; b < integer1.Value; b++)
{
exprArray2.set(0, b, paramArrayOfExpr[b + true]);
}
for (b = 1; b < integer2.Value; b++)
{
for (sbyte b1 = 0; b1 < integer1.Value; b1++)
{
if (b - 1 < exprArray1.rows() && b1 < exprArray1.columns())
{
Expr expr = exprArray1.get(b - 1, b1);
exprArray2.set(b, b1, expr);
}
}
}
}
catch (Exception exception)
{
Console.WriteLine(exception.ToString());
Console.Write(exception.StackTrace);
}
return(exprArray2);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.boris.expr.Expr evaluate(org.boris.expr.IEvaluationContext paramIEvaluationContext, org.boris.expr.Expr[] paramArrayOfExpr) throws org.boris.expr.ExprException
public virtual Expr evaluate(IEvaluationContext paramIEvaluationContext, Expr[] paramArrayOfExpr)
{
assertMinArgCount(paramArrayOfExpr, 2);
assertMaxArgCount(paramArrayOfExpr, 2);
ExprArray exprArray = asArray(paramIEvaluationContext, paramArrayOfExpr[0], true);
double d = asDouble(paramIEvaluationContext, paramArrayOfExpr[1], true);
int i = asInteger(paramIEvaluationContext, paramArrayOfExpr[1], true);
int j = exprArray.rows();
int k = exprArray.columns();
for (sbyte b = 0; b < j; b++)
{
for (sbyte b1 = 0; b1 < k; b1++)
{
Expr expr = exprArray.get(b, b1);
if (expr is ExprDouble)
{
exprArray.set(b, b1, new ExprDouble(Math.Abs(((ExprDouble)expr).doubleValue()) * d));
}
else if (expr is ExprInteger)
{
exprArray.set(b, b1, new ExprInteger(Math.Abs(((ExprInteger)expr).intValue()) * i));
}
}
}
return(exprArray);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.boris.expr.Expr evaluate(org.boris.expr.IEvaluationContext paramIEvaluationContext, org.boris.expr.Expr[] paramArrayOfExpr) throws org.boris.expr.ExprException
public virtual Expr evaluate(IEvaluationContext paramIEvaluationContext, Expr[] paramArrayOfExpr)
{
assertArgCount(paramArrayOfExpr, 0);
ExprArray exprArray = new ExprArray(1, 1);
exprArray.set(0, 0, new ExprInteger(0));
if (!(paramIEvaluationContext is ExprAbstractEvaluationContext))
{
return(exprArray);
}
System.Collections.IList list = ((ExprAbstractEvaluationContext)paramIEvaluationContext).SelectedBoqItemIds;
try
{
if (list.Count == 0)
{
return(exprArray);
}
ExprArray exprArray1 = new ExprArray(list.Count, 1);
list.Sort();
for (sbyte b = 0; b < list.Count; b++)
{
exprArray1.set(b, 0, new ExprInteger(((long?)list[b]).Value));
}
return(exprArray1);
}
catch (Exception)
{
return(exprArray);
}
}
private void setArrayValue(ExprArray paramExprArray, object paramObject, int paramInt1, int paramInt2)
{
if (paramObject == null)
{
paramExprArray.set(paramInt1, paramInt2, new ExprString("-"));
}
else if (paramObject is decimal)
{
paramExprArray.set(paramInt1, paramInt2, new ExprDouble(((decimal)paramObject).doubleValue()));
}
else if (paramObject is BigInteger)
{
paramExprArray.set(paramInt1, paramInt2, new ExprInteger(((BigInteger)paramObject).intValue()));
}
else if (paramObject is string)
{
paramExprArray.set(paramInt1, paramInt2, new ExprString(paramObject.ToString()));
}
else if (paramObject is bool?)
{
paramExprArray.set(paramInt1, paramInt2, new ExprBoolean(((bool?)paramObject).Value));
}
else if (paramObject is long?)
{
paramExprArray.set(paramInt1, paramInt2, new ExprInteger(((long?)paramObject).Value));
}
else if (paramObject is int?)
{
paramExprArray.set(paramInt1, paramInt2, new ExprInteger(((int?)paramObject).Value));
}
else if (paramObject is Number)
{
paramExprArray.set(paramInt1, paramInt2, new ExprDouble(((Number)paramObject).doubleValue()));
}
else if (paramObject is Date)
{
paramExprArray.set(paramInt1, paramInt2, new ExprDouble(ExcelDate.toExcelDate(((Date)paramObject).Time)));
}
else
{
paramExprArray.set(paramInt1, paramInt2, new ExprString(paramObject.ToString()));
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public static org.boris.expr.ExprArray toCalculatedEpxrArray(org.boris.expr.IEvaluationContext paramIEvaluationContext, org.boris.expr.ExprArray paramExprArray) throws org.boris.expr.ExprException
public static ExprArray toCalculatedEpxrArray(IEvaluationContext paramIEvaluationContext, ExprArray paramExprArray)
{
ExprArray exprArray = new ExprArray(paramExprArray.rows(), paramExprArray.columns());
for (sbyte b = 0; b < paramExprArray.rows(); b++)
{
for (sbyte b1 = 0; b1 < paramExprArray.columns(); b1++)
{
Expr expr = paramExprArray.get(b, b1);
if (expr is ExprEvaluatable)
{
expr = ((ExprEvaluatable)expr).evaluate(paramIEvaluationContext);
}
exprArray.set(b, b1, expr);
}
}
return(exprArray);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.boris.expr.Expr evaluate(org.boris.expr.IEvaluationContext paramIEvaluationContext, org.boris.expr.Expr[] paramArrayOfExpr) throws org.boris.expr.ExprException
public virtual Expr evaluate(IEvaluationContext paramIEvaluationContext, Expr[] paramArrayOfExpr)
{
assertMinArgCount(paramArrayOfExpr, 1);
int?integer1 = Convert.ToInt32(asInteger(paramIEvaluationContext, paramArrayOfExpr[0], true));
paramArrayOfExpr = extractArgs(paramIEvaluationContext, (Expr[])Arrays.copyOfRange(paramArrayOfExpr, 1, paramArrayOfExpr.Length));
int? integer2 = Convert.ToInt32(paramArrayOfExpr.Length / integer1.Value);
ExprArray exprArray = new ExprArray(integer2.Value, integer1.Value);
sbyte b1 = 0;
for (sbyte b2 = 0; b2 < integer2.Value; b2++)
{
for (sbyte b = 0; b < integer1.Value; b++)
{
exprArray.set(b2, b, paramArrayOfExpr[b1++]);
}
}
return(exprArray);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.boris.expr.Expr evaluate(org.boris.expr.IEvaluationContext paramIEvaluationContext, org.boris.expr.Expr[] paramArrayOfExpr) throws org.boris.expr.ExprException
public virtual Expr evaluate(IEvaluationContext paramIEvaluationContext, Expr[] paramArrayOfExpr)
{
assertArgCount(paramArrayOfExpr, 10);
ExprArray exprArray1 = null;
Expr expr1 = evalArg(paramIEvaluationContext, paramArrayOfExpr[0]);
Expr expr2 = evalArg(paramIEvaluationContext, paramArrayOfExpr[1]);
Expr expr3 = evalArg(paramIEvaluationContext, paramArrayOfExpr[2]);
Expr expr4 = evalArg(paramIEvaluationContext, paramArrayOfExpr[3]);
Expr expr5 = evalArg(paramIEvaluationContext, paramArrayOfExpr[4]);
Expr expr6 = evalArg(paramIEvaluationContext, paramArrayOfExpr[5]);
Expr expr7 = evalArg(paramIEvaluationContext, paramArrayOfExpr[6]);
Expr expr8 = evalArg(paramIEvaluationContext, paramArrayOfExpr[7]);
Expr expr9 = evalArg(paramIEvaluationContext, paramArrayOfExpr[8]);
Expr expr10 = evalArg(paramIEvaluationContext, paramArrayOfExpr[9]);
ExprArray exprArray2 = asArray(paramIEvaluationContext, expr1, false);
string str = asString(paramIEvaluationContext, expr2, false);
int i = asInteger(paramIEvaluationContext, expr3, false);
double d1 = asDouble(paramIEvaluationContext, expr4, false);
int j = asInteger(paramIEvaluationContext, expr5, false);
int k = asInteger(paramIEvaluationContext, expr6, false);
double d2 = asDouble(paramIEvaluationContext, expr7, false);
int m = asInteger(paramIEvaluationContext, expr8, false);
int n = asInteger(paramIEvaluationContext, expr9, false);
int i1 = asInteger(paramIEvaluationContext, expr10, false);
if (exprArray2 is DummyExprArray)
{
return(new ExprArray(0, 0));
}
if (i <= 0)
{
throw new ExprException("Column to search text (3rd argument) cannot be less than or equal to zero.");
}
if (i > exprArray2.length())
{
throw new ExprException("Column to search text (3rd argument) is greater than the array lenght.");
}
if (j <= 0)
{
throw new ExprException("Begin column index in range 1 (5th argument) cannot be less than or equal to zero.");
}
if (j > exprArray2.length())
{
throw new ExprException("Begin column index in range 1 (5th argument) is greater than the array lenght.");
}
if (k <= 0)
{
throw new ExprException("End column index in range 1 (6th argument) cannot be less than or equal to zero.");
}
if (k > exprArray2.length())
{
throw new ExprException("End column index in range 1 (6th argument) is greater than the array lenght.");
}
if (m < 0)
{
throw new ExprException("Begin column index in range 2 (8th argument) cannot be less than zero.");
}
if (m > exprArray2.length())
{
throw new ExprException("Begin column index in range 2 (8th argument) is greater than the array lenght.");
}
if (n < 0)
{
throw new ExprException("End column index in range 2 (9th argument) cannot be less than zero.");
}
if (n > exprArray2.length())
{
throw new ExprException("End column index in range 2 (9th argument) is greater than the array lenght.");
}
if (i1 <= 0)
{
throw new ExprException("Column index to return values (10th argument) cannot be less than or equal to zero.");
}
if (i1 > exprArray2.length())
{
throw new ExprException("Column index to return values (10th argument) is greater than the array lenght.");
}
List <object> arrayList = new List <object>();
sbyte b;
for (b = 0; b < exprArray2.rows(); b++)
{
string str1 = asString(paramIEvaluationContext, exprArray2.get(b, i - 1), false);
double d3 = asDouble(paramIEvaluationContext, exprArray2.get(b, j - 1), false);
double d4 = asDouble(paramIEvaluationContext, exprArray2.get(b, k - 1), false);
if (m == 0 || n == 0)
{
if (str.Equals(str1, StringComparison.OrdinalIgnoreCase) && d1 >= d3 && d1 <= d4)
{
string str2 = asString(paramIEvaluationContext, exprArray2.get(b, i1 - 1), false);
arrayList.Add(str2);
}
}
else if (m > 0 && n > 0)
{
double d5 = asDouble(paramIEvaluationContext, exprArray2.get(b, m - 1), false);
double d6 = asDouble(paramIEvaluationContext, exprArray2.get(b, n - 1), false);
if (str.Equals(str1, StringComparison.OrdinalIgnoreCase) && d1 >= d3 && d1 <= d4 && d2 >= d5 && d2 <= d6)
{
string str2 = asString(paramIEvaluationContext, exprArray2.get(b, i1 - 1), false);
arrayList.Add(str2);
}
}
}
if (arrayList.Count == 0)
{
exprArray1 = new ExprArray(0, 1);
}
else
{
exprArray1 = new ExprArray(arrayList.Count, 1);
for (b = 0; b < arrayList.Count; b++)
{
exprArray1.set(b, 0, new ExprString((string)arrayList[b]));
}
}
return(exprArray1);
}
private void setArrayValue(ExprArray paramExprArray, object paramObject, int paramInt1, int paramInt2)
{
if (paramObject == null)
{
paramExprArray.set(paramInt1, paramInt2, new ExprString("-"));
}
else if (paramObject is HqlResultValue)
{
HqlResultValue hqlResultValue = (HqlResultValue)paramObject;
if (!string.ReferenceEquals(hqlResultValue.StringValue, null))
{
paramExprArray.set(paramInt1, paramInt2, new ExprString(hqlResultValue.StringValue));
}
else if (hqlResultValue.DecimalValue != null)
{
paramExprArray.set(paramInt1, paramInt2, new ExprDouble(hqlResultValue.DecimalValue.doubleValue()));
}
else if (hqlResultValue.LongValue != null)
{
paramExprArray.set(paramInt1, paramInt2, new ExprInteger(hqlResultValue.LongValue.Value));
}
else if (hqlResultValue.BooleanValue != null)
{
paramExprArray.set(paramInt1, paramInt2, new ExprBoolean(hqlResultValue.BooleanValue.Value));
}
else if (hqlResultValue.DateValue != null)
{
paramExprArray.set(paramInt1, paramInt2, new ExprDouble(ExcelDate.toExcelDate(hqlResultValue.DateValue.Ticks)));
}
}
else if (paramObject is decimal)
{
paramExprArray.set(paramInt1, paramInt2, new ExprDouble(((decimal)paramObject).doubleValue()));
}
else if (paramObject is string)
{
paramExprArray.set(paramInt1, paramInt2, new ExprString(paramObject.ToString()));
}
else if (paramObject is bool?)
{
paramExprArray.set(paramInt1, paramInt2, new ExprBoolean(((bool?)paramObject).Value));
}
else if (paramObject is long?)
{
paramExprArray.set(paramInt1, paramInt2, new ExprInteger(((long?)paramObject).Value));
}
else if (paramObject is int?)
{
paramExprArray.set(paramInt1, paramInt2, new ExprInteger(((int?)paramObject).Value));
}
else if (paramObject is double?)
{
paramExprArray.set(paramInt1, paramInt2, new ExprDouble(((double?)paramObject).Value));
}
else if (paramObject is Number)
{
paramExprArray.set(paramInt1, paramInt2, new ExprDouble(((Number)paramObject).doubleValue()));
}
else if (paramObject is Date)
{
paramExprArray.set(paramInt1, paramInt2, new ExprDouble(ExcelDate.toExcelDate(((Date)paramObject).Time)));
}
else if (paramObject is Clob)
{
Clob clob = (Clob)paramObject;
paramExprArray.set(paramInt1, paramInt2, new ExprString(StringUtils.clobToString((Clob)paramObject)));
}
else
{
paramExprArray.set(paramInt1, paramInt2, new ExprString(paramObject.ToString()));
}
}
public static Expr toExprArray(NativeArray paramNativeArray)
{
List <object> arrayList = new List <object>();
int i = 1;
bool @bool = false;
foreach (object @object in paramNativeArray.Ids)
{
int j = ((int?)@object).Value;
@object = paramNativeArray.get(j, null);
if (@object is NativeArray)
{
@bool = true;
List <object> arrayList1 = new List <object>();
foreach (object object1 in ((NativeArray)@object).Ids)
{
int k = ((int?)object1).Value;
object1 = ((NativeArray)@object).get(k, null);
arrayList1.Add(object1);
}
if (i == 1 && arrayList1.Count != 0)
{
i = arrayList1.Count;
}
arrayList.Add(arrayList1);
}
else
{
arrayList.Add(@object);
}
}
ExprArray exprArray = new ExprArray(arrayList.Count, i);
if (!@bool)
{
for (sbyte b = 0; b < arrayList.Count; b++)
{
object @object = arrayList[b];
ExprString exprString = null;
if (@object is double?)
{
exprString = new ExprDouble(((double?)@object).Value);
}
else if (@object is int?)
{
ExprInteger exprInteger = new ExprInteger(((int?)@object).Value);
}
else if (StringUtils.isDecimal(@object.ToString()))
{
exprString = new ExprDouble((Convert.ToDouble(@object.ToString())));
}
else if (@object is NativeJavaObject)
{
object object1 = ((NativeJavaObject)@object).getDefaultValue(typeof(string));
if (StringUtils.isDecimal(object1.ToString()))
{
exprString = new ExprDouble((Convert.ToDouble(object1.ToString())));
}
else
{
ExprString exprString1 = new ExprString(object1.ToString());
}
}
else
{
exprString = new ExprString(@object.ToString());
}
exprArray.set(b, exprString);
}
}
else
{
for (sbyte b = 0; b < arrayList.Count; b++)
{
System.Collections.IList list = (System.Collections.IList)arrayList[b];
for (sbyte b1 = 0; b1 < list.Count; b1++)
{
object @object = list[b1];
ExprString exprString = null;
if (@object is double?)
{
exprString = new ExprDouble(((double?)@object).Value);
}
else if (@object is int?)
{
ExprInteger exprInteger = new ExprInteger(((int?)@object).Value);
}
else if (StringUtils.isDecimal(@object.ToString()))
{
exprString = new ExprDouble((Convert.ToDouble(@object.ToString())));
}
else if (@object is NativeJavaObject)
{
object object1 = ((NativeJavaObject)@object).getDefaultValue(typeof(string));
if (StringUtils.isDecimal(object1.ToString()))
{
exprString = new ExprDouble((Convert.ToDouble(object1.ToString())));
}
else
{
ExprString exprString1 = new ExprString(object1.ToString());
}
}
else
{
exprString = new ExprString(@object.ToString());
}
exprArray.set(b, b1, exprString);
}
}
}
return(exprArray);
}
public static Expr toExprArray(object[] paramArrayOfObject)
{
List <object> arrayList = new List <object>();
int i = 1;
bool @bool = false;
foreach (object @object in paramArrayOfObject)
{
if (@object is object[])
{
@bool = true;
List <object> arrayList1 = new List <object>();
foreach (object object1 in (object[])@object)
{
arrayList1.Add(object1);
}
if (i == 1 && arrayList1.Count != 0)
{
i = arrayList1.Count;
}
arrayList.Add(arrayList1);
}
else
{
arrayList.Add(@object);
}
}
ExprArray exprArray = new ExprArray(arrayList.Count, i);
if (!@bool)
{
for (sbyte b = 0; b < arrayList.Count; b++)
{
object @object = arrayList[b];
ExprString exprString = null;
if (@object is double?)
{
exprString = new ExprDouble(((double?)@object).Value);
}
else if (@object is int?)
{
ExprInteger exprInteger = new ExprInteger(((int?)@object).Value);
}
else if (StringUtils.isDecimal(@object.ToString()))
{
exprString = new ExprDouble((Convert.ToDouble(@object.ToString())));
}
else
{
exprString = new ExprString(@object.ToString());
}
exprArray.set(b, exprString);
}
}
else
{
for (sbyte b = 0; b < arrayList.Count; b++)
{
System.Collections.IList list = (System.Collections.IList)arrayList[b];
for (sbyte b1 = 0; b1 < list.Count; b1++)
{
object @object = list[b1];
ExprString exprString = null;
if (@object is double?)
{
exprString = new ExprDouble(((double?)@object).Value);
}
else if (@object is int?)
{
ExprInteger exprInteger = new ExprInteger(((int?)@object).Value);
}
else if (StringUtils.isDecimal(@object.ToString()))
{
exprString = new ExprDouble((Convert.ToDouble(@object.ToString())));
}
else
{
exprString = new ExprString(@object.ToString());
}
exprArray.set(b, b1, exprString);
}
}
}
return(exprArray);
}
