public static void SaveDefinitionStub(string file, DataHolderDefinition dataHolderDef)
{
XmlDataHolderDefinition holderDefinition = new XmlDataHolderDefinition()
{
Name = dataHolderDef.Name,
DefaultTables = new string[1] {
" "
},
Fields = new DataFieldDefinition[dataHolderDef.Fields.Count]
};
int num = 0;
foreach (IDataField field in dataHolderDef.Fields.Values)
{
holderDefinition.Fields[num++] = LightDBMgr.DataFieldCreators[(int)field.DataFieldType](field);
}
LightRecordXmlConfig lightRecordXmlConfig = new LightRecordXmlConfig();
lightRecordXmlConfig.FileName = file;
lightRecordXmlConfig.DataHolders = new XmlDataHolderDefinition[1]
{
holderDefinition
};
lightRecordXmlConfig.Save();
}
private List <T> GetKeyValuePairs <T>(IDataHolder obj, Func <TableDefinition, T> listCreator)
where T : KeyValueListBase
{
DataHolderDefinition holderDefinition = this.m_mapping.GetDataHolderDefinition(obj.GetType());
List <T> source = new List <T>(this.m_mapping.TableDefinitions.Length);
for (int index1 = 0; index1 < this.m_mapping.TableDefinitions.Length; ++index1)
{
TableDefinition table = this.m_mapping.TableDefinitions[index1];
for (int index2 = 0; index2 < table.ColumnDefinitions.Length; ++index2)
{
SimpleDataColumn columnDefinition = table.ColumnDefinitions[index2];
for (int index3 = 0; index3 < columnDefinition.FieldList.Count; ++index3)
{
IFlatDataFieldAccessor field = columnDefinition.FieldList[index3];
if (field.DataHolderDefinition == holderDefinition)
{
T obj1 = source.FirstOrDefault <T>((Func <T, bool>)(l => l.TableName == table.Name));
if ((object)obj1 == null)
{
source.Add(obj1 = listCreator(table));
}
object obj2 = field.Get(obj);
obj1.AddPair(columnDefinition.ColumnName, (object)obj2.ToString());
}
}
}
}
return(source);
}
internal void SetMainDataHolder(DataHolderDefinition dataDef, bool isDefaultTable)
{
if (this.MainDataHolder != null)
{
return;
}
this.m_mainDataHolder = dataDef;
this.m_isDefaultTable = isDefaultTable;
}
internal void SetMainDataHolder(DataHolderDefinition dataDef, bool isDefaultTable)
{
if (MainDataHolder != null)
{
return;
//throw new DataHolderException("Table was set as DefaultTable for more than one DataHolder: \"" + dataDef + "\" and \"" + MainDataHolder + "\"");
}
m_mainDataHolder = dataDef;
m_isDefaultTable = isDefaultTable;
}
public static void CompleteStep2(DataHolderDefinition dataHolder, string filterText = null)
{
if (filterText != null)
{
UIMap.FilterDatasetsDatatables(filterText);
}
UIMap.SelectDatasetOrDatatableByName(dataHolder.Name.Replace(",", "\\,"));
UIMap.NextButton().WaitForControlEnabled();
UIMap.ClickNextButton();
}
public void SaveCache(string filename)
{
using (BinaryWriter writer =
new BinaryWriter((Stream) new FileStream(filename, FileMode.Create, FileAccess.Write)))
{
this.WriteHeader(writer);
for (int index = 0; index < this.m_mapping.DataHolderDefinitions.Length; ++index)
{
DataHolderDefinition holderDefinition = this.m_mapping.DataHolderDefinitions[index];
object obj = holderDefinition.CacheGetter.Invoke((object)null, new object[0]);
new BinaryContentStream(holderDefinition).WriteAll(writer, (IEnumerable)obj);
}
}
}
public static void SaveDefinitionStub(string file, DataHolderDefinition dataHolderDef)
{
var def = new XmlDataHolderDefinition {
Name = dataHolderDef.Name,
DefaultTables = new[] { " " },
Fields = new DataFieldDefinition[dataHolderDef.Fields.Count]
};
int i = 0;
foreach (var field in dataHolderDef.Fields.Values)
{
def.Fields[i++] = DataFieldCreators[(int)field.DataFieldType](field);
}
var cfg = new LightRecordXmlConfig {
FileName = file,
DataHolders = new[] { def }
};
cfg.Save();
}
private static bool AddTables(ICollection <DataHolderDefinition> allDefs, DataHolderDefinition def,
Dictionary <DataHolderDefinition, List <TableDefinition> > dataHolderToTable,
HashSet <DataHolderDefinition> dataHolders, HashSet <TableDefinition> tables)
{
if (!allDefs.Contains(def))
{
return(false);
}
allDefs.Remove(def);
dataHolders.Add(def);
foreach (TableDefinition tableDefinition in dataHolderToTable[def])
{
tables.Add(tableDefinition);
foreach (DataHolderDefinition holderDefinition in tableDefinition.DataHolderDefinitions)
{
dataHolders.Add(holderDefinition);
AddTables(allDefs, holderDefinition, dataHolderToTable, dataHolders, tables);
}
}
return(true);
}
private List <KeyValuePair <string, object> > GetWherePairs(TableDefinition table, IDataHolder obj)
{
DataHolderDefinition holderDefinition = this.m_mapping.GetDataHolderDefinition(obj.GetType());
List <KeyValuePair <string, object> > keyValuePairList = new List <KeyValuePair <string, object> >(2);
foreach (PrimaryColumn primaryColumn in table.PrimaryColumns)
{
foreach (IFlatDataFieldAccessor field in primaryColumn.DataColumn.FieldList)
{
if (field.DataHolderDefinition == holderDefinition)
{
object obj1 = field.Get(obj);
if (obj1 != null)
{
keyValuePairList.Add(
new KeyValuePair <string, object>(primaryColumn.Name, (object)obj1.ToString()));
}
}
}
}
return(keyValuePairList);
}
static bool AddTables(ICollection <DataHolderDefinition> allDefs,
DataHolderDefinition def,
Dictionary <DataHolderDefinition, List <TableDefinition> > dataHolderToTable,
HashSet <DataHolderDefinition> dataHolders,
HashSet <TableDefinition> tables)
{
if (allDefs.Contains(def))
{
allDefs.Remove(def);
dataHolders.Add(def);
foreach (var table in dataHolderToTable[def])
{
tables.Add(table);
foreach (var dataHolder in table.DataHolderDefinitions)
{
dataHolders.Add(dataHolder);
AddTables(allDefs, dataHolder, dataHolderToTable, dataHolders, tables);
}
}
return(true);
}
return(false);
}
public string CodeFromDataHolder(DataHolderDefinition dh)
{
return(ChainType == ChainTypes.TimeSeries
? ((Dataset)dh).Code
: ((Datatable)dh).Code);
}
public DataFieldProxy(string fieldName, DataHolderDefinition dataHolderDef)
{
m_FieldName = fieldName;
m_DataHolderDef = dataHolderDef;
}
/// <summary>
/// Fetches all sets of objects, defined through the given mapping.
/// </summary>
/// <returns></returns>
public void Fetch()
{
// Map of objects, mapped by DataHolder-Type, DataHolder-Id and field-Name
//var objects = new Dictionary<Type, Dictionary<object, Dictionary<string, object>>>();
var actions = new List <Action>(10000);
var tables = m_mapping.TableDefinitions;
DataHolderDefinition holderDef = null;
for (var t = 0; t < tables.Length; t++)
{
var table = tables[t];
try
{
using (var rs = m_db.CreateReader(table, t))
{
var mappedFields = table.ColumnDefinitions;
while (rs.Read())
{
var id = table.GetId(rs);
DataHolderDefinition lastDataHolderDef = null;
IDataHolder lastDataHolder = null;
object value = null;
SimpleDataColumn column = null;
int columnN;
try
{
for (columnN = 0; columnN < mappedFields.Length; columnN++)
{
column = mappedFields[columnN];
value = null;
value = column.ReadValue(rs);
for (var i = 0; i < column.FieldList.Count; i++)
{
var dataField = column.FieldList[i];
holderDef = dataField.DataHolderDefinition;
if (holderDef == null)
{
throw new DataHolderException(
"Invalid DataField did not have a DataHolderDefinition: " +
dataField);
}
IDataHolder holder;
if (lastDataHolderDef != dataField.DataHolderDefinition || lastDataHolder == null)
{
// only get the DataHolder, if its different from the last one
var dataHolders = dataHolderMap.GetOrCreate(holderDef.Type);
if (!dataHolders.TryGetValue(id, out holder))
{
// create new DataHolder object if this is one of the DataHolder's default tables
if (!table.IsDefaultTable)
{
// ignore DataHolders that are not defined in their DefaultTables
LightDBMgr.OnInvalidData(
"Invalid DataHolder was not defined in its Default-Tables - " +
"DataHolder: {0}; Id(s): {1}; Table: {2}", holderDef, id, table);
// little trick to skip the parent loop
columnN = mappedFields.Length;
break;
}
// init with Id(s)
dataHolders.Add(id, holder = (IDataHolder)holderDef.CreateHolder(value));
//table.SetDefaults(id, holder);
actions.Add(holder.FinalizeDataHolder);
}
lastDataHolder = holder;
lastDataHolderDef = holderDef;
}
else
{
holder = lastDataHolder;
}
// set value
dataField.Set(holder, value);
}
}
}
catch (Exception e)
{
var ids = (id is Array ? ((object[])id) : new[] { id });
throw new DataHolderException(e, "Unable to parse data-cell (Column: {0}, Id(s): {1}{2})", column,
ids.ToString(", ", (idObj) => {
return(idObj.GetType().IsEnum ? Convert.ChangeType(idObj, Enum.GetUnderlyingType(idObj.GetType())) : idObj);
}), value != null ? (", Value: " + value) : "");
}
}
}
}
catch (Exception e)
{
throw new DataHolderException(e, "Failed to read from Table \"{0}\" {1}", table,
holderDef != null ? ("DataHolder: " + holderDef) : "");
}
}
for (var i = 0; i < actions.Count; i++)
{
var action = actions[i];
action();
}
dataHolderMap.Clear();
m_fetched = true;
}
public DataFieldProxy(string fieldName, DataHolderDefinition dataHolderDef)
{
this.m_FieldName = fieldName;
this.m_DataHolderDef = dataHolderDef;
}
public TableDefinition[] EnsureTables(string tableName, DataHolderDefinition def)
{
return(EnsureTables(tableName, GetDefaultTables(def)));
}
public TableDefinition[] GetDefaultTables(DataHolderDefinition def)
{
TableDefinition[] tableDefinitionArray;
DefaultTables.TryGetValue(def.Name, out tableDefinitionArray);
return(tableDefinitionArray);
}
private void RegisterDefintion(LightRecordXmlConfig cfg, Dictionary <string, List <SimpleDataColumn> > fieldMap)
{
DataHolderDefinition[] holderDefinitions = DataHolderDefinitions;
XmlDataHolderDefinition holderDefinition1 = null;
foreach (XmlDataHolderDefinition holderDefinition2 in cfg)
{
XmlDataHolderDefinition dataRawDef = holderDefinition2;
try
{
if (dataRawDef.Name == null)
{
throw new DataHolderException("Invalid DataHolder-definition has no name ({0}).", holderDefinition1 == null
? (object)"First in file"
: (object)("After: " + (object)holderDefinition1));
}
dataRawDef.EnsureFieldsNotNull();
DataHolderDefinition dataDef = holderDefinitions
.Where(def =>
def.Name.Equals(dataRawDef.Name, StringComparison.InvariantCultureIgnoreCase))
.FirstOrDefault();
if (dataDef == null)
{
LightDBMgr.OnInvalidData("Invalid DataHolder-definition refers to non-existing DataHolder: " +
dataRawDef.Name);
}
else
{
TableDefinition[] tableDefinitionArray;
TableDefinition[] array;
if (DefaultTables.TryGetValue(dataDef.Name, out tableDefinitionArray))
{
array = tableDefinitionArray;
}
else
{
array = null;
tableDefinitionArray = dataRawDef.DefaultTables == null
? new TableDefinition[0]
: new TableDefinition[dataRawDef.DefaultTables.Length];
}
for (int index = 0; index < tableDefinitionArray.Length; ++index)
{
string key = dataRawDef.DefaultTables[index].Trim();
TableDefinition tableDefinition;
if (!TableDefinitionMap.TryGetValue(key, out tableDefinition))
{
throw new DataHolderException(
"DefaultTable \"{0}\" of DataHolder \"{1}\" is not defined - Make sure to define the table in the Table collection.",
(object)key, (object)dataRawDef);
}
tableDefinitionArray[index] = tableDefinition;
tableDefinition.SetMainDataHolder(dataDef, true);
}
DefaultTables[dataDef.Name] = tableDefinitionArray;
if (dataRawDef.DataHolderName.Contains("Trainer"))
{
ToString();
}
AddFieldMappings(dataRawDef.Fields,
dataDef.Fields, fieldMap);
if (array != null)
{
int length = array.Length;
Array.Resize(ref array, array.Length + tableDefinitionArray.Length);
Array.Copy(tableDefinitionArray, 0, array, length,
tableDefinitionArray.Length);
DefaultTables[dataDef.Name] = array;
}
holderDefinition1 = dataRawDef;
}
}
catch (Exception ex)
{
throw new DataHolderException(ex,
"Failed to parse DataHolder-definition \"" + dataRawDef + "\" from {0}", (object)cfg.FileName);
}
}
}
public static DataHolderTableMapping[] CreateDataHolderTableMappings(
Dictionary <TableDefinition, List <DataHolderDefinition> > tableDataHolderMap,
DataHolderDefinition[] dataHolderDefinitions)
{
Dictionary <DataHolderDefinition, List <TableDefinition> > dictionary =
new Dictionary <DataHolderDefinition, List <TableDefinition> >();
foreach (KeyValuePair <TableDefinition, List <DataHolderDefinition> > tableDataHolder in tableDataHolderMap)
{
if (tableDataHolder.Value == null)
{
log.Warn(
"Table-definition \"{0}\" has no used columns (and can possibly be removed from the config).");
}
else
{
tableDataHolder.Key.DataHolderDefinitions = tableDataHolder.Value.ToArray();
foreach (DataHolderDefinition holderDefinition in tableDataHolder.Key.DataHolderDefinitions)
{
dictionary.GetOrCreate(holderDefinition)
.Add(tableDataHolder.Key);
}
}
}
List <DataHolderTableMapping> holderTableMappingList = new List <DataHolderTableMapping>();
HashSet <DataHolderDefinition> holderDefinitionSet1 =
new HashSet <DataHolderDefinition>(
dictionary.Keys.ToArray());
HashSet <DataHolderDefinition> holderDefinitionSet2 = new HashSet <DataHolderDefinition>();
HashSet <TableDefinition> tableDefinitionSet = new HashSet <TableDefinition>();
foreach (DataHolderDefinition key in dictionary.Keys)
{
if (AddTables(holderDefinitionSet1, key,
dictionary, holderDefinitionSet2, tableDefinitionSet))
{
DataHolderTableMapping holderTableMapping = new DataHolderTableMapping(
holderDefinitionSet2.ToArray(),
tableDefinitionSet.ToArray());
holderTableMappingList.Add(holderTableMapping);
holderDefinitionSet2.Clear();
tableDefinitionSet.Clear();
}
}
foreach (TableDefinition key in tableDataHolderMap.Keys)
{
TableDefinition table = key;
foreach (SimpleDataColumn columnDefinition in table.ColumnDefinitions)
{
if (columnDefinition is IDataFieldBase)
{
DataHolderDefinition holderDefinition =
((IDataFieldBase)columnDefinition).DataHolderDefinition;
if (!holderDefinitionSet2.Contains(holderDefinition))
{
DataHolderTableMapping holderTableMapping =
holderTableMappingList.Find(map =>
map.TableDefinitions.Contains(
table));
DataHolderDefinition[] holderDefinitions = holderTableMapping.DataHolderDefinitions;
holderTableMapping.DataHolderDefinitions =
new DataHolderDefinition[holderDefinitions.Length + 1];
Array.Copy(holderDefinitions, holderTableMapping.TableDefinitions,
holderDefinitions.Length);
holderTableMapping.DataHolderDefinitions[holderDefinitions.Length] = holderDefinition;
}
}
}
}
return(holderTableMappingList.ToArray());
}
private void FinishLoading(Dictionary <string, List <SimpleDataColumn> > fieldMap)
{
foreach (KeyValuePair <string, List <SimpleDataColumn> > field1 in fieldMap)
{
TableDefinition table = GetTable(field1.Key);
SimpleDataColumn[] fields = field1.Value.ToArray();
if (!string.IsNullOrEmpty(table.MainDataHolderName))
{
DataHolderDefinition dataDef = DataHolderDefinitions
.Where(dataHolderDef =>
dataHolderDef.Name.Equals(table.MainDataHolderName,
StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();
if (dataDef == null)
{
throw new DataHolderException("Table \"{0}\" refered to invalid MainDataHolder: {1}", (object)table,
(object)table.MainDataHolderName);
}
table.SetMainDataHolder(dataDef, false);
}
try
{
List <PrimaryColumn> primaryColumnList = new List <PrimaryColumn>();
primaryColumnList.AddRange(table.PrimaryColumns);
for (int index = 0; index < fields.Length; ++index)
{
SimpleDataColumn field = fields[index];
PrimaryColumn primaryColumn = primaryColumnList
.Where(
primCol => primCol.Name == field.ColumnName)
.FirstOrDefault();
if (primaryColumn != null)
{
primaryColumn.DataColumn = field;
field.IsPrimaryKey = true;
primaryColumnList.Remove(primaryColumn);
}
if (field.ColumnName == null && field.DefaultValue == null)
{
LightDBMgr.OnInvalidData(
"Field-definition \"{0}\" did not define a Column nor a DefaultValue.", (object)field);
}
}
for (int index1 = 0; index1 < fields.Length; ++index1)
{
SimpleDataColumn simpleDataColumn1 = fields[index1];
for (int index2 = 0; index2 < simpleDataColumn1.FieldList.Count; ++index2)
{
IFlatDataFieldAccessor field2 = simpleDataColumn1.FieldList[index2];
if (field2.DataHolderDefinition.DependingField == field2)
{
SimpleDataColumn simpleDataColumn2 = fields[0];
fields[0] = simpleDataColumn1;
fields[index1] = simpleDataColumn2;
}
}
}
if (primaryColumnList.Count > 0 && table.MainDataHolder == null)
{
throw new DataHolderException(
"Table \"{0}\" referenced PrimaryColumn(s) ({1}) but did not define a MainDataHolder explicitely.",
(object)table, (object)primaryColumnList.ToString(", "));
}
if (primaryColumnList.Count > 0 || table.Variables != null && table.Variables.Length > 0)
{
int num1 = table.Variables != null ? table.Variables.Length : 0;
int destinationIndex = num1 + primaryColumnList.Count;
SimpleDataColumn[] simpleDataColumnArray =
new SimpleDataColumn[fields.Length + destinationIndex];
Array.Copy(fields, 0, simpleDataColumnArray, destinationIndex, fields.Length);
fields = simpleDataColumnArray;
if (num1 > 0)
{
InitVars(table, fields);
}
int num2 = num1;
foreach (PrimaryColumn primaryColumn in primaryColumnList)
{
DataFieldProxy dataFieldProxy =
new DataFieldProxy(primaryColumn.Name, table.MainDataHolder);
IFieldReader reader = Converters.GetReader(primaryColumn.TypeName);
if (reader == null)
{
throw new DataHolderException(
"Invalid Type \"" + primaryColumn.TypeName + "\" for PrimaryColumn \"" +
primaryColumn.Name + "\" in definition for Table: " + table +
" - You must explicitely define the TypeName attribute inside the PrimaryColumn node, if it is only an additional table for a DataHolder!");
}
SimpleDataColumn simpleDataColumn = new SimpleDataColumn(primaryColumn.Name, reader, 0)
{
IsPrimaryKey = true
};
simpleDataColumn.FieldList.Add(dataFieldProxy);
fields[num2++] = primaryColumn.DataColumn = simpleDataColumn;
}
}
int num = 0;
for (int index = 0; index < fields.Length; ++index)
{
SimpleDataColumn simpleDataColumn = fields[index];
if (simpleDataColumn.DefaultValue == null)
{
simpleDataColumn.m_index = num++;
}
else
{
simpleDataColumn.Reader = null;
}
}
TableDefinitionMap[field1.Key].ColumnDefinitions = fields;
}
catch (Exception ex)
{
throw new DataHolderException(ex, "Unable to setup Table \"{0}\" (MainDataHolder: \"{1}\")", (object)table,
(object)table.MainDataHolder);
}
}
m_mappings =
CreateDataHolderTableMappings(m_tableDataHolderMap,
DataHolderDefinitions);
}
protected DataFieldBase(DataHolderDefinition dataHolder, IGetterSetter accessor, INestedDataField parent)
{
this.m_DataHolderDefinition = dataHolder;
this.m_parent = parent;
this.m_accessor = accessor;
}
private void FinishLoading(Dictionary <string, List <SimpleDataColumn> > fieldMap)
{
// bind mapping-objects to tables
foreach (var pair in fieldMap)
{
var table = GetTable(pair.Key);
var fields = pair.Value.ToArray();
if (!string.IsNullOrEmpty(table.MainDataHolderName))
{
DataHolderDefinition defaultDef = DataHolderDefinitions.Where(dataHolderDef =>
dataHolderDef.Name.Equals(table.MainDataHolderName,
StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();
if (defaultDef == null)
{
throw new DataHolderException("Table \"{0}\" refered to invalid MainDataHolder: {1}", table,
table.MainDataHolderName);
}
table.SetMainDataHolder(defaultDef, false);
}
try
{
var primCols = new List <PrimaryColumn>();
primCols.AddRange(table.PrimaryColumns);
// find Primary Columns, set defaults and consider depending fields
for (var i = 0; i < fields.Length; i++)
{
var field = fields[i];
var col = primCols.Where(primCol => primCol.Name == field.ColumnName).FirstOrDefault();
if (col != null)
{
col.DataColumn = field;
field.IsPrimaryKey = true;
primCols.Remove(col);
//var tmp = fields[0];
//fields[0] = field;
//fields[i] = tmp;
}
if (field.ColumnName == null && field.DefaultValue == null)
{
LightDBMgr.OnInvalidData("Field-definition \"{0}\" did not define a Column nor a DefaultValue.", field);
}
}
// put the depending Fields first (if any)
for (var i = 0; i < fields.Length; i++)
{
var field = fields[i];
for (var j = 0; j < field.FieldList.Count; j++)
{
var dataField = field.FieldList[j];
var dataHolder = dataField.DataHolderDefinition;
if (dataHolder.DependingField == dataField)
{
var tmp = fields[0];
fields[0] = field;
fields[i] = tmp;
}
}
}
//if (primCols.Count() > 0)
//{
// throw new DataHolderException("Table-definition \"{0}\" refered to non-existing PrimaryKey(s): {1}",
// pair.Key, primCols.ToString(", "));
//}
if (primCols.Count > 0 && table.MainDataHolder == null)
{
throw new DataHolderException("Table \"{0}\" referenced PrimaryColumn(s) ({1}) but did not define a MainDataHolder explicitely.",
table, primCols.ToString(", "));
}
// custom primary columns and variables
if (primCols.Count > 0 || (table.Variables != null && table.Variables.Length > 0))
{
var varCount = table.Variables != null ? table.Variables.Length : 0;
var extraFields = varCount + primCols.Count;
var tmpArr = new SimpleDataColumn[fields.Length + extraFields];
Array.Copy(fields, 0, tmpArr, extraFields, fields.Length);
fields = tmpArr;
if (varCount > 0)
{
InitVars(table, fields);
}
var i = varCount;
foreach (var primaryCol in primCols)
{
// PrimaryKey-field is not explicitely mapped but only used as a reference
var proxyField = new DataFieldProxy(primaryCol.Name, table.MainDataHolder);
var reader = Converters.GetReader(primaryCol.TypeName);
if (reader == null)
{
throw new DataHolderException("Invalid Type \"" + primaryCol.TypeName
+ "\" for PrimaryColumn \"" + primaryCol.Name + "\" in definition for Table: " + table + " - " +
"You must explicitely define the TypeName attribute inside the PrimaryColumn node, if it is only an additional table for a DataHolder!");
}
var col = new SimpleDataColumn(primaryCol.Name, reader, 0)
{
IsPrimaryKey = true
};
col.FieldList.Add(proxyField);
fields[i++] = primaryCol.DataColumn = col;
}
}
var index = 0;
for (var i = 0; i < fields.Length; i++)
{
var field = fields[i];
if (field.DefaultValue == null)
{
field.m_index = index++;
}
else
{
field.Reader = null;
}
}
TableDefinitionMap[pair.Key].ColumnDefinitions = fields;
}
catch (Exception ex)
{
throw new DataHolderException(ex, "Unable to setup Table \"{0}\" (MainDataHolder: \"{1}\")", table, table.MainDataHolder);
}
}
m_mappings = CreateDataHolderTableMappings(m_tableDataHolderMap, DataHolderDefinitions);
}
/// <summary>
/// Fetches all sets of objects, defined through the given mapping.
/// </summary>
/// <returns></returns>
public void Fetch()
{
List <Action> actionList = new List <Action>(10000);
TableDefinition[] tableDefinitions = this.m_mapping.TableDefinitions;
DataHolderDefinition holderDefinition1 = (DataHolderDefinition)null;
for (int tableIndex = 0; tableIndex < tableDefinitions.Length; ++tableIndex)
{
TableDefinition def = tableDefinitions[tableIndex];
try
{
using (IDataReader reader = this.m_db.CreateReader(def, tableIndex))
{
SimpleDataColumn[] columnDefinitions = def.ColumnDefinitions;
while (reader.Read())
{
object key = def.GetId(reader);
DataHolderDefinition holderDefinition2 = (DataHolderDefinition)null;
IDataHolder dataHolder1 = (IDataHolder)null;
object firstValue = (object)null;
SimpleDataColumn simpleDataColumn = (SimpleDataColumn)null;
try
{
for (int index1 = 0; index1 < columnDefinitions.Length; ++index1)
{
simpleDataColumn = columnDefinitions[index1];
firstValue = (object)null;
firstValue = simpleDataColumn.ReadValue(reader);
for (int index2 = 0; index2 < simpleDataColumn.FieldList.Count; ++index2)
{
IFlatDataFieldAccessor field = simpleDataColumn.FieldList[index2];
holderDefinition1 = field.DataHolderDefinition;
if (holderDefinition1 == null)
{
throw new DataHolderException(
"Invalid DataField did not have a DataHolderDefinition: " +
(object)field, new object[0]);
}
IDataHolder dataHolder2;
if (holderDefinition2 != field.DataHolderDefinition || dataHolder1 == null)
{
Dictionary <object, IDataHolder> dictionary =
this.dataHolderMap.GetOrCreate <Type, object, IDataHolder>(
holderDefinition1.Type);
if (!dictionary.TryGetValue(key, out dataHolder2))
{
if (!def.IsDefaultTable)
{
LightDBMgr.OnInvalidData(
"Invalid DataHolder was not defined in its Default-Tables - DataHolder: {0}; Id(s): {1}; Table: {2}",
(object)holderDefinition1, key, (object)def);
index1 = columnDefinitions.Length;
break;
}
dictionary.Add(key,
dataHolder2 =
(IDataHolder)holderDefinition1.CreateHolder(firstValue));
actionList.Add(new Action(dataHolder2.FinalizeDataHolder));
}
dataHolder1 = dataHolder2;
holderDefinition2 = holderDefinition1;
}
else
{
dataHolder2 = dataHolder1;
}
field.Set(dataHolder2, firstValue);
}
}
}
catch (Exception ex)
{
object[] objArray1;
if (!(key is Array))
{
objArray1 = new object[1] {
key
}
}
;
else
{
objArray1 = (object[])key;
}
object[] objArray2 = objArray1;
throw new DataHolderException(ex,
"Unable to parse data-cell (Column: {0}, Id(s): {1}{2})", new object[3]
{
(object)simpleDataColumn,
(object)((IEnumerable <object>)objArray2).ToString <object>(", ",
(Func <object, object>)(idObj =>
idObj.GetType().IsEnum
? Convert.ChangeType(idObj, Enum.GetUnderlyingType(idObj.GetType()))
: idObj)),
firstValue != null ? (object)(", Value: " + firstValue) : (object)""
});
}
}
}
}
catch (Exception ex)
{
throw new DataHolderException(ex, "Failed to read from Table \"{0}\" {1}", new object[2]
{
(object)def,
holderDefinition1 != null ? (object)("DataHolder: " + (object)holderDefinition1) : (object)""
});
}
}
for (int index = 0; index < actionList.Count; ++index)
{
actionList[index]();
}
this.dataHolderMap.Clear();
this.m_fetched = true;
}
