public LogCollector(MyQueue <string> paths, MyQueue <EventItem> events)
{
/*
* LogCollectorConfig config = LogCollectorConfig.GetSection(ConfigurationUserLevel.None);
* Console.WriteLine(config.ExampleAttribute);
* config.ExampleAttribute = "B";
* config.Class1.Add(new Class1Element());
* config.Save();
*/
workers = new IWorkingElement[1 + NUM_READERS + NUM_PROCESSORS];
int p = 0;
workers[p] = new DirectoryScanner("Scanner", paths, inFiles);
p++;
for (int i = 0; i < NUM_READERS; i++)
{
workers[p] = new FileReader("FR-" + i, inFiles, rows, outFiles);
p++;
}
for (int i = 0; i < NUM_PROCESSORS; i++)
{
workers[p] = new RowProcessor("RP-" + i, rows, events);
p++;
}
}
public void AddToDataTableTest()
{
var feedFilePlan = new FeedFilePlan {
TransformMaps = new [] {
new TransformMapping {
DestCol = "intColumn",
SrcColumns = "0",
Type = "int",
},
new TransformMapping {
DestCol = "strColumn",
SrcColumns = "1",
},
new TransformMapping {
DestCol = "boolColumn",
SrcColumns = "2",
Type = "bool",
},
new TransformMapping {
DestCol = "floatColumn",
SrcColumns = "3",
Type = "float",
},
},
};
var dataTable = new DataTable ();
dataTable.Columns.Add (FeedProcessor.LoadNumberString, typeof(Int32));
dataTable.Columns.Add (FeedProcessor.DataSourceCodeString, typeof(String));
dataTable.Columns.Add ("intColumn", typeof(int));
dataTable.Columns.Add ("strColumn", typeof(string));
dataTable.Columns.Add ("boolColumn", typeof(bool));
dataTable.Columns.Add ("floatColumn", typeof(float));
var row = new Dictionary<string, string> {
{ "intColumn", "42" },
{ "strColumn", "foo" },
{ "boolColumn", "true" },
{ "floatColumn", "10.0" },
};
var rowProcessor = new RowProcessor ();
rowProcessor.AddRowToDataTable (feedFilePlan, 1, "TST", row, dataTable);
Assert.AreEqual (1, dataTable.Rows.Count);
var dataRow = dataTable.Rows [0];
Assert.IsNotNull (dataRow);
var intVal = (int)dataRow ["intColumn"];
var stringVal = (string)dataRow ["strColumn"];
var boolVal = (bool)dataRow ["boolColumn"];
var floatVal = (float)dataRow ["floatColumn"];
Assert.AreEqual (42, intVal);
Assert.AreEqual ("foo", stringVal);
Assert.AreEqual (true, boolVal);
Assert.AreEqual (10.0f, floatVal);
}
public static void Read(RowProcessor proc, System.IO.StreamReader file, string sep, bool hasHeader)
{
string[] header = null;
string[] read = null;
string data;
if (hasHeader)
{
if ((data = file.ReadLine()) != null)
{
header = data.Split(sep[0]);
}
}
while ((data = file.ReadLine()) != null)
{
read = data.Split(sep[0]);
proc.ProcessRow(header, read);
}
}
public static void DeserializeWithHeader(TextReader textReader, RowProcessor rowProcessor)
{
Dictionary <string, string> keyedRow = new Dictionary <string, string>();
string[] header = new string[] {};
int index;
bool initialized = false;
int maxLength = 0;
for (List <string> rawRow = ParseRow(textReader, ',', '"', maxLength); rawRow != null; rawRow = ParseRow(textReader, ',', '"', maxLength))
{
index = 0;
if (!initialized)
{
header = rawRow.ToArray();
}
else
{
keyedRow = new Dictionary <string, string>();
foreach (string match in rawRow)
{
keyedRow.Add(header[index], match);
++index;
}
}
if (initialized)
{
rowProcessor(keyedRow);
}
else
{
initialized = true;
}
maxLength = (maxLength > rawRow.Count ? maxLength : rawRow.Count);
}
}
public static int addRowsWithDataGrid(
DataGridView dataGrid,
DataGridRowValidator validate, RowProcessor rowProc, ErrorCallBack callback)
{
DataGridViewRow lastRow = dataGrid.Rows[dataGrid.Rows.Count - 1];
string missingCol;
foreach (DataGridViewRow r in dataGrid.Rows)
{
if (validate(r, out missingCol))
{
rowProc(r.Cells);
}
else if (r != lastRow && dataGrid.AllowUserToAddRows)
{
callback(missingCol);
return -1;
}
}
return dataGrid.Rows.Count - (dataGrid.AllowUserToAddRows ? 1 : 0);
}
public static void DeserializeWithHeader(string path, RowProcessor rowProcessor)
{
DeserializeWithHeader(new StreamReader(path), rowProcessor);
}
protected virtual void ReadHotfixes <T>(IDictionary <int, T> storage, DBReader dbReader, RowProcessor processor = null) where T : class, new()
{
var fieldCache = typeof(T).GetFields().Select(x => new FieldCache <T>(x)).ToArray();
if (processor == null)
{
processor = DefaultProcessor;
}
// Id fields need to be excluded if not inline
if (dbReader.Flags.HasFlagExt(DB2Flags.Index))
{
fieldCache[dbReader.IdFieldIndex].IndexMapField = true;
}
// TODO verify hotfixes need to be applied sequentially
var records = _reader.GetRecords(dbReader.TableHash).OrderBy(x => x.PushId);
// Check if there are any valid cached records with data, don't remove row if so.
// Example situation: Blizzard has invalidated TACTKey records in the same DBCache as valid ones.
// Without the below check, valid cached TACTKey records would be removed by the invalidated records afterwards.
// This only seems to be relevant for cached tables and specifically TACTKey, BroadcastText/ItemSparse only show up single times it seems.
var shouldDelete = dbReader.TableHash != 3744420815 || !records.Any(r => r.IsValid && r.PushId == -1 && r.DataSize > 0);
foreach (var row in records)
{
var operation = processor(row, shouldDelete);
if (operation == RowOp.Add)
{
T entry = new T();
row.GetFields(fieldCache, entry);
storage[row.RecordId] = entry;
}
else if (operation == RowOp.Delete)
{
storage.Remove(row.RecordId);
}
}
}
public void ApplyHotfixes <T>(IDictionary <int, T> storage, DBReader dbReader, RowProcessor processor) where T : class, new() => ReadHotfixes(storage, dbReader, processor);
/// <summary>
/// Creates a new instance of EntityHandler.
/// </summary>
/// <param name="entity">The Entity Type that objects returned from handle() are created from.</param>
/// <param name="processor">The RowProcessor implementation to use when converting rows into entities.</param>
public EntityHandler(Entity entity, RowProcessor processor)
{
this.entType = entity;
this.processor = processor;
}
/// <summary>
/// Creates a new instance of PageInfoHandler.
/// </summary>
/// <param name="type">The type that objects returned from handle() are created from.</param>
public PageFilterHandler(Type type)
{
this.type = type;
this.processor = new BasicRowProcesor();
}
/// <summary>
/// Creates a new instance of BeanHandler.
/// </summary>
/// <param name="type">The type that objects returned from handle() are created from.</param>
/// <param name="processor">The RowProcessor implementation to use when converting rows into beans.</param>
public BeanHandler(Type type, RowProcessor processor)
{
this.type = type;
this.processor = processor;
}
public void RowTransformationTest()
{
var rowProcessor = new RowProcessor {
MethodResolvers = methodResolver
};
var result = rowProcessor.TransformRow (1, "ARC", 0, feedFilePlan, new[] {
"Sterling",
"Archer",
"40",
"85",
"2",
"anotherIgnoredValue"
});
Assert.IsTrue (result.Keys.Count == 4);
Assert.IsTrue (result.ContainsKey ("FirstName"));
Assert.IsTrue (result.ContainsKey ("LastName"));
Assert.IsTrue (result.ContainsKey ("ComputedValue"));
Assert.IsTrue (result.ContainsKey ("FullName"));
Assert.AreEqual ("Sterling", result ["FirstName"]);
Assert.AreEqual ("Archer", result ["LastName"]);
Assert.AreEqual ("42", result ["ComputedValue"]);
Assert.AreEqual ("Mr. Sterling Archer, the world's most dangerous spy.",
result ["FullName"]);
}
