public static void MapNestedArray(this LightDBDefinitionSet defs, IDataField dataField,
IDataFieldDefinition fieldDef, Dictionary <string, List <SimpleDataColumn> > mappedFields)
{
NestedArrayFieldDefinition arrayFieldDefinition = (NestedArrayFieldDefinition)fieldDef;
NestedArrayDataField nestedArrayDataField = (NestedArrayDataField)dataField;
TableDefinition[] defaultTables =
defs.EnsureTables(arrayFieldDefinition.Table, dataField.DataHolderDefinition);
foreach (FlatArrayFieldDefinition segment in arrayFieldDefinition.Segments)
{
SimpleFlatFieldDefinition[] columns = segment.GetColumns(nestedArrayDataField.Length);
for (int index = 0; index < columns.Length; ++index)
{
SimpleFlatFieldDefinition fieldDef1 = columns[index];
IDataField dataField1;
if (!((NestedArrayAccessor)nestedArrayDataField.ArrayAccessors[index]).InnerFields.TryGetValue(
segment.Name, out dataField1))
{
throw new DataHolderException("NestedArray definition {0} refered to non-existing field {1}",
new object[2]
{
(object)nestedArrayDataField,
(object)segment
});
}
LightDBMgr.AddMapping(defs, defaultTables, fieldDef1, mappedFields,
(IFlatDataFieldAccessor)dataField1, dataField1.MappedMember);
}
}
}
public static void MapNestedArray(this LightDBDefinitionSet defs, IDataField dataField, IDataFieldDefinition fieldDef,
Dictionary <string, List <SimpleDataColumn> > mappedFields)
{
var arrField = (NestedArrayFieldDefinition)fieldDef;
var arrDataField = (NestedArrayDataField)dataField;
var defaultTables = defs.EnsureTables(arrField.Table, dataField.DataHolderDefinition);
var segments = arrField.Segments;
for (var i = 0; i < segments.Length; i++)
{
var segment = segments[i];
var cols = segment.GetColumns(arrDataField.Length);
for (var j = 0; j < cols.Length; j++)
{
var col = cols[j];
var arrAccessor = (NestedArrayAccessor)arrDataField.ArrayAccessors[j];
IDataField fieldAccessor;
if (!arrAccessor.InnerFields.TryGetValue(segment.Name, out fieldAccessor))
{
throw new DataHolderException("NestedArray definition {0} refered to non-existing field {1}", arrDataField,
segment);
}
AddMapping(defs, defaultTables, col, mappedFields,
(IFlatDataFieldAccessor)fieldAccessor, fieldAccessor.MappedMember);
}
}
}
public static void MapFlatSimple(this LightDBDefinitionSet defs, IDataField dataField,
IDataFieldDefinition fieldDef, Dictionary <string, List <SimpleDataColumn> > mappedFields)
{
SimpleFlatFieldDefinition fieldDef1 = (SimpleFlatFieldDefinition)fieldDef;
LightDBMgr.AddMapping(defs, defs.GetDefaultTables(dataField.DataHolderDefinition), fieldDef1, mappedFields,
(IFlatDataFieldAccessor)dataField, dataField.MappedMember);
}
public static void MapNestedSimple(this LightDBDefinitionSet defs, IDataField dataField, IDataFieldDefinition fieldDef,
Dictionary <string, List <SimpleDataColumn> > mappedFields)
{
var nestedFieldDefinition = ((INestedFieldDefinition)fieldDef);
nestedFieldDefinition.EnsureFieldsNotNull(dataField.DataHolderDefinition.Name);
defs.AddFieldMappings(nestedFieldDefinition.Fields, ((NestedSimpleDataField)dataField).InnerFields, mappedFields);
}
public static void MapFlatSimple(this LightDBDefinitionSet defs, IDataField dataField, IDataFieldDefinition fieldDef,
Dictionary <string, List <SimpleDataColumn> > mappedFields)
{
var tableField = ((SimpleFlatFieldDefinition)fieldDef);
AddMapping(defs, defs.GetDefaultTables(dataField.DataHolderDefinition), tableField, mappedFields,
(FlatSimpleDataField)dataField, dataField.MappedMember);
}
static void AddMapping(LightDBDefinitionSet defs, TableDefinition[] defaultTables, SimpleFlatFieldDefinition fieldDef,
Dictionary <string, List <SimpleDataColumn> > mappedFields, IFlatDataFieldAccessor accessor, MemberInfo member)
{
var column = fieldDef.Column;
var tables = defs.EnsureTables(fieldDef.Table, defaultTables);
object defaultValue;
if (!String.IsNullOrEmpty(fieldDef.DefaultStringValue))
{
defaultValue = StringParser.Parse(fieldDef.DefaultStringValue, member.GetVariableType());
}
else
{
if (String.IsNullOrEmpty(column))
{
return;
}
defaultValue = null;
}
foreach (var table in tables)
{
var dataHolders = defs.m_tableDataHolderMap.GetOrCreate(table);
if (!dataHolders.Contains(accessor.DataHolderDefinition))
{
dataHolders.Add(accessor.DataHolderDefinition);
}
var mappedFieldMap = mappedFields.GetOrCreate(table.Name);
SimpleDataColumn dataColumn;
var dbAttrs = member.GetCustomAttributes <DBAttribute>();
var attr = dbAttrs.Where(attribute => attribute is PersistentAttribute).FirstOrDefault() as PersistentAttribute;
if (String.IsNullOrEmpty(column))
{
// use default value
mappedFieldMap.Add(dataColumn = new SimpleDataColumn(fieldDef.Name, defaultValue));
}
else
{
dataColumn = mappedFieldMap.Find((cmpField) => cmpField.ColumnName == column);
if (dataColumn == null)
{
var type = member.GetActualType();
if (attr != null)
{
type = attr.ReadType ?? type;
}
var reader = Converters.GetReader(type);
mappedFieldMap.Add(dataColumn = new SimpleDataColumn(column, reader));
}
}
dataColumn.FieldList.Add(accessor);
}
}
public static void MapNestedSimple(this LightDBDefinitionSet defs, IDataField dataField,
IDataFieldDefinition fieldDef, Dictionary <string, List <SimpleDataColumn> > mappedFields)
{
INestedFieldDefinition field = (INestedFieldDefinition)fieldDef;
field.EnsureFieldsNotNull(dataField.DataHolderDefinition.Name);
defs.AddFieldMappings((IEnumerable <IDataFieldDefinition>)field.Fields,
(IDictionary <string, IDataField>)((NestedDataField)dataField).InnerFields, mappedFields);
}
public static void MapFlatArray(this LightDBDefinitionSet defs, IDataField dataField, IDataFieldDefinition fieldDef,
Dictionary <string, List <SimpleDataColumn> > mappedFields)
{
var arrFieldDef = (FlatArrayFieldDefinition)fieldDef;
var arrDataField = (FlatArrayDataField)dataField;
var defaultTables = defs.EnsureTables(arrFieldDef.Table, dataField.DataHolderDefinition);
var cols = arrFieldDef.GetColumns(arrDataField.Length);
var accessors = arrDataField.ArrayAccessors;
for (var i = 0; i < cols.Length; i++)
{
var col = cols[i];
AddMapping(defs, defaultTables, col, mappedFields, (IFlatDataFieldAccessor)accessors[i], dataField.MappedMember);
}
}
public static void MapFlatArray(this LightDBDefinitionSet defs, IDataField dataField,
IDataFieldDefinition fieldDef, Dictionary <string, List <SimpleDataColumn> > mappedFields)
{
FlatArrayFieldDefinition arrayFieldDefinition = (FlatArrayFieldDefinition)fieldDef;
FlatArrayDataField flatArrayDataField = (FlatArrayDataField)dataField;
TableDefinition[] defaultTables =
defs.EnsureTables(arrayFieldDefinition.Table, dataField.DataHolderDefinition);
SimpleFlatFieldDefinition[] columns = arrayFieldDefinition.GetColumns(flatArrayDataField.Length);
IDataFieldAccessor[] arrayAccessors = flatArrayDataField.ArrayAccessors;
for (int index = 0; index < columns.Length; ++index)
{
SimpleFlatFieldDefinition fieldDef1 = columns[index];
LightDBMgr.AddMapping(defs, defaultTables, fieldDef1, mappedFields,
(IFlatDataFieldAccessor)arrayAccessors[index], dataField.MappedMember);
}
}
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);
LightDBDefinitionSet.AddTables(allDefs, holderDefinition, dataHolderToTable, dataHolders, tables);
}
}
return(true);
}
static void AddMapping(LightDBDefinitionSet defs, TableDefinition[] defaultTables, SimpleFlatFieldDefinition fieldDef,
Dictionary<string, List<SimpleDataColumn>> mappedFields, IFlatDataFieldAccessor accessor, MemberInfo member)
{
var column = fieldDef.Column;
var tables = defs.EnsureTables(fieldDef.Table, defaultTables);
object defaultValue;
if (!String.IsNullOrEmpty(fieldDef.DefaultStringValue))
{
defaultValue = StringParser.Parse(fieldDef.DefaultStringValue, member.GetVariableType());
}
else
{
if (String.IsNullOrEmpty(column))
{
return;
}
defaultValue = null;
}
foreach (var table in tables)
{
var dataHolders = defs.m_tableDataHolderMap.GetOrCreate(table);
if (!dataHolders.Contains(accessor.DataHolderDefinition))
{
dataHolders.Add(accessor.DataHolderDefinition);
}
var mappedFieldMap = mappedFields.GetOrCreate(table.Name);
SimpleDataColumn dataColumn;
var dbAttrs = member.GetCustomAttributes<DBAttribute>();
var attr = dbAttrs.Where(attribute => attribute is PersistentAttribute).FirstOrDefault() as PersistentAttribute;
if (String.IsNullOrEmpty(column))
{
// use default value
mappedFieldMap.Add(dataColumn = new SimpleDataColumn(fieldDef.Name, defaultValue));
}
else
{
dataColumn = mappedFieldMap.Find((cmpField) => cmpField.ColumnName == column);
if (dataColumn == null)
{
var type = member.GetActualType();
if (attr != null)
type = attr.ReadType ?? type;
var reader = Converters.GetReader(type);
mappedFieldMap.Add(dataColumn = new SimpleDataColumn(column, reader));
}
}
dataColumn.FieldList.Add(accessor);
}
}
private static void AddMapping(LightDBDefinitionSet defs, TableDefinition[] defaultTables,
SimpleFlatFieldDefinition fieldDef, Dictionary <string, List <SimpleDataColumn> > mappedFields,
IFlatDataFieldAccessor accessor, MemberInfo member)
{
string column = fieldDef.Column;
TableDefinition[] tableDefinitionArray = defs.EnsureTables(fieldDef.Table, defaultTables);
object defaultValue;
if (!string.IsNullOrEmpty(fieldDef.DefaultStringValue))
{
defaultValue = StringParser.Parse(fieldDef.DefaultStringValue, member.GetVariableType());
}
else
{
if (string.IsNullOrEmpty(column))
{
return;
}
defaultValue = (object)null;
}
foreach (TableDefinition key in tableDefinitionArray)
{
List <DataHolderDefinition> holderDefinitionList =
defs.m_tableDataHolderMap.GetOrCreate <TableDefinition, DataHolderDefinition>(key);
if (!holderDefinitionList.Contains(accessor.DataHolderDefinition))
{
holderDefinitionList.Add(accessor.DataHolderDefinition);
}
List <SimpleDataColumn> simpleDataColumnList =
mappedFields.GetOrCreate <string, SimpleDataColumn>(key.Name);
PersistentAttribute persistentAttribute =
((IEnumerable <DBAttribute>)member.GetCustomAttributes <DBAttribute>())
.Where <DBAttribute>((Func <DBAttribute, bool>)(attribute => attribute is PersistentAttribute))
.FirstOrDefault <DBAttribute>() as PersistentAttribute;
SimpleDataColumn simpleDataColumn;
if (string.IsNullOrEmpty(column))
{
simpleDataColumnList.Add(simpleDataColumn = new SimpleDataColumn(fieldDef.Name, defaultValue));
}
else
{
simpleDataColumn =
simpleDataColumnList.Find(
(Predicate <SimpleDataColumn>)(cmpField => cmpField.ColumnName == column));
if (simpleDataColumn == null)
{
Type type1 = member.GetActualType();
if (persistentAttribute != null)
{
Type type2 = persistentAttribute.ReadType;
if ((object)type2 == null)
{
type2 = type1;
}
type1 = type2;
}
IFieldReader reader = Converters.GetReader(type1);
simpleDataColumnList.Add(simpleDataColumn = new SimpleDataColumn(column, reader));
}
}
simpleDataColumn.FieldList.Add(accessor);
}
}
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)
{
LightDBDefinitionSet.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 <DataHolderDefinition, TableDefinition>(holderDefinition)
.Add(tableDataHolder.Key);
}
}
}
List <DataHolderTableMapping> holderTableMappingList = new List <DataHolderTableMapping>();
HashSet <DataHolderDefinition> holderDefinitionSet1 =
new HashSet <DataHolderDefinition>(
(IEnumerable <DataHolderDefinition>)dictionary.Keys.ToArray <DataHolderDefinition>());
HashSet <DataHolderDefinition> holderDefinitionSet2 = new HashSet <DataHolderDefinition>();
HashSet <TableDefinition> tableDefinitionSet = new HashSet <TableDefinition>();
foreach (DataHolderDefinition key in dictionary.Keys)
{
if (LightDBDefinitionSet.AddTables((ICollection <DataHolderDefinition>)holderDefinitionSet1, key,
dictionary, holderDefinitionSet2, tableDefinitionSet))
{
DataHolderTableMapping holderTableMapping = new DataHolderTableMapping(
holderDefinitionSet2.ToArray <DataHolderDefinition>(),
tableDefinitionSet.ToArray <TableDefinition>());
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((Predicate <DataHolderTableMapping>)(map =>
((IEnumerable <TableDefinition>)map.TableDefinitions).Contains <TableDefinition>(
table)));
DataHolderDefinition[] holderDefinitions = holderTableMapping.DataHolderDefinitions;
holderTableMapping.DataHolderDefinitions =
new DataHolderDefinition[holderDefinitions.Length + 1];
Array.Copy((Array)holderDefinitions, (Array)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 = this.GetTable(field1.Key);
SimpleDataColumn[] fields = field1.Value.ToArray();
if (!string.IsNullOrEmpty(table.MainDataHolderName))
{
DataHolderDefinition dataDef = ((IEnumerable <DataHolderDefinition>) this.DataHolderDefinitions)
.Where <DataHolderDefinition>((Func <DataHolderDefinition, bool>)(dataHolderDef =>
dataHolderDef.Name.Equals(table.MainDataHolderName,
StringComparison.InvariantCultureIgnoreCase))).FirstOrDefault <DataHolderDefinition>();
if (dataDef == null)
{
throw new DataHolderException("Table \"{0}\" refered to invalid MainDataHolder: {1}",
new object[2]
{
(object)table,
(object)table.MainDataHolderName
});
}
table.SetMainDataHolder(dataDef, false);
}
try
{
List <PrimaryColumn> primaryColumnList = new List <PrimaryColumn>();
primaryColumnList.AddRange((IEnumerable <PrimaryColumn>)table.PrimaryColumns);
for (int index = 0; index < fields.Length; ++index)
{
SimpleDataColumn field = fields[index];
PrimaryColumn primaryColumn = primaryColumnList
.Where <PrimaryColumn>(
(Func <PrimaryColumn, bool>)(primCol => primCol.Name == field.ColumnName))
.FirstOrDefault <PrimaryColumn>();
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.",
new object[2]
{
(object)table,
(object)primaryColumnList.ToString <PrimaryColumn>(", ")
});
}
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((Array)fields, 0, (Array)simpleDataColumnArray, destinationIndex, fields.Length);
fields = simpleDataColumnArray;
if (num1 > 0)
{
LightDBDefinitionSet.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: " + (object)table +
" - You must explicitely define the TypeName attribute inside the PrimaryColumn node, if it is only an additional table for a DataHolder!",
new object[0]);
}
SimpleDataColumn simpleDataColumn = new SimpleDataColumn(primaryColumn.Name, reader, 0)
{
IsPrimaryKey = true
};
simpleDataColumn.FieldList.Add((IFlatDataFieldAccessor)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 = (IFieldReader)null;
}
}
this.TableDefinitionMap[field1.Key].ColumnDefinitions = fields;
}
catch (Exception ex)
{
throw new DataHolderException(ex, "Unable to setup Table \"{0}\" (MainDataHolder: \"{1}\")",
new object[2]
{
(object)table,
(object)table.MainDataHolder
});
}
}
this.m_mappings =
LightDBDefinitionSet.CreateDataHolderTableMappings(this.m_tableDataHolderMap,
this.DataHolderDefinitions);
}
static void AddMapping(LightDBDefinitionSet defs, TableDefinition[] defaultTables, SimpleFlatFieldDefinition fieldDef,
Dictionary<string, List<SimpleDataColumn>> mappedFields, IFlatDataFieldAccessor accessor, MemberInfo member)
{
var column = fieldDef.Column;
var tables = defs.EnsureTables(fieldDef.Table, defaultTables);
object defaultValue;
if (!String.IsNullOrEmpty(fieldDef.DefaultStringValue))
{
defaultValue = Utility.Parse(fieldDef.DefaultStringValue, member.GetVariableType());
}
else
{
if (String.IsNullOrEmpty(column))
{
return;
}
defaultValue = null;
}
if (accessor.DataHolderDefinition.Type.Name.EndsWith("TrainerEntry"))
{
defs.ToString();
}
foreach (var table in tables)
{
var dataHolders = defs.m_tableDataHolderMap.GetOrCreate(table);
if (!dataHolders.Contains(accessor.DataHolderDefinition))
{
dataHolders.Add(accessor.DataHolderDefinition);
}
var mappedFieldMap = mappedFields.GetOrCreate(table.Name);
SimpleDataColumn dataColumn;
if (String.IsNullOrEmpty(column))
{
// use default value
mappedFieldMap.Add(dataColumn = new SimpleDataColumn(fieldDef.Name, defaultValue));
}
else
{
dataColumn = mappedFieldMap.Find((cmpField) => cmpField.ColumnName == column);
if (dataColumn == null)
{
mappedFieldMap.Add(dataColumn = new SimpleDataColumn(column, Converters.GetReader(member.GetActualType())));
}
}
dataColumn.FieldList.Add(accessor);
}
}
