public override object calculate()
{
if (base.paramList.Count < 2)
{
throw new ReportError("ifnull函数参数数目应为2");
}
ExpParse parse = (ExpParse)base.paramList[0];
if (parse == null)
{
throw new ReportError("ifnull函数出现无效参数");
}
object obj2 = ConvertTool.getValue(parse.calculate());
if ((obj2 != null) && (obj2 != DBNull.Value))
{
return(obj2);
}
ExpParse parse2 = (ExpParse)base.paramList[1];
if (parse2 != null)
{
return(ConvertTool.getValue(parse2.calculate()));
}
return(null);
}
public Group filter(ExpParse exp)
{
if (exp == null)
{
return(this);
}
if (exp.ConstantExpression)
{
object obj2 = exp.calculate();
if ((obj2 is bool) && (bool)(obj2))
{
return(this);
}
}
Group group = (Group)base.MemberwiseClone();
group.bool_0 = false;
if (exp.getFilters(group) == null)
{
group.method_0(exp);
}
else
{
group.method_1(exp);
}
group.btree_0 = null;
return(group);
}
public override object calculate()
{
if (base.paramList.Count == 0)
{
throw new ReportError("groupall函数参数列表为空");
}
ExpParse select = (ExpParse)base.paramList[0];
ExpParse filter = null;
ExpParse desc = null;
if (base.paramList.Count > 1)
{
desc = (ExpParse)base.paramList[1];
}
if (base.paramList.Count > 2)
{
filter = (ExpParse)base.paramList[2];
}
ExpParse sort = null;
if (base.paramList.Count > 3)
{
sort = (ExpParse)base.paramList[3];
}
return(this.Group_0.group(select, desc, filter, sort));
}
public override object calculate()
{
if (base.paramList.Count == 0)
{
throw new ReportError("sum函数参数列表为空");
}
ExpParse exp = (ExpParse)base.paramList[0];
ExpParse parse2 = null;
if (base.paramList.Count > 1)
{
parse2 = (ExpParse)base.paramList[1];
}
Group group = base.ds.CurrentGroup.filter(parse2);
int rowCount = group.RowCount;
double num2 = 0.0;
for (int i = 0; i < rowCount; i++)
{
object o = ConvertTool.getSingleValue(group.getRow(i).evaluate(exp));
if (o != null)
{
num2 += ConvertTool.doubleValue(o);
}
}
return(num2);
}
public override object calculate()
{
if (base.paramList.Count != 1)
{
throw new ReportError("取单元格显示值函数的参数个数应该为1");
}
ExpParse parse = (ExpParse)base.paramList[0];
if (parse == null)
{
throw new ReportError("取单元格显示值函数的第1个参数应该是单元格");
}
object obj2 = parse.calculate();
if (obj2 == null)
{
return(new StringBuilder("").ToString());
}
if (!(obj2 is CSVar))
{
throw new ReportError("取单元格显示值函数的第1个参数应该是单元格");
}
CellExt ext = ((CSVar)obj2).getCell();
if (ext == null)
{
return(null);
}
return(ext.GetValue(true));
}
public override object calculate()
{
if (base.paramList.Count == 0)
{
throw new ReportError("sum函数参数列表为空");
}
ExpParse parse = (ExpParse)base.paramList[0];
if (parse == null)
{
throw new ReportError("sum函数出现无效参数");
}
object obj3 = ConvertTool.getValue(parse.calculate());
double num2 = 0.0;
if (!(obj3 is ArrayList))
{
return(obj3);
}
ArrayList list = (ArrayList)obj3;
for (int i = 0; i < list.Count; i++)
{
object o = ConvertTool.getSingleValue(list[i]);
if (o != null)
{
num2 += ConvertTool.doubleValue(o);
}
}
return(num2);
}
public override object calculate()
{
if (base.paramList.Count != 2)
{
throw new ReportError("map函数参数数目应为2");
}
ExpParse parse2 = (ExpParse)base.paramList[0];
ExpParse parse = (ExpParse)base.paramList[1];
if ((parse2 == null) || (parse == null))
{
throw new ReportError("map函数参数为空");
}
object obj7 = parse2.calculate();
object obj3 = parse.calculate();
if ((obj7 is ArrayList) && (obj3 is ArrayList))
{
ArrayList list = (ArrayList)obj7;
ArrayList list2 = (ArrayList)obj3;
object obj6 = base.cs.Current.GetValue(false);
for (int i = 0; i < list.Count; i++)
{
object obj5 = ConvertTool.getValue(list[i]);
if (ConvertTool.equals(obj6, obj5) && (list2.Count > i))
{
return(ConvertTool.getValue(list2[i]));
}
}
}
return(null);
}
public override object calculate()
{
if (base.paramList.Count < 2)
{
throw new ReportError("afterdays函数参数数目应为2");
}
ExpParse parse = (ExpParse)base.paramList[0];
ExpParse parse2 = (ExpParse)base.paramList[1];
object obj3 = ConvertTool.getValue(parse.calculate());
object o = ConvertTool.getValue(parse2.calculate());
if ((obj3 != null) && (o != null))
{
if (obj3 is string)
{
obj3 = ConvertTool.parseDate((string)obj3);
if (!(obj3 is DateTime))
{
throw new ReportError(new StringBuilder("字符串").Append(obj3).Append("不能转换成日期").ToString().ToString());
}
}
if (!(obj3 is DateTime) || !ConvertTool.isNumber(o))
{
throw new ReportError("afterdays函数参数类型不正确");
}
long num = ((System.DateTime)obj3).Ticks;
long num2 = (((ConvertTool.longValue(o) * 24) * 3600) * 1000) * 10000;
return(new System.DateTime(num + num2));
}
return(null);
}
public override object calculate()
{
SubReportList subRptList = base.cs.Env.SubRptList;
if (subRptList == null)
{
throw new ReportError("当前报表没有引入子报表，不能进行子报表运算");
}
if ((base.paramList.Count < 3) || (base.paramList.Count > 4))
{
throw new ReportError("子报表运算函数的参数格式应为subreport(rpt, List1, List2) 或者 subreport(rpt, List1, List2,importOrEmbed)");
}
ExpParse parse4 = (ExpParse)base.paramList[0];
if (parse4 == null)
{
throw new ReportError("子报表运算函数出现无效参数");
}
object obj2 = ConvertTool.getValue(parse4.calculate());
int num = 0;
if (base.paramList.Count == 4)
{
ExpParse parse3 = (ExpParse)base.paramList[3];
if (parse3 == null)
{
throw new ReportError("子报表运算函数出现无效参数");
}
object obj6 = ConvertTool.getValue(parse3.calculate());
try
{
num = (int)obj6;
}
catch (Exception)
{
num = 0;
}
}
if (!(obj2 is string))
{
throw new ReportError("子报表运算函数第一个参数应为引入的子报表名");
}
string str = subRptList.getAddress((string)obj2);
string str2 = subRptList.getType((string)obj2);
ReportDefine define = this.method_0(str, str2);
ExpParse parse = (ExpParse)base.paramList[1];
ExpParse parse2 = (ExpParse)base.paramList[2];
if ((parse != null) && (parse2 != null))
{
object obj5 = ConvertTool.getValue(parse.calculate());
object obj4 = ConvertTool.getValue(parse2.calculate());
if ((obj5 is ArrayList) && (obj4 is ArrayList))
{
return(this.method_1(define, (ArrayList)obj5, (ArrayList)obj4, num));
}
return(this.method_1(define, null, null, num));
}
return(this.method_1(define, null, null, num));
}
private bool method_5(ExpParse expParse_0)
{
Index index = this.dataSet_0.Index;
if (index != null)
{
if (this.btree_0 != null)
{
if (expParse_0 == null)
{
return(false);
}
Unit home = expParse_0.Home;
if (home is DSVar)
{
DSVar var = (DSVar)home;
if (var.DS != this.dataSet_0)
{
return(false);
}
int colNo = var.ColNo;
return((colNo >= 0) ? (index.getLevelFrom(this.btree_0, colNo) >= 0) : false);
}
}
return(false);
}
return(false);
}
private ArrayList method_6(ExpParse expParse_0)
{
ArrayList list = new ArrayList();
Group group = null;
object obj2 = null;
object obj3 = null;
Row row = null;
for (int i = 0; i < this.arrayList_0.Count; i++)
{
row = (Row)this.arrayList_0[i];
obj2 = row.evaluate(expParse_0);
if (i != 0)
{
if (!ConvertTool.equals(obj2, obj3))
{
group.trimToSize();
group = new Group(this.dataSet_0, false);
group.setValue(obj2);
list.Add(group);
}
}
else
{
group = new Group(this.dataSet_0, false);
group.setValue(obj2);
list.Add(group);
}
group.addRow(row);
obj3 = obj2;
}
return(list);
}
private ArrayList method_4(ExpParse expParse_0, ExpParse expParse_1)
{
if (DataSet.DEBUG)
{
CellExt1 cS = expParse_0.CS;
if ((cS != null) && (cS.Current != null))
{
if (cS.Current.Source == cS.Current)
{
Logger.info(cS.Current.SourceId.ToString().ToString() + "分组使用索引");
}
}
else
{
Logger.info("分组使用索引");
}
}
bool flag = false;
if (expParse_1 != null)
{
object obj2 = ConvertTool.getValue(expParse_1.calculate());
if (!(obj2 is bool))
{
throw new ReportError("group函数第2个参数应该为空或null或布尔型值");
}
flag = (bool)obj2;
}
return(this.dataSet_0.Index.getGroups(this.btree_0, !flag));
}
public override object calculate()
{
if (base.paramList.Count < 3)
{
throw new ReportError("条件函数参数数目应为3");
}
ExpParse parse = (ExpParse)base.paramList[0];
if (parse == null)
{
throw new ReportError("条件函数出现无效参数");
}
object obj2 = ConvertTool.getValue(parse.calculate());
if (!(obj2 is bool))
{
throw new ReportError("条件函数参数1应为布尔值");
}
if (obj2.Equals(true))
{
ExpParse parse2 = (ExpParse)base.paramList[1];
if (parse2 == null)
{
throw new ReportError("条件函数出现无效参数");
}
return(parse2.calculate());
}
ExpParse parse3 = (ExpParse)base.paramList[2];
if (parse3 == null)
{
throw new ReportError("条件函数出现无效参数");
}
return(parse3.calculate());
}
private void method_1(ExpParse expParse_0)
{
Filters fs = expParse_0.getFilters(this);
if (DataSet.DEBUG)
{
bool flag = fs.includeAllFilter();
CellExt1 cS = expParse_0.CS;
if ((cS != null) && (cS.Current != null))
{
if (cS.Current.Source == cS.Current)
{
if (flag)
{
Logger.info(cS.Current.SourceId.ToString().ToString() + "过滤完全使用索引");
}
else
{
Logger.info(cS.Current.SourceId.ToString().ToString() + "过滤时使用索引中遍历");
}
}
}
else if (flag)
{
Logger.info("过滤完全使用索引");
}
else
{
Logger.info("过滤使用索引中遍历");
}
}
this.arrayList_0 = this.dataSet_0.Index.getRows(this.btree_0, fs);
this.arrayList_0.TrimToSize();
}
public virtual Row getRow(ExpParse filter)
{
if (this.arrayList_1 != null)
{
for (int i = 0; i < this.arrayList_1.Count; i++)
{
Row row3 = (Row)this.arrayList_1[i];
if ((filter == null) || row3.test(filter))
{
return(row3);
}
}
}
if (this.arrayList_0 != null)
{
for (int j = 0; j < this.arrayList_0.Count; j++)
{
Row row2 = ((BTree)this.arrayList_0[j]).getRow(filter);
if (row2 != null)
{
return(row2);
}
}
}
return(null);
}
public override object calculate()
{
int num = base.paramList.Count;
for (int i = 0; i < num; i++)
{
ExpParse parse = (ExpParse)base.paramList[i];
if (parse == null)
{
throw new ReportError("case函数出现无效参数");
}
if (i >= (num - 1))
{
return(parse.calculate());
}
object obj3 = ConvertTool.getValue(parse.calculate());
if (!(obj3 is bool))
{
throw new ReportError("case函数参数类型不正确");
}
if (obj3.Equals(true))
{
ExpParse parse2 = (ExpParse)base.paramList[i + 1];
if (parse2 == null)
{
throw new ReportError("case函数出现无效参数");
}
return(parse2.calculate());
}
i++;
}
return(null);
}
public void evaulateRows(ExpParse exp)
{
for (int i = 0; i < this.arrayList_0.Count; i++)
{
Row row = (Row)this.arrayList_0[i];
row.setValue(row.evaluate(exp));
}
}
public Filters(Index dataIndex, int groupLevel, ExpParse filterExp)
{
this.index_0 = dataIndex;
this.int_0 = groupLevel;
this.expParse_0 = filterExp;
this.method_2();
this.method_0();
}
public override object calculate()
{
ExpParse exp = null;
if (base.paramList.Count > 0)
{
exp = (ExpParse)base.paramList[0];
}
return(ConvertData.getInteger(base.ds.CurrentGroup.filter(exp).RowCount));
}
public virtual bool test(ExpParse exp)
{
this.dataSet_0.CurrentRow = this;
object obj2 = ConvertTool.getValue(exp.calculate());
if (!(obj2 is bool))
{
throw new ReportError("行过滤条件应返回布尔值");
}
return((bool)obj2);
}
public override object calculate()
{
if (base.paramList.Count == 0)
{
throw new ReportError("get函数参数列表为空");
}
ExpParse exp = (ExpParse)base.paramList[0];
ExpParse parse2 = null;
ExpParse desc = null;
if (base.paramList.Count > 1)
{
desc = (ExpParse)base.paramList[1];
if (((desc != null) && desc.ConstantExpression) && (desc.calculate() == null))
{
desc = null;
}
}
if (base.paramList.Count > 2)
{
parse2 = (ExpParse)base.paramList[2];
}
ExpParse sort = null;
if (base.paramList.Count > 3)
{
sort = (ExpParse)base.paramList[3];
}
Group group = base.ds.CurrentGroup.filter(parse2);
if ((sort != null) || (desc != null))
{
if (sort == null)
{
sort = exp;
}
group = group.sort(sort, desc);
}
group.evaulateRows(exp);
ArrayList rows = group.Rows;
if (rows.Count == 1)
{
return(rows[0]);
}
if (rows.Count != 0)
{
return(rows);
}
Row nullRow = base.ds.NullRow;
base.ds.CurrentRow = nullRow;
return(nullRow);
}
public override object calculate()
{
if (base.paramList.Count == 0)
{
throw new ReportError("max函数参数列表为空");
}
ExpParse exp = (ExpParse)base.paramList[0];
ExpParse parse2 = null;
if (base.paramList.Count > 1)
{
parse2 = (ExpParse)base.paramList[1];
}
Group currentGroup = base.ds.CurrentGroup;
Row row = null;
object obj3 = null;
currentGroup = currentGroup.filter(parse2);
int rowCount = currentGroup.RowCount;
for (int i = 0; i < rowCount; i++)
{
Row row2 = currentGroup.getRow(i);
object obj4 = ConvertTool.getSingleValue(row2.evaluate(exp));
if (obj4 != null)
{
if (obj3 != null)
{
if (ConvertTool.compare2(obj3, obj4) < 0)
{
obj3 = obj4;
row = row2;
}
}
else
{
obj3 = obj4;
row = row2;
}
}
else if (row == null)
{
row = row2;
}
}
if (obj3 == null)
{
return(null);
}
row.setValue(obj3);
return(row);
}
public ArrayList group(ExpParse exp, ArrayList extents, bool eq, bool asc)
{
ArrayList list = new ArrayList();
int num = extents.Count;
for (int i = 0; i <= num; i++)
{
Group group3 = new Group(this.dataSet_0, false);
group3.setValue(ConvertData.getInteger(i));
list.Add(group3);
}
if (asc)
{
for (int k = 0; k < this.arrayList_0.Count; k++)
{
Row row2 = (Row)this.arrayList_0[k];
object obj3 = row2.evaluate(exp);
int num7 = 0;
while (num7 < num)
{
int num8 = ConvertTool.compare(obj3, extents[num7]);
if ((eq && (num8 <= 0)) || (!eq && (num8 < 0)))
{
break;
}
num7++;
}
((Group)list[num7]).addRow(row2);
}
return(list);
}
for (int j = 0; j < this.arrayList_0.Count; j++)
{
Row row = (Row)this.arrayList_0[j];
object obj2 = row.evaluate(exp);
int num3 = 0;
while (num3 < num)
{
int num5 = ConvertTool.compare(obj2, extents[num3]);
if ((eq && (num5 >= 0)) || (!eq && (num5 > 0)))
{
break;
}
num3++;
}
((Group)list[num3]).addRow(row);
}
return(list);
}
public ArrayList group(ExpParse select, ExpParse desc, ExpParse filter, ExpParse sort)
{
if ((filter != null) && filter.ConstantExpression)
{
object obj2 = filter.calculate();
if ((obj2 is bool) && (bool)(obj2))
{
filter = null;
}
}
if (((sort == null) && (filter == null)) && this.method_5(select))
{
return(this.method_4(select, desc));
}
return(this.method_3(select, desc, filter, sort));
}
private void method_0(ExpParse expParse_0)
{
int num = this.arrayList_0.Count;
ArrayList list = new ArrayList((num > 1000) ? (num / 100) : 10);
for (int i = 0; i < num; i++)
{
Row row = (Row)this.arrayList_0[i];
if (row.test(expParse_0))
{
list.Add(row);
}
}
list.TrimToSize();
this.arrayList_0 = list;
}
public Row select1(ExpParse filterExp)
{
if (filterExp == null)
{
if (this.arrayList_0.Count != 0)
{
return((Row)this.arrayList_0[0]);
}
return(this.dataSet_0.NullRow);
}
Filters fs = filterExp.getFilters(this);
if (fs != null)
{
if (DataSet.DEBUG)
{
CellExt1 cS = filterExp.CS;
if ((cS == null) || (cS.Current == null))
{
Logger.info("单选完全使用索引");
}
else if (cS.Current.Source == cS.Current)
{
Logger.info(cS.Current.SourceId.ToString().ToString() + "单选完全使用索引");
}
}
Row row2 = this.dataSet_0.Index.getRow(this.btree_0, fs);
if (row2 != null)
{
return(row2);
}
}
else
{
for (int i = 0; i < this.arrayList_0.Count; i++)
{
Row row3 = (Row)this.arrayList_0[i];
if (row3.test(filterExp))
{
return(row3);
}
}
}
return(this.dataSet_0.NullRow);
}
public override object calculate()
{
if (base.paramList.Count < 2)
{
throw new ReportError("likestr函数参数数目至少为2");
}
object obj2 = ConvertTool.getValue(((ExpParse)base.paramList[0]).calculate());
if (obj2 != null)
{
if (!(obj2 is string))
{
throw new ReportError("likestr函数的第一个参数应为字符串");
}
object obj3 = ConvertTool.getValue(((ExpParse)base.paramList[1]).calculate());
if (obj3 == null)
{
return(false);
}
if (!(obj3 is string))
{
throw new ReportError("likestr函数的第二个参数应为格式串");
}
bool ifcase = false;
if (base.paramList.Count >= 3)
{
ExpParse parse = (ExpParse)base.paramList[2];
if (parse != null)
{
object obj5 = ConvertTool.getValue(parse.calculate());
if (!(obj5 is bool))
{
throw new ReportError("likestr函数的第三个参数应为布尔值");
}
ifcase = (bool)obj5;
}
}
if (!StringUtils.matches((string)obj2, (string)obj3, ifcase))
{
return(false);
}
return(true);
}
return(false);
}
public override object calculate()
{
if (base.paramList.Count == 0)
{
throw new ReportError("first函数参数列表为空");
}
ExpParse parse = (ExpParse)base.paramList[0];
ExpParse desc = null;
if (base.paramList.Count > 1)
{
desc = (ExpParse)base.paramList[1];
}
ExpParse exp = null;
if (base.paramList.Count > 2)
{
exp = (ExpParse)base.paramList[2];
}
ExpParse sort = null;
if (base.paramList.Count > 3)
{
sort = (ExpParse)base.paramList[3];
}
Group group = base.ds.CurrentGroup.filter(exp);
if ((sort != null) || (desc != null))
{
if (sort == null)
{
sort = parse;
}
group = group.sort(sort, desc);
}
if (group.RowCount <= 0)
{
return(null);
}
Row row = group.getRow(0);
base.ds.CurrentRow = row;
row.setValue(parse.calculate());
return(row);
}
private ArrayList method_3(ExpParse expParse_0, ExpParse expParse_1, ExpParse expParse_2, ExpParse expParse_3)
{
Group group = this;
if (expParse_2 != null)
{
group = group.filter(expParse_2);
}
if ((expParse_3 != null) || (expParse_1 != null))
{
if (expParse_3 == null)
{
expParse_3 = expParse_0;
}
group = group.sort(expParse_3, expParse_1);
}
return(group.method_6(expParse_0));
}
public override object calculate()
{
if (base.paramList.Count == 0)
{
throw new ReportError("tostring函数参数为空");
}
object o = ConvertTool.getValue(((ExpParse)base.paramList[0]).calculate());
if (base.paramList.Count > 1)
{
ExpParse parse2 = (ExpParse)base.paramList[1];
if (parse2 != null)
{
object obj3 = ConvertTool.getValue(parse2.calculate());
return(ConvertTool.format(o, (string)obj3));
}
}
return(ConvertTool.toString(o));
}
