private static StandardResult <string> EvaulateExpression(SimpleTableRow row, string expressionText)
{
if (expressionText == null)
{
return(StandardResult <string> .ReturnResult(null));
}
var fieldSource = new FieldDataSource()
{
Row = row
};
var expression = ExpressionCache.Compile(expressionText);
var result = expression.Evaluate(new Context()
{
FieldSource = fieldSource
});
if (result.IsError)
{
return(StandardResult <string> .ReturnError(result.String));
}
if (!result.IsString)
{
return(StandardResult <string> .ReturnError("message processing error - expression evaulation did not result in a string"));
}
return(StandardResult <string> .ReturnResult(result.String));
}
public void StorageWorks()
{
var t = new SimpleTableData();
int numCols = _random.Next(1, 50);
for (int n = 0; n < numCols; ++n)
{
t.AddColumn(Guid.NewGuid().ToString());
}
var rows = new List <SimpleTableRow>();
int numRows = _random.Next(100, 1000);
for (int n = 0; n < numRows; ++n)
{
var row = new SimpleTableRow();
for (int c = 0; c < numCols; ++c)
{
row.Add(Guid.NewGuid().ToString());
}
rows.Add(row);
t.AddRow(row);
}
int i = 0;
foreach (var row in t.Rows)
{
Assert.AreEqual(row, rows[i++]);
}
}
public void CanAddNullValues()
{
var row = new SimpleTableRow();
row.Add(null);
Assert.IsTrue(row.ColumnCount == 1);
}
public static StandardResult <SimpleTable> Execute(string data, string newRow, char delimiter = '=', IList <string> columns = null)
{
var lines = data.Split(new string[] { "\r\n" }, StringSplitOptions.None);
var table = new SimpleTable();
if (columns != null)
{
for (int i = 0; i < columns.Count; i++)
{
table.SetColumnName(i, columns[i]);
}
}
SimpleTableRow row = null;
foreach (var line in lines)
{
if (string.IsNullOrEmpty(line))
{
continue;
}
if (line.StartsWith("#"))
{
continue;
}
if (line == newRow)
{
row = table.CreateRow();
continue;
}
int pos = line.IndexOf(delimiter);
if (pos < 0)
{
continue;
}
string name = line.Substring(0, pos);
string value = line.Substring(pos + 1);
if (columns == null && !table.ContainColumn(name))
{
table.SetColumnName(table.ColumnNames.Count, name);
}
if (table.ContainColumn(name))
{
row.SetField(name, value);
}
}
return(StandardResult <SimpleTable> .ReturnResult(table));
}
public void SetBodyFields(SimpleTableRow row)
{
for (int i = 0; i < row.ColumnCount; i++)
{
var columnName = row.Table.GetColumnName(i);
var value = row[i];
InProcessBody = InProcessBody.Replace("[" + columnName + "]", value);
}
}
public void SetRowFields(SimpleTableRow row)
{
var sb = new StringBuilder(TemplateRow);
foreach (var column in row.Table.ColumnNames)
{
var value = row[column];
sb.Replace("[" + column + "]", value);
}
InProcessRows.Append(sb);
}
public void AcceptsRowsWithTooFewColumns()
{
var t = new SimpleTableData();
t.AddColumn("col1");
t.AddColumn("col2");
t.AddColumn("col3");
var row = new SimpleTableRow();
row.Add("val1");
t.AddRow(row);
Assert.IsTrue(row.ColumnCount == t.ColumnCount);
}
public bool Equals(SimpleTableRow <T> other)
{
// Check for null
if (ReferenceEquals(other, null))
{
return(false);
}
// Check for same reference
if (ReferenceEquals(this, other))
{
return(true);
}
// Check for same Id and same Values
return(Id == other.Id && Values.SequenceEqual(other.Values));
}
static void Main()
{
// first and second are logically equivalent
SimpleTableRow <int> first = new SimpleTableRow <int>(1, 2, 3, 4, 5, 6),
second = new SimpleTableRow <int>(1, 2, 3, 4, 5, 6);
if (first.Equals(second) && first.GetHashCode() != second.GetHashCode())
{ // proven Equals, but GetHashCode() disagrees
Console.WriteLine("We have a problem");
}
HashSet <SimpleTableRow <int> > set = new HashSet <SimpleTableRow <int> >();
set.Add(first);
set.Add(second); Console.WriteLine("Yup, very bad indeed{0}", set.Count); Console.ReadKey();
// which confuses anything that uses hash algorithms
//if (set.Count != 1)
}
public void PreventsAdditionOfRowsWithTooManyColumns()
{
var t = new SimpleTableData();
t.AddColumn("col1");
t.AddColumn("col2");
t.AddColumn("col3");
var row = new SimpleTableRow();
row.Add("val1");
row.Add("val2");
row.Add("val3");
row.Add("val4");
t.AddRow(row);
}
private Row FromDataDiff(DataDiff d)
{
var r = new Row();
SimpleTableRow sr = null;
var statusString = string.Empty;
switch (d.Status)
{
case RowStatus.Inserted:
statusString = HistorySchema.HistoryStatusInsert;
sr = d.NewRow;
break;
case RowStatus.Updated:
statusString = HistorySchema.HistoryStatusUpdate;
sr = d.NewRow;
break;
case RowStatus.Deleted:
statusString = HistorySchema.HistoryStatusDelete;
sr = d.OldRow;
break;
case RowStatus.Unknown:
throw new ApplicationException("Unknown status for diff row");
}
if (sr != null)
{
int colNum = 1; // skip the diff status flag
foreach (var col in _stagingTableColumns)
{
r[col] = sr.Get(colNum++);
}
r[HistorySchema.HistoryStatusColumnName] = statusString;
r[HistorySchema.HistoryLogColumnName] = _logId;
r[HistorySchema.HistoryFederatedColumnName] = 0;
r[HistorySchema.HistoryAppliedColumnName] = 0;
r[HistorySchema.HistoryStampColumnName] = DateTime.Now;
}
return(r);
}
private string GeneratePrimaryKeyHash(SimpleTableRow row)
{
var sb = new StringBuilder();
// skip 1st column which is table indicator...
for (var n = 1; n < _primaryKeyColCount + 1; ++n)
{
if (sb.Length > 0)
{
sb.Append("\t");
}
sb.Append(row[n]);
}
var result = sb.ToString();
_log.DebugFormat("KeyHash generated = {0}", result);
return(result);
}
private List <ITableRow> CreateSimpleData(string[] columnIdentifiers, int countRows)
{
var rand = new Random();
var min = 0;
var max = 900;
var list = new List <ITableRow>();
for (int i = 0; i < countRows; i++)
{
var tr = new SimpleTableRow();
foreach (var identifier in columnIdentifiers)
{
tr.DataCell.Add(identifier,
nameof(SimpleTableRow) + " " + rand.Next(min, max));
}
list.Add(tr);
}
return(list);
}
public static StandardResult <SimpleTable> Execute(SimpleTable sourceTable, SimpleTable validationRules, bool rowPerMatch, bool overwrite)
{
var resultsTable = new SimpleTable();
foreach (var column in sourceTable.ColumnNames)
{
resultsTable.AddColumnName(column);
}
foreach (var column in validationRules.ColumnNames)
{
if (column == "Match")
{
continue;
}
resultsTable.AddColumnName(column);
}
var fieldSource = new FieldDataSource();
foreach (var sourceRow in sourceTable)
{
fieldSource.Row = sourceRow;
SimpleTableRow row = null;
foreach (var rule in validationRules)
{
var match = rule["Match"];
if (string.IsNullOrWhiteSpace(match))
{
continue;
}
var expression = ExpressionCache.Compile(match);
if (expression == null)
{
return(StandardResult <SimpleTable> .ReturnError("ValidateTable() error: evaluator returns null"));
}
if (!expression.IsValid)
{
return(StandardResult <SimpleTable> .ReturnError("ValidateTable() error: occurred during evaluating: " + expression.Parser.Tokenizer.Expression));
}
var result = expression.Evaluate(new Context()
{
FieldSource = fieldSource
});
if (result.IsError)
{
return(StandardResult <SimpleTable> .ReturnError("ValidateTable() error: occurred during evaluating: " + expression.Parser.Tokenizer.Expression, result.String));
}
if (!result.Boolean)
{
continue;
}
if (row == null || rowPerMatch)
{
row = resultsTable.CreateRow();
}
foreach (var column in sourceTable.ColumnNames)
{
row[column] = sourceRow[column];
}
foreach (var column in validationRules.ColumnNames)
{
if (column == "Match")
{
continue;
}
var text = rule[column];
if (string.IsNullOrWhiteSpace(text))
{
continue;
}
var expression2 = ExpressionCache.Compile(text);
if (expression2 == null)
{
return(StandardResult <SimpleTable> .ReturnError("ValidateTable() error: evaluator returns null"));
}
if (!expression2.IsValid)
{
return(StandardResult <SimpleTable> .ReturnError("ValidateTable() error: occurred during evaluating: " + expression2.Parser.Tokenizer.Expression));
}
var result2 = expression2.Evaluate(new Context()
{
FieldSource = fieldSource
});
if (result2.IsError)
{
return(StandardResult <SimpleTable> .ReturnError("ValidateTable() error: occurred during evaluating: " + expression2.Parser.Tokenizer.Expression, result2.String));
}
if (overwrite || string.IsNullOrWhiteSpace(row[column]))
{
row[column] = result2.String;
}
}
}
}
return(StandardResult <SimpleTable> .ReturnResult(resultsTable));
}
public FieldDataSource(SimpleTableRow simpleTableRow)
{
Row = simpleTableRow;
}
public override void ViewDidLoad()
{
base.ViewDidLoad();
InitTableCell();
InitTable();
btn_copyCell.Title = "Copy clicked cell value";
btn_copyRow.Title = "Copy selected row";
btn_updateRow.Title = "Update row";
btn_updateColumn.Title = "Update column";
btn_addRow.Title = "Add row";
tf_row.PlaceholderString = "RowIndex";
tf_column.PlaceholderString = "C0";
tbl.Activated += (sender, e) => {
var ds = (TableDataSource)tbl.DataSource;
var tableRow = ds.Data[(int)tbl.ClickedRow];
var clickedColumn = tbl.TableColumns()[(int)tbl.ClickedColumn];
var cellValue = tableRow.GetValue(clickedColumn.Identifier).Text;
_cellValue = cellValue;
};
btn_copyCell.Activated += (sender, e) =>
_clipboard.CopyString(_cellValue);
btn_copyRow.Activated += (sender, e) => {
if (tbl.SelectedRow == -1)
{
return;
}
var ds = (TableDataSource)tbl.DataSource;
var tableRow = ds.Data[(int)tbl.SelectedRow];
var rowValue = string.Empty;
foreach (var column in tbl.TableColumns())
{
if (!string.IsNullOrEmpty(rowValue))
{
rowValue += "\t";
}
rowValue += tableRow.GetValue(column.Identifier).Text;
}
_clipboard.CopyString(rowValue);
};
btn_updateRow.Activated += (sender, e) => {
if (int.TryParse(tf_row.StringValue, out int rowIndex))
{
var ds = (TableDataSource)tbl.DataSource;
if (ds.Data.Count > rowIndex &&
rowIndex >= 0)
{
var tableRow = (SimpleTableRow)ds.Data[rowIndex];
var rand = new Random();
var min = 0;
var max = 900;
foreach (var column in tbl.TableColumns())
{
tableRow.DataCell[column.Identifier] =
nameof(SimpleTableRow) + " " + rand.Next(min, max);
}
var rowIndexSet = new NSIndexSet(rowIndex);
var columnIndexSet = new NSMutableIndexSet();
for (int i = 0; i < tbl.TableColumns().Length; i++)
{
columnIndexSet.Add(new NSIndexSet(i));
}
tbl.ReloadData(rowIndexSet, columnIndexSet);
}
}
};
btn_updateColumn.Activated += (sender, e) => {
var foundColumnIndex = tbl.FindColumn((NSString)tf_column.StringValue);
if (foundColumnIndex < 0)
{
return;
}
var column = tbl.TableColumns()[foundColumnIndex];
var ds = (TableDataSource)tbl.DataSource;
var rand = new Random();
var min = 0;
var max = 900;
foreach (var row in ds.Data)
{
var tableRow = (SimpleTableRow)row;
tableRow.DataCell[column.Identifier] =
nameof(SimpleTableRow) + " " + rand.Next(min, max);
}
var columnIndexSet = new NSIndexSet(foundColumnIndex);
var rowIndexSet = new NSMutableIndexSet();
for (int i = 0; i < ds.Data.Count; i++)
{
rowIndexSet.Add(new NSIndexSet(i));
}
tbl.ReloadData(rowIndexSet, columnIndexSet);
};
btn_addRow.Activated += (sender, e) => {
var tableRow = new SimpleTableRow();
foreach (var column in tbl.TableColumns())
{
tableRow.DataCell.Add(column.Identifier, column.Identifier);
}
var ds = (TableDataSource)tbl.DataSource;
ds.AddRow(tableRow);
};
//ordinary table
var ordinaryTbl = (BaseOrdinaryTable)tbl;
ordinaryTbl.SelectedRowIsChanged += (sender, e) =>
Console.WriteLine("Selected row is changed");
ordinaryTbl.WasKeyDown += (sender, e) => {
var theEvent = (NSEvent)sender;
Console.WriteLine("key code of pressed key: " + theEvent.KeyCode);
if (KeyDefinder.SpaceKey(theEvent))
{
Console.WriteLine("Space key was pressed");
}
};
}
