public static DataTable[] explodeForGroups(DataTable table, string[] colsArr)
{
List <DataTable> list = new List <DataTable>();
table.DefaultView.Sort = ToolSqlText.getSortString(colsArr, ToolArray.create <SqlTypeRelations>(colsArr.Length, SqlTypeRelations.sortAsc));
DataColumn[] colsObj = new DataColumn[colsArr.Length];
for (int i = 0; i < colsArr.Length; ++i)
{
colsObj[i] = table.Columns[colsArr[i]];
}
object[] curValues = ToolArray.create <object>(colsArr.Length, null);
DataTable tabTmp = null;
foreach (DataRowView rowV in table.DefaultView)
{
object[] tmpValues = compareData(rowV, colsObj, curValues);
if (tmpValues != null)
{
curValues = tmpValues;
list.Add(tabTmp = table.Clone());
}
tabTmp.Rows.Add(rowV.Row.ItemArray);
}
table.DefaultView.Sort = string.Empty;
return(list.ToArray());
}
object[] selectValues(object[] pKeys)
{
if (pKeys == null)
{
pKeys = new object[0];
}
List <object> list = new List <object>();
foreach (object[] arr in data)
{
if (pKeys.Length < arr.Length)
{
bool select_ = ToolArray.isEqual(pKeys, ToolArray.resize <object>(arr, pKeys.Length));
if (select_)
{
if (pKeys.Length < arr.Length)
{
object val_ = arr[pKeys.Length];
if (!list.Contains(val_))
{
list.Add(val_);
}
}
}
}
}
return(list.ToArray());
}
public static object[][] getGroups(DataTable table, string[] colsArr)
{
List <object[]> list = new List <object[]>();
DataColumn[] colsObj = new DataColumn[colsArr.Length];
for (int i = 0; i < colsArr.Length; ++i)
{
colsObj[i] = table.Columns[colsArr[i]];
}
foreach (DataRow row in table.Rows)
{
object[] curValues = ToolRow.copyRowToArr(colsObj, row);
foreach (object[] arr in list)
{
if (ToolArray.isEqual(arr, curValues))
{
curValues = null;
break;
}
}
if (curValues != null)
{
list.Add(curValues);
}
}
list.Sort(new ToolArray.Comparer());
return(list.ToArray());
}
protected void table_DistributeValues(DataRow[] topRows, DataRow[] subRows)
{
object topTotal = topOperDef;
for (int i = 0; i < topRows.Length; ++i)
{
evalOnTopAny.setVarAll(ToolRow.copyRowToArr(columnsVars, topRows[i]));
object tmpRes = evalOnTopAny.getResult();
evalOnTopAnyResult.setVarAll(new object[] { topTotal, tmpRes });
topTotal = evalOnTopAnyResult.getResult();
}
for (int i = 0; i < subRows.Length; ++i)
{
object[] vals;
object tmp;
DataRow row = subRows[i];
string oldest = toucher.getOldest(columnsCalc, row);
IEvaluator eval = evalOnSubCalc[Array.IndexOf <string>(columnsCalc, oldest)];
vals = ToolRow.copyRowToArr(columnsVars, row);
vals = ToolArray.resize <object>(vals, vals.Length + 1);
vals[vals.Length - 1] = topTotal;
eval.setVarAll(vals);
tmp = eval.getResult();
ToolCell.set(row, oldest, tmp);
vals = ToolRow.copyRowToArr(columnsVars, row);
vals = ToolArray.resize <object>(vals, vals.Length + 1);
vals[vals.Length - 1] = topTotal;
evalOnSubCorrect.setVarAll(vals);
topTotal = evalOnSubCorrect.getResult();
}
}
void init(DataTable pTableSource, DataTable pTableDest, IPagedSource pSource, string[] pBindChildCol, string[] pBindParentCol, string[] pChildCol, string[] pParentCol, UpdateTypeFlags pFlags, IRowValidator pValidator, string[] pTriggerCols)
{
validator = (pValidator == null) ? new RowValidatorTrue() : pValidator;
tableSource = pTableSource;
tableDest = pTableDest;
flags.flagEnable(pFlags);
source = pSource;
triggerCols = pTriggerCols;
bindChildCol = pBindChildCol;
bindParentCol = pBindParentCol;
childCol = pChildCol;
parentCol = pParentCol;
allChildCol = childCol;
allParentCol = parentCol;
//
for (int i = 0; i < bindChildCol.Length; ++i)
{
addColForMapBind(bindChildCol[i], bindParentCol[i]);
}
for (int i = 0; i < childCol.Length; ++i)
{
addColForMapData(childCol[i], parentCol[i]);
}
//
if (flags.isFlagEnabled(UpdateTypeFlags.activeOnRelColumn))
{
columns = bindChildCol;
}
else
{
int len = allChildCol.Length;
if (flags.isFlagEnabled(UpdateTypeFlags.activateIgnorLast1DrivedChilCols))
{
len -= 1;
}
else
if (flags.isFlagEnabled(UpdateTypeFlags.activateIgnorLast1DrivedChilCols))
{
len -= 2;
}
else
if (flags.isFlagEnabled(UpdateTypeFlags.activateIgnorLast1DrivedChilCols))
{
len -= 3;
}
columns = new string[len];
Array.Copy(allChildCol, columns, len);
}
columns = ToolArray.merge <string>(columns, triggerCols);
//
// if (flags.isFlagEnabled(UpdateTypeFlags.updateIgnoreRelColumn))
updateChildCol = childCol;
// else
// updateChildCol = allChildCol;
//!!!!!!!!!!!!!!!!!!!!!!!!!!!
}
public DataRow[] get(DataRow row)
{
DataRow[] rows = new DataRow[0];
DataTable table = row.Table;
//
if (row != null)
{
// if (row.RowState != DataRowState.Deleted)
for (int i = 0; i < table.Rows.Count; ++i)
{
DataRow locRow = table.Rows[i];
if (locRow.RowState != DataRowState.Deleted)
{
if ((!ToolStockLine.isLineStlineGlobal(locRow)) && ToolStockLine.isLineMonetary(locRow))
{
if (rows == null)
{
rows = new DataRow[] { locRow }
}
}
}
;
else
{
rows = ToolArray.resize <DataRow>(rows, rows.Length + 1);
rows[rows.Length - 1] = locRow;
}
}
Type[] checkAttrTypesArr(Type[] arr, int len)
{
if (arr == null || arr.Length == 0)
{
return(ToolArray.create <Type>(len, typeof(string)));
}
return(arr);
}
private object parse(string[] str)
{
switch (str[0])
{
case "println":
return("\r\n");
case "set":
_oper.setVar(str[1], parse(ToolArray.sub <string>(str, 2)));
break;
case "get":
return(_oper.getVar(str[1]));
case "mult":
return(_oper.mult(ToolArray.sub <string>(str, 1)));
case "sum":
return(_oper.sum(ToolArray.sub <string>(str, 1)));
case "div":
return(_oper.div(ToolArray.sub <string>(str, 1)));
case "format":
return(_oper.format(ToolArray.sub <string>(str, 1)));
case "formatln":
return(_oper.format(ToolArray.sub <string>(str, 1)) + "\r\n");
case "toDouble":
return(_oper.toDouble(str[1]));
case "toInt32":
return(_oper.toInt32(str[1]));
case "toInt16":
return(_oper.toInt16(str[1]));
case "sys":
return(_env.getSysSettings().getString(_oper.getVar(str[1]).ToString()));
case "printch":
return(_oper.printch(ToolArray.sub <string>(str, 1)));
case "replace":
return(_oper.replace(ToolArray.sub <string>(str, 1)));
case "formatlistarr":
return(_oper.formatlistarr(ToolArray.sub <string>(str, 1)));
}
if (str.Length == 1)
{
return(_oper.getVar(str[0]));
}
return(null);
}
public object[] filterLoad(string[] pCols)
{
string[] cols_ = ToolMobile.getEnvironment().getStateRuntime(stateFilterCols) as string[];
object[] vals_ = ToolMobile.getEnvironment().getStateRuntime(stateFilterVal) as object[];
if (cols_ != null && pCols != null && ToolArray.compare(cols_, pCols) == 0)
{
return(vals_);
}
return(null);
}
public string formatlistarr(string[] vars)
{
if (vars.Length < 3)
{
throw new MyException.MyExceptionError(MessageCollection.T_MSG_ERROR_INVALID_ARGS_COUNT);
}
StringBuilder sb = new StringBuilder();
string format_ = getVar(vars[0]).ToString();
string arr_ = getVar(vars[1]).ToString();
if (!string.IsNullOrEmpty(arr_))
{
string join_ = getVar(vars[2]).ToString();
string[] typesTmp_ = ToolArray.sub <string>(vars, 3);
Type[] types_ = new Type[typesTmp_.Length];
for (int i = 0; i < types_.Length; ++i)
{
types_[i] = ToolType.parse(typesTmp_[i]);
}
string[][] values_ = ToolString.explodeGroupList(arr_);
for (int x = 0; x < values_.Length; ++x)
{
string[] itms = values_[x];
object[] data_ = new object[itms.Length];
for (int i = 0; i < data_.Length; ++i)
{
Type type_ = i < types_.Length ? types_[i] : ToolTypeSet.helper.tString;
data_[i] = PARSE(itms[i], type_);
}
sb.Append(string.Format(format_, data_));
if (x < values_.Length - 1)
{
sb.Append(join_);
}
}
}
return(sb.ToString());
}
public DataRow[] get(DataRow row)
{
DataRow[] rows = new DataRow[0];
DataTable table = row.Table;
//
if (row != null && row.RowState != DataRowState.Deleted)
{
if (!ToolStockLine.isLineStlineGlobal(row))
{
if (ToolStockLine.isLineMonetary(row))
{
for (int i = table.Rows.IndexOf(row) + 1; i < table.Rows.Count; ++i)
{
DataRow locRow = table.Rows[i];
if (locRow.RowState != DataRowState.Deleted)
{
if (ToolStockLine.isLineMonetary(locRow))
{
break;
}
if ((!ToolStockLine.isLineStlineGlobal(locRow)) && ToolStockLine.isLinePureMoney(locRow))
{
if (rows == null)
{
rows = new DataRow[] { locRow }
}
;
else
{
rows = ToolArray.resize <DataRow>(rows, rows.Length + 1);
rows[rows.Length - 1] = locRow;
}
}
}
}
}
else
if (ToolStockLine.isLinePureMoney(row))
{
rows = new DataRow[] { row };
}
}
}
return(rows);
}
public string[][] getArrAttr(string name, string arrName, string[] attr)
{
return(ToolArray.stringArray(getArrAttr(name, arrName, attr, new Type[0])));
}
public string[][] getArr(string name)
{
return(ToolArray.stringArray(getArr(name, new Type[0])));
}
void init(DataTable pTable, IPagedSource pSource, string[] pBindChildCol, string[] pBindParentCol, string[] pChildCol, string[] pParentCol, UpdateTypeFlags pFlags, IRowValidator pValidator, string[] pTriggerCols)
{
flags.flagEnable(pFlags);
source = pSource;
for (int i = pChildCol.Length; i < pParentCol.Length; ++i)
{
pChildCol = ToolArray.resize <string>(pChildCol, pChildCol.Length + 1);
pChildCol[pChildCol.Length - 1] = string.Empty;
}
for (int i = 0; i < pParentCol.Length; ++i)
{
if ((pChildCol[i] == string.Empty) || (pChildCol[i] == null))
{
pChildCol[i] = ToolColumn.getColumnFullName(source.getBuilder().getName(), pParentCol[i]);
}
}
triggerCols = pTriggerCols;
bindChildCol = pBindChildCol;
bindParentCol = pBindParentCol;
childCol = pChildCol;
parentCol = pParentCol;
allChildCol = new string[bindChildCol.Length + childCol.Length];
bindChildCol.CopyTo(allChildCol, 0);
childCol.CopyTo(allChildCol, bindChildCol.Length);
allParentCol = new string[bindParentCol.Length + parentCol.Length];
bindParentCol.CopyTo(allParentCol, 0);
parentCol.CopyTo(allParentCol, bindParentCol.Length);
//
for (int i = 0; i < bindChildCol.Length; ++i)
{
addColForMap(bindChildCol[i], bindParentCol[i]);
}
for (int i = 0; i < childCol.Length; ++i)
{
addColForMap(childCol[i], parentCol[i]);
}
//
if (flags.isFlagEnabled(UpdateTypeFlags.activeOnRelColumn))
{
columns = bindChildCol;
}
else
{
int len = allChildCol.Length;
if (flags.isFlagEnabled(UpdateTypeFlags.activateIgnorLast1DrivedChilCols))
{
len -= 1;
}
else
if (flags.isFlagEnabled(UpdateTypeFlags.activateIgnorLast2DrivedChilCols))
{
len -= 2;
}
else
if (flags.isFlagEnabled(UpdateTypeFlags.activateIgnorLast3DrivedChilCols))
{
len -= 3;
}
columns = new string[len];
Array.Copy(allChildCol, columns, len);
}
columns = ToolArray.merge <string>(columns, triggerCols);
//
if (flags.isFlagEnabled(UpdateTypeFlags.updateIgnoreRelColumn))
{
updateChildCol = childCol;
}
else
{
updateChildCol = allChildCol;
}
//!!!!!!!!!!!!!!!!!!!!!!!!!!!
//
for (int i = 0; i < allChildCol.Length; ++i)
{
if (!tableSource.Columns.Contains(allChildCol[i]))
{
tableSource.Columns.Add(allChildCol[i], ToolTypeSet.helper.tObject);//check// source.getBuilder().getColumnType(allParentCol[i]));
}
}
//
try
{
flags.flagEnable(UpdateTypeFlags.__spe__updateIfDrived);
for (int i = 0; i < tableSource.Rows.Count; ++i)
{
refresh(tableSource.Rows[i]);
}
}
finally
{
flags.flagDisable(UpdateTypeFlags.__spe__updateIfDrived);
}
//
tableSource.ColumnChanged += new DataColumnChangeEventHandler(table_ColumnChanged);
}
