protected DataField(DataHolderDefinition dataHolder, string name, IGetterSetter accessor, MemberInfo mappedMember, INestedDataField parent) :
base(dataHolder, accessor, parent)
{
m_mappedMember = mappedMember;
m_name = name;
//m_fullName = parent;
}
protected ArrayDataField(DataHolderDefinition dataHolder, string name,
IGetterSetter accessor, MemberInfo mappedMember, INestedDataField parent, int length, IProducer arrProducer)
: base(dataHolder, name, accessor, mappedMember, parent)
{
m_length = length;
m_arrProducer = arrProducer;
}
public LightDBDefinitionSet(DataHolderDefinition[] dataHolderDefinitions)
{
DataHolderDefinitions = dataHolderDefinitions;
foreach (var def in dataHolderDefinitions)
{
DataHolderDefinitionMap.Add(def.Type, def);
}
}
public FlatArrayDataField(DataHolderDefinition dataHolder, string name, IGetterSetter accessor,
MemberInfo mappedMember, int length, IProducer arrProducer, INestedDataField parent)
: base(dataHolder, name, accessor, mappedMember, parent, length, arrProducer)
{
this.m_ArrayAccessors = (IDataFieldAccessor[])new FlatArrayAccessor[this.m_length];
for (int index = 0; index < this.m_length; ++index)
{
this.m_ArrayAccessors[index] = (IDataFieldAccessor) new FlatArrayAccessor(this, index);
}
}
public FlatArrayDataField(DataHolderDefinition dataHolder, string name, IGetterSetter accessor,
MemberInfo mappedMember, int length, IProducer arrProducer, INestedDataField parent) :
base(dataHolder, name, accessor, mappedMember, parent, length, arrProducer)
{
m_ArrayAccessors = new FlatArrayAccessor[m_length];
for (var i = 0; i < m_length; i++)
{
m_ArrayAccessors[i] = new FlatArrayAccessor(this, i);
}
}
public NestedArrayDataField(DataHolderDefinition dataHolder, string name, IGetterSetter accessor,
MemberInfo mappedMember, IProducer producer, IProducer arrayProducer, int length, INestedDataField parent)
: base(dataHolder, name, accessor, mappedMember, parent, length, arrayProducer)
{
m_Producer = producer;
m_ArrayAccessors = new NestedArrayAccessor[m_length];
for (int index = 0; index < m_length; ++index)
{
m_ArrayAccessors[index] = new NestedArrayAccessor(this, index);
}
}
public static void CreateAndStoreDataHolderDefinitions(Assembly asm)
{
foreach (Type type in asm.GetTypes())
{
if (type.GetCustomAttributes <DataHolderAttribute>()
.Count() > 0)
{
DataHolderDefinition holderDefinition = CreateDataHolderDefinition(type);
DataHolderDefinitions.Add(holderDefinition.Name, holderDefinition);
}
}
}
public static Dictionary <string, DataHolderDefinition> CreateDataHolderDefinitionMap(Assembly asm)
{
Dictionary <string, DataHolderDefinition> dictionary = new Dictionary <string, DataHolderDefinition>();
foreach (Type type in asm.GetTypes())
{
if (type.GetCustomAttributes <DataHolderAttribute>()
.Count() > 0)
{
DataHolderDefinition holderDefinition = CreateDataHolderDefinition(type);
dictionary.Add(holderDefinition.Name, holderDefinition);
}
}
return(dictionary);
}
public static List <DataHolderDefinition> CreateDataHolderDefinitionList(Assembly asm)
{
List <DataHolderDefinition> holderDefinitionList = new List <DataHolderDefinition>();
foreach (Type type in asm.GetTypes())
{
if (type.Name == "PetLevelStatInfo")
{
type.ToString();
}
if (type.GetCustomAttributes <DataHolderAttribute>()
.Count() > 0)
{
DataHolderDefinition holderDefinition = CreateDataHolderDefinition(type);
holderDefinitionList.Add(holderDefinition);
}
}
return(holderDefinitionList);
}
protected ArrayDataField(DataHolderDefinition dataHolder, string name,
IGetterSetter accessor, MemberInfo mappedMember, INestedDataField parent, int length, IProducer arrProducer)
: base(dataHolder, name, accessor, mappedMember, parent)
{
m_length = length;
m_arrProducer = arrProducer;
}
public NestedSimpleDataField(DataHolderDefinition dataHolder, string name, IGetterSetter accessor,
MemberInfo mappedMember, IProducer producer, INestedDataField parent)
: base(dataHolder, name, accessor, mappedMember, producer, parent)
{
}
protected NestedDataField(DataHolderDefinition dataHolder, string name, IGetterSetter accessor, MemberInfo mappedMember, IProducer producer, INestedDataField parent)
: base(dataHolder, name, accessor, mappedMember, parent)
{
m_Producer = producer;
}
public NestedArrayDataField(DataHolderDefinition dataHolder, string name, IGetterSetter accessor,
MemberInfo mappedMember,
IProducer producer, IProducer arrayProducer, int length, INestedDataField parent)
: base(dataHolder, name, accessor, mappedMember, parent, length, arrayProducer)
{
m_Producer = producer;
m_ArrayAccessors = new NestedArrayAccessor[m_length];
for (var i = 0; i < m_length; i++)
{
m_ArrayAccessors[i] = new NestedArrayAccessor(this, i);
}
}
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 TableDefinition[] EnsureTables(string tableName, DataHolderDefinition def)
{
return EnsureTables(tableName, GetDefaultTables(def));
}
private void GetDataFields(Type type, IDictionary <string, IDataField> fields, INestedDataField parent)
{
MemberInfo[] members = type.GetMembers(BindingFlags.Instance | BindingFlags.Public | BindingFlags.SetField |
BindingFlags.SetProperty);
int length = members.Length;
Dictionary <MemberInfo, IGetterSetter> dictionary1 = length >= 80 || !type.IsClass
? (Dictionary <MemberInfo, IGetterSetter>)null
: AccessorMgr.GetOrCreateAccessors(type);
foreach (MemberInfo index1 in members)
{
if (!index1.IsReadonly() && index1.GetCustomAttributes <NotPersistentAttribute>().Length <= 0)
{
PersistentAttribute attr =
((IEnumerable <DBAttribute>)index1.GetCustomAttributes <DBAttribute>())
.Where <DBAttribute>((Func <DBAttribute, bool>)(attribute => attribute is PersistentAttribute))
.FirstOrDefault <DBAttribute>() as PersistentAttribute;
if (attr != null || !this.m_Attribute.RequirePersistantAttr)
{
Type variableType = index1.GetVariableType();
bool isArray = variableType.IsArray;
Type type1;
string name;
IGetterSetter accessor;
IFieldReader reader;
if (attr != null)
{
Type actualType = attr.ActualType;
if ((object)actualType == null)
{
actualType = index1.GetActualType();
}
type1 = actualType;
name = attr.Name ?? index1.Name;
if (attr.AccessorType != (Type)null)
{
object instance = Activator.CreateInstance(attr.AccessorType);
if (!(instance is IGetterSetter))
{
throw new DataHolderException(
"Accessor for Persistent members must be of type IGetterSetter - Found accessor of type {0} for member {1}",
new object[2]
{
(object)instance.GetType(),
(object)index1.GetFullMemberName()
});
}
accessor = (IGetterSetter)instance;
}
else
{
accessor = dictionary1 != null
? dictionary1[index1]
: (IGetterSetter) new DefaultVariableAccessor(index1);
}
Type type2 = attr.ReadType;
if ((object)type2 == null)
{
type2 = type1;
}
reader = Converters.GetReader(type2);
}
else
{
type1 = index1.GetActualType();
name = index1.Name;
accessor = dictionary1 != null
? dictionary1[index1]
: (IGetterSetter) new DefaultVariableAccessor(index1);
reader = Converters.GetReader(type1);
}
if (isArray && (variableType.GetArrayRank() > 1 || type1.IsArray))
{
throw new DataHolderException(
"Cannot define Type {0} of {1} because its a multi-dimensional Array.", new object[2]
{
(object)variableType,
(object)index1.GetFullMemberName()
});
}
IDataField dataField1;
if (reader == null)
{
if (type.IsAbstract)
{
throw new DataHolderException(
"Cannot define member \"{0}\" of DataHolder \"{1}\" because it's Type ({2}) is abstract.",
new object[3]
{
(object)index1.GetFullMemberName(),
(object)this,
(object)type1.FullName
});
}
IProducer producer = !type1.IsClass
? (IProducer)null
: DataHolderDefinition.CreateProducer(type1);
if (isArray)
{
int arrayLengthByAttr = DataHolderDefinition.GetArrayLengthByAttr(attr, index1);
NestedArrayDataField nestedArrayDataField = new NestedArrayDataField(this, name,
accessor, index1, producer,
DataHolderDefinition.CreateArrayProducer(type1, arrayLengthByAttr),
arrayLengthByAttr, parent);
Dictionary <string, IDataField> dictionary2 =
new Dictionary <string, IDataField>(
(IEqualityComparer <string>)StringComparer.InvariantCultureIgnoreCase);
this.GetDataFields(type1, (IDictionary <string, IDataField>)dictionary2,
(INestedDataField)nestedArrayDataField);
foreach (IDataField dataField2 in dictionary2.Values)
{
for (int index2 = 0; index2 < nestedArrayDataField.ArrayAccessors.Length; ++index2)
{
NestedArrayAccessor arrayAccessor =
(NestedArrayAccessor)nestedArrayDataField.ArrayAccessors[index2];
IDataField dataField3 =
((DataFieldBase)dataField2).Copy((INestedDataField)arrayAccessor);
arrayAccessor.InnerFields.Add(dataField3.Name, dataField3);
}
}
dataField1 = (IDataField)nestedArrayDataField;
}
else
{
NestedSimpleDataField nestedSimpleDataField =
new NestedSimpleDataField(this, name, accessor, index1, producer, parent);
this.GetDataFields(type1,
(IDictionary <string, IDataField>)nestedSimpleDataField.InnerFields,
(INestedDataField)nestedSimpleDataField);
if (nestedSimpleDataField.InnerFields.Count == 0)
{
throw new DataHolderException(
"Cannot define " + index1.GetFullMemberName() +
" as Nested because it does not have any inner fields.", new object[0]);
}
dataField1 = (IDataField)nestedSimpleDataField;
}
}
else if (isArray)
{
int arrayLengthByAttr = DataHolderDefinition.GetArrayLengthByAttr(attr, index1);
dataField1 = (IDataField) new FlatArrayDataField(this, name, accessor, index1,
arrayLengthByAttr, DataHolderDefinition.CreateArrayProducer(type1, arrayLengthByAttr),
parent);
}
else
{
dataField1 = (IDataField) new FlatSimpleDataField(this, name, accessor, index1, parent);
if (name == this.m_DependingFieldName)
{
this.m_DependingField = (FlatSimpleDataField)dataField1;
}
}
fields.Add(dataField1.Name, dataField1);
}
}
}
if (fields.Count <KeyValuePair <string, IDataField> >() - length == 0)
{
throw new ArgumentException("Invalid data Type has no persistent members: " + type.FullName);
}
}
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 NestedSimpleDataField(DataHolderDefinition dataHolder, string name, IGetterSetter accessor,
MemberInfo mappedMember, IProducer producer, INestedDataField parent)
: base(dataHolder, name, accessor, mappedMember, producer, parent)
{
}
protected NestedDataField(DataHolderDefinition dataHolder, string name, IGetterSetter accessor, MemberInfo mappedMember, IProducer producer, INestedDataField parent)
: base(dataHolder, name, accessor, mappedMember, parent)
{
m_Producer = producer;
}
public BinaryContentStream(DataHolderDefinition def)
{
m_Def = def;
InitPersistors();
}
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();
}
public static DataHolderTableMapping[] CreateDataHolderTableMappings(
Dictionary<TableDefinition, List<DataHolderDefinition>> tableDataHolderMap,
DataHolderDefinition[] dataHolderDefinitions
)
{
// find exact mappings and split them up into as small parts as possible
// this way we will only read the data from tables that is actually
// mapped to DataHolders and we will read every cell only once
var tablesByHolder = new Dictionary<DataHolderDefinition, List<TableDefinition>>();
foreach (var pair in tableDataHolderMap)
{
if (pair.Value == null)
{
log.Warn("Table-definition \"{0}\" has no used columns (and can possibly be removed from the config).");
}
else
{
pair.Key.DataHolderDefinitions = pair.Value.ToArray();
foreach (var dataHolder in pair.Key.DataHolderDefinitions)
{
tablesByHolder.GetOrCreate(dataHolder).Add(pair.Key);
}
}
}
var mappings = new List<DataHolderTableMapping>();
var allDefs = new HashSet<DataHolderDefinition>(tablesByHolder.Keys.ToArray());
var dataHolders = new HashSet<DataHolderDefinition>();
var tables = new HashSet<TableDefinition>();
foreach (var holder in tablesByHolder.Keys)
{
if (AddTables(allDefs, holder, tablesByHolder, dataHolders, tables))
{
var mapping = new DataHolderTableMapping(dataHolders.ToArray(), tables.ToArray());
mappings.Add(mapping);
dataHolders.Clear();
tables.Clear();
}
}
foreach (var table in tableDataHolderMap.Keys)
{
foreach (var field in table.ColumnDefinitions)
{
if (field is IDataFieldBase)
{
var holderDef = ((IDataFieldBase)field).DataHolderDefinition;
if (!dataHolders.Contains(holderDef))
{
var mapping = mappings.Find(map => map.TableDefinitions.Contains(table));
var tableHolders = mapping.DataHolderDefinitions;
mapping.DataHolderDefinitions = new DataHolderDefinition[tableHolders.Length + 1];
Array.Copy(tableHolders, mapping.TableDefinitions, tableHolders.Length);
mapping.DataHolderDefinitions[tableHolders.Length] = holderDef;
}
}
}
}
return mappings.ToArray();
}
public TableDefinition[] GetDefaultTables(DataHolderDefinition def)
{
TableDefinition[] tables;
DefaultTables.TryGetValue(def.Name, out tables);
return tables;
}
public DataFieldProxy(string fieldName, DataHolderDefinition dataHolderDef)
{
m_FieldName = fieldName;
m_DataHolderDef = dataHolderDef;
}
protected DataField(DataHolderDefinition dataHolder, string name, IGetterSetter accessor, MemberInfo mappedMember, INestedDataField parent)
: base(dataHolder, accessor, parent)
{
m_mappedMember = mappedMember;
m_name = name;
//m_fullName = parent;
}
protected DataFieldBase(DataHolderDefinition dataHolder, IGetterSetter accessor, INestedDataField parent)
{
m_DataHolderDefinition = dataHolder;
m_parent = parent;
m_accessor = accessor;
}
public BinaryContentStream(DataHolderDefinition def)
{
m_Def = def;
InitPersistors();
}
protected DataFieldBase(DataHolderDefinition dataHolder, IGetterSetter accessor, INestedDataField parent)
{
m_DataHolderDefinition = dataHolder;
m_parent = parent;
m_accessor = accessor;
}
