public override bool Equals(object obj) { TableTwo p = obj as TableTwo; if (p == null || p.name != name || p.capacity != this.capacity || !p.fieldNames.SequenceEqual(this.fieldNames) || !p.fieldDataTypeNames.SequenceEqual(this.fieldDataTypeNames)) { return(false); } for (int i = 0; i < capacity; i++) { bool containsRow = ContainsRow(i); if (containsRow != p.ContainsRow(i)) { return(false); } if (containsRow && !this[i].valuesAsStrings.SequenceEqual(p[i].valuesAsStrings)) { return(false); } } return(true); }
public void InsertToTable(TableTwo pTable) { pTable._usedRows[row] = true; TableRow tr = pTable.GetRow(row); tr.valuesAsStrings = values; }
private void AddFieldsToTable(TableTwo pTable, string[] pFieldNames, string[] pDataTypeNames) { D.assert(pFieldNames.Length == pDataTypeNames.Length, "field definitions does not match"); for (int i = 0; i < pFieldNames.Length; i++) { Type genericType = typeof(TableField <>); string dataTypeName = pDataTypeNames[i]; //Console.WriteLine(dataTypeName); Type[] typeArgs = null; // Check through all assemblies for the type arguemnts foreach (Assembly assm in AppDomain.CurrentDomain.GetAssemblies()) { typeArgs = new Type[] { assm.GetType(dataTypeName) }; if (typeArgs[0] != null) { break; //found type } } D.isNull(typeArgs[0], dataTypeName + " was not found "); Type repositoryType = genericType.MakeGenericType(typeArgs); ITableField result = (ITableField)Activator.CreateInstance(repositoryType, pFieldNames[i]); pTable.AddField(result); } }
public static T Create <T>(TableTwo pTable) where T : RelayObjectTwo { Type t = typeof(T); T newItem = Activator.CreateInstance(t) as T; newItem.CreateNewRelayEntry(pTable, t.Name); return(newItem); }
public void CreateNewRelayEntry(TableTwo pTable, string pClassName) { table = pTable; objectId = table.CreateRow().row; table.EnsureField <string>(CSHARP_CLASS_FIELD_NAME); table.SetValue <string>(objectId, CSHARP_CLASS_FIELD_NAME, pClassName); SetupCells(); }
public void LoadFromExistingRelayEntry(TableTwo pTable, int pObjectID, string pClassName) { table = pTable; objectId = pObjectID; #if DEBUG D.assert(table.ContainsRow(objectId), "object id does not exist! " + objectId); D.assert(table.GetValue <string>(pObjectID, CSHARP_CLASS_FIELD_NAME) == pClassName, "classname missmatch!"); #endif SetupCells(); }
public TableTwo CreateTable(string pTableName) { #if DEBUG if (tables.ContainsKey(pTableName)) { throw new RelayException("Database already contains a table with name " + pTableName); } #endif TableTwo newTable = new TableTwo(pTableName); tables.Add(pTableName, newTable); return(newTable); }
public IEnumerable <float> Load(string pFilename) { #if PRINT_TIME_DATA DateTime startTime = DateTime.Now; #endif FileStream f = new FileStream(pFilename, FileMode.Open); StreamReader sw = new StreamReader(f); while (!sw.EndOfStream) { string tableName = sw.ReadLine(); int tableCount = Convert.ToInt32(sw.ReadLine()); string[] fieldNames = JsonConvert.DeserializeObject <string[]>(sw.ReadLine()); string[] typeNames = JsonConvert.DeserializeObject <string[]>(sw.ReadLine()); TableTwo newTable = new TableTwo(tableName); AddFieldsToTable(newTable, fieldNames, typeNames); for (int i = 0; i < tableCount; i++) { SerializableTableRow r = JsonConvert.DeserializeObject <SerializableTableRow>(sw.ReadLine()); if (r.row >= newTable.capacity) { newTable.SetCapacity(r.row + 1); } r.InsertToTable(newTable); } tables.Add(newTable.name, newTable); yield return(((float)sw.BaseStream.Position) / ((float)sw.BaseStream.Length)); } f.Flush(); f.Close(); f.Dispose(); #if PRINT_TIME_DATA TimeSpan span = DateTime.Now - startTime; Console.WriteLine("Loading " + pFilename + " took " + span.TotalSeconds + " seconds"); #endif }
public RelayTreeRunner(RelayTwo pRelay, string pTableName) { D.isNull(pRelay); if (!pRelay.tables.ContainsKey(pTableName)) { pRelay.CreateTable(pTableName); } _table = pRelay.GetTable(pTableName); List <RelayTreeNode> nodes = InstantiatorTwo.Process <RelayTreeNode>(_table); foreach (RelayTreeNode t in nodes) { D.assert(t.hasSetupCells, "an object of type " + t.GetType().Name + " did not call base method of SetupCells"); _nodes.Add(t.objectId, t); t.SetRunner(this); } foreach (RelayTreeNode t in nodes) { t.RestoreRelations(); } }
public RelayTwo Subset(string pTableName, Func <TableRow, bool> pPredicate) { RelayTwo relaySubset = new RelayTwo(); TableTwo tableSubset = relaySubset.CreateTable(pTableName); TableTwo sourceTable = tables[pTableName]; foreach (ITableField f in sourceTable.fields) { tableSubset.AddField(f.GetEmptyCopy()); } tableSubset.SetCapacity(sourceTable.capacity); foreach (TableRow sourceRow in sourceTable.Where(pPredicate)) { SerializableTableRow newRow = sourceRow.GetSerializableTableRow(); newRow.InsertToTable(tableSubset); //Console.WriteLine("added row " + newRow.row); } return(relaySubset); }
public static List <T> Process <T>(TableTwo pTable, Type[] pSubTypes) where T : RelayObjectTwo { Type[] subTypes = pSubTypes; //int[] objectIds = pTable.GetIndexesOfPopulatedRows(); List <T> newInstances = new List <T>(); foreach (TableRow tr in pTable) { string className = tr.Get <string>(RelayObjectTwo.CSHARP_CLASS_FIELD_NAME); Type type = GetType(className, subTypes); if (type == null) { throw new CantFindClassWithNameException("Can't find class with name " + className + " to instantiate"); } T newInstance = Activator.CreateInstance(type) as T; D.isNull(newInstance); newInstance.LoadFromExistingRelayEntry(pTable, tr.row, className); newInstances.Add(newInstance); } return(newInstances); }
/// <summary> /// Append all entries in all tables, source IDs will be discarded. /// </summary> public void AppendTables(RelayTwo pRelay) { RelayTwo additiveRelay = pRelay; // Cycle through all new tables in the loaded relay foreach (String tableName in additiveRelay.tables.Keys) { TableTwo fromTable = additiveRelay.tables[tableName]; // If the table already exists, append the entries from the new table. if (tables.ContainsKey(tableName)) { TableTwo toTable = tables[tableName]; // Ensure that all fields exists in the old table. foreach (ITableField f in fromTable.fields) { if (!toTable.fieldNames.Contains(f.name)) { toTable.AddField(f.GetEmptyCopy()); } } foreach (TableRow fromRow in fromTable) { TableRow toRow = toTable.CreateRow(); foreach (ITableField fromField in fromTable.fields) { ITableField toField = toTable.GetField(fromField.name); toField.SetValueFromString(toRow.row, fromField.GetValueAsString(fromRow.row)); } } } else { this.tables[fromTable.name] = fromTable; } } }
internal TableRow(TableTwo pTable, int pRow) { _table = pTable; _row = pRow; }
public void MergeWith(RelayTwo pSource) { foreach (TableTwo targetTable in tables.Values) { if (pSource.tables.ContainsKey(targetTable.name)) { TableTwo sourceTable = pSource.tables[targetTable.name]; // Add missing fields to targetTable foreach (ITableField field in sourceTable.fields) { if (!targetTable.fieldNames.Contains(field.name)) { targetTable.AddField(field.GetEmptyCopy()); } } // Add missing fields to sourceTable foreach (ITableField field in targetTable.fields) { if (!sourceTable.fieldNames.Contains(field.name)) { sourceTable.AddField(field.GetEmptyCopy()); } } if (sourceTable.capacity > targetTable.capacity) { targetTable.SetCapacity(sourceTable.capacity); } foreach (TableRow r in sourceTable) { SerializableTableRow sr = r.GetSerializableTableRow(); if (targetTable.ContainsRow(sr.row)) { throw new RelayMergeException("table " + targetTable.name + " does already contain row " + sr.row); } sr.InsertToTable(targetTable); } } } // Copy complete tables from subsetB if they don't exist in this relay foreach (TableTwo tableB in pSource.tables.Values) { if (!tables.ContainsKey(tableB.name)) { TableTwo newTable = CreateTable(tableB.name); // Add fields to the new table foreach (ITableField field in tableB.fields) { newTable.AddField(field.GetEmptyCopy()); } newTable.SetCapacity(tableB.capacity); foreach (TableRow r in tableB) { SerializableTableRow sr = r.GetSerializableTableRow(); sr.InsertToTable(newTable); } } } }
public static List <T> Process <T>(TableTwo pTable) where T : RelayObjectTwo { return(Process <T>(pTable, typeof(T))); }
public static List <T> Process <T>(TableTwo pTable, Type pType) where T : RelayObjectTwo { Type[] subTypes = GetSubclasses(pType); return(Process <T>(pTable, subTypes)); }