public static IEnumerable <T> AllGameItemsFromAsset <T>(LoadableXmlAsset asset) where T : new() { if (asset.xmlDoc == null) { yield break; } XmlNodeList assetNodes = asset.xmlDoc.DocumentElement.SelectNodes(typeof(T).Name); bool gotData = false; IEnumerator enumerator = assetNodes.GetEnumerator(); try { while (enumerator.MoveNext()) { object obj = enumerator.Current; XmlNode node = (XmlNode)obj; XmlAttribute abstractAtt = node.Attributes["Abstract"]; if (abstractAtt == null || !(abstractAtt.Value.ToLower() == "true")) { T item; try { item = DirectXmlToObject.ObjectFromXml <T>(node, true); gotData = true; } catch (Exception ex) { Log.Error(string.Concat(new object[] { "Exception loading data from file ", asset.name, ": ", ex }), false); continue; } yield return(item); } } } finally { IDisposable disposable; if ((disposable = (enumerator as IDisposable)) != null) { disposable.Dispose(); } } if (!gotData) { Log.Error(string.Concat(new object[] { "Found no usable data when trying to get ", typeof(T), "s from file ", asset.name }), false); } yield break; }
public override bool TryResolve(FailMode failReportMode) { failReportMode = FailMode.LogErrors; bool flag = typeof(Def).IsAssignableFrom(typeof(K)); bool flag2 = typeof(Def).IsAssignableFrom(typeof(V)); List <Pair <K, V> > list = new List <Pair <K, V> >(); foreach (XmlNode wantedDictRef in this.wantedDictRefs) { XmlNode xmlNode = wantedDictRef["key"]; XmlNode xmlNode2 = wantedDictRef["value"]; K first = (!flag) ? DirectXmlToObject.ObjectFromXml <K>(xmlNode, true) : DirectXmlCrossRefLoader.TryResolveDef <K>(xmlNode.InnerText, failReportMode); V second = (!flag2) ? DirectXmlToObject.ObjectFromXml <V>(xmlNode2, true) : DirectXmlCrossRefLoader.TryResolveDef <V>(xmlNode2.InnerText, failReportMode); list.Add(new Pair <K, V>(first, second)); } Dictionary <K, V> dictionary = (Dictionary <K, V>)base.wanter; dictionary.Clear(); foreach (Pair <K, V> item in list) { try { dictionary.Add(item.First, item.Second); } catch { Log.Error("Failed to load key/value pair: " + item.First + ", " + item.Second); } } return(true); }
public static IEnumerable <T> AllGameItemsFromAsset <T>(LoadableXmlAsset asset) where T : new() { if (asset.xmlDoc != null) { XmlNodeList xmlNodeList = asset.xmlDoc.DocumentElement.SelectNodes(typeof(T).Name); bool gotData = false; foreach (XmlNode item in xmlNodeList) { XmlAttribute xmlAttribute = item.Attributes["Abstract"]; if (xmlAttribute == null || !(xmlAttribute.Value.ToLower() == "true")) { T val; try { val = DirectXmlToObject.ObjectFromXml <T>(item, doPostLoad: true); gotData = true; } catch (Exception ex) { Log.Error("Exception loading data from file " + asset.name + ": " + ex); continue; } yield return(val); } } if (!gotData) { Log.Error("Found no usable data when trying to get " + typeof(T) + "s from file " + asset.name); } } }
public static T ItemFromXmlFile <T>(string filePath, bool resolveCrossRefs = true) where T : new() { if (resolveCrossRefs && DirectXmlCrossRefLoader.LoadingInProgress) { Log.Error("Cannot call ItemFromXmlFile with resolveCrossRefs=true while loading is already in progress."); } FileInfo fileInfo = new FileInfo(filePath); if (!fileInfo.Exists) { return(Activator.CreateInstance <T>()); } T result; try { XmlDocument xmlDocument = new XmlDocument(); xmlDocument.LoadXml(File.ReadAllText(fileInfo.FullName)); T t = DirectXmlToObject.ObjectFromXml <T>(xmlDocument.DocumentElement, false); if (resolveCrossRefs) { DirectXmlCrossRefLoader.ResolveAllWantedCrossReferences(FailMode.LogErrors); } result = t; } catch (Exception ex) { Log.Error("Exception loading file at " + filePath + ". Loading defaults instead. Exception was: " + ex.ToString()); result = Activator.CreateInstance <T>(); } return(result); }
private static FieldInfo GetFieldInfoForType(Type type, string token, XmlNode debugXmlNode) { Dictionary <string, FieldInfo> dictionary = DirectXmlToObject.fieldInfoLookup.TryGetValue(type, null); if (dictionary == null) { dictionary = new Dictionary <string, FieldInfo>(); DirectXmlToObject.fieldInfoLookup[type] = dictionary; } FieldInfo fieldInfo = dictionary.TryGetValue(token, null); if (fieldInfo == null && !dictionary.ContainsKey(token)) { fieldInfo = DirectXmlToObject.SearchTypeHierarchy(type, token, BindingFlags.Default); if (fieldInfo == null) { fieldInfo = DirectXmlToObject.SearchTypeHierarchy(type, token, BindingFlags.IgnoreCase); if (fieldInfo != null && !type.HasAttribute <CaseInsensitiveXMLParsing>()) { string text = string.Format("Attempt to use string {0} to refer to field {1} in type {2}; xml tags are now case-sensitive", token, fieldInfo.Name, type); if (debugXmlNode != null) { text = text + ". XML: " + debugXmlNode.OuterXml; } Log.Error(text, false); } } dictionary[token] = fieldInfo; } return(fieldInfo); }
public static T ItemFromXmlString <T>(string xmlContent, string filePath, bool resolveCrossRefs = true) where T : new() { if (resolveCrossRefs && DirectXmlCrossRefLoader.LoadingInProgress) { Log.Error("Cannot call ItemFromXmlString with resolveCrossRefs=true while loading is already in progress (forgot to resolve or clear cross refs from previous loading?)."); } try { XmlDocument xmlDocument = new XmlDocument(); xmlDocument.LoadXml(xmlContent); T result = DirectXmlToObject.ObjectFromXml <T>(xmlDocument.DocumentElement, doPostLoad: false); if (resolveCrossRefs) { try { DirectXmlCrossRefLoader.ResolveAllWantedCrossReferences(FailMode.LogErrors); } finally { DirectXmlCrossRefLoader.Clear(); } } return(result); } catch (Exception ex) { Log.Error("Exception loading file at " + filePath + ". Loading defaults instead. Exception was: " + ex.ToString()); return(new T()); } }
private void LoadPatches() { DeepProfiler.Start("Loading all patches"); patches = new List <PatchOperation>(); loadedAnyPatches = false; List <LoadableXmlAsset> list = DirectXmlLoader.XmlAssetsInModFolder(this, "Patches/").ToList(); for (int i = 0; i < list.Count; i++) { XmlElement documentElement = list[i].xmlDoc.DocumentElement; if (documentElement.Name != "Patch") { Log.Error($"Unexpected document element in patch XML; got {documentElement.Name}, expected 'Patch'"); continue; } foreach (XmlNode childNode in documentElement.ChildNodes) { if (childNode.NodeType == XmlNodeType.Element) { if (childNode.Name != "Operation") { Log.Error($"Unexpected element in patch XML; got {childNode.Name}, expected 'Operation'"); continue; } PatchOperation patchOperation = DirectXmlToObject.ObjectFromXml <PatchOperation>(childNode, doPostLoad: false); patchOperation.sourceFile = list[i].FullFilePath; patches.Add(patchOperation); loadedAnyPatches = true; } } } DeepProfiler.End(); }
private static List <T> ListFromXml <T>(XmlNode listRootNode) where T : new() { List <T> list = new List <T>(); try { bool flag = typeof(Def).IsAssignableFrom(typeof(T)); foreach (XmlNode xmlNode in listRootNode.ChildNodes) { if (DirectXmlToObject.ValidateListNode(xmlNode, listRootNode, typeof(T))) { if (flag) { DirectXmlCrossRefLoader.RegisterListWantsCrossRef <T>(list, xmlNode.InnerText); } else { list.Add(DirectXmlToObject.ObjectFromXml <T>(xmlNode, true)); } } } } catch (Exception ex) { Log.Error(string.Concat(new object[] { "Exception loading list from XML: ", ex, "\nXML:\n", listRootNode.OuterXml })); } return(list); }
public override void Apply() { Dictionary <K, V> dictionary = (Dictionary <K, V>)wanter; dictionary.Clear(); foreach (Pair <object, object> makingDatum in makingData) { try { object obj = makingDatum.First; object obj2 = makingDatum.Second; if (obj is XmlNode) { obj = DirectXmlToObject.ObjectFromXml <K>(obj as XmlNode, doPostLoad: true); } if (obj2 is XmlNode) { obj2 = DirectXmlToObject.ObjectFromXml <V>(obj2 as XmlNode, doPostLoad: true); } dictionary.Add((K)obj, (V)obj2); } catch { Log.Error(string.Concat("Failed to load key/value pair: ", makingDatum.First, ", ", makingDatum.Second)); } } }
public static IEnumerable <T> AllGameItemsFromAsset <T>(LoadableXmlAsset asset) where T : new() { if (DirectXmlLoader.loadingAsset != null) { Log.Error("Tried to load " + asset + " while loading " + DirectXmlLoader.loadingAsset + ". This will corrupt the internal state of DataLoader."); } if (asset.xmlDoc != null) { DirectXmlLoader.loadingAsset = asset; XmlNodeList assetNodes = asset.xmlDoc.DocumentElement.SelectNodes(typeof(T).Name); bool gotData = false; IEnumerator enumerator = assetNodes.GetEnumerator(); try { while (enumerator.MoveNext()) { XmlNode node = (XmlNode)enumerator.Current; XmlAttribute abstractAtt = node.Attributes["Abstract"]; if (abstractAtt != null && abstractAtt.Value.ToLower() == "true") { continue; } T item; try { item = DirectXmlToObject.ObjectFromXml <T>(node, true); gotData = true; } catch (Exception ex) { Log.Error("Exception loading data from file " + asset.name + ": " + ex); continue; } yield return(item); /*Error: Unable to find new state assignment for yield return*/; } } finally { IDisposable disposable; IDisposable disposable2 = disposable = (enumerator as IDisposable); if (disposable != null) { disposable2.Dispose(); } } if (!gotData) { Log.Error("Found no usable data when trying to get " + typeof(T) + "s from file " + asset.name); } DirectXmlLoader.loadingAsset = null; } yield break; IL_0247: /*Error near IL_0248: Unexpected return in MoveNext()*/; }
public static IEnumerable <T> AllGameItemsFromAsset <T>(LoadableXmlAsset asset) where T : new() { if (DirectXmlLoader.loadingAsset != null) { Log.Error(string.Concat(new object[] { "Tried to load ", asset, " while loading ", DirectXmlLoader.loadingAsset, ". This will corrupt the internal state of DataLoader." })); } if (asset.xmlDoc != null) { DirectXmlLoader.loadingAsset = asset; XmlNodeList assetNodes = asset.xmlDoc.DocumentElement.SelectNodes(typeof(T).Name); bool gotData = false; foreach (XmlNode node in assetNodes) { XmlAttribute abstractAtt = node.Attributes["Abstract"]; if (abstractAtt == null || !(abstractAtt.Value.ToLower() == "true")) { T item; try { item = DirectXmlToObject.ObjectFromXml <T>(node, true); gotData = true; } catch (Exception ex) { Log.Error(string.Concat(new object[] { "Exception loading data from file ", asset.name, ": ", ex })); continue; } yield return(item); } } if (!gotData) { Log.Error(string.Concat(new object[] { "Found no usable data when trying to get ", typeof(T), "s from file ", asset.name })); } DirectXmlLoader.loadingAsset = null; } }
public override bool TryResolve(FailMode failReportMode) { failReportMode = FailMode.LogErrors; bool flag = typeof(Def).IsAssignableFrom(typeof(K)); bool flag2 = typeof(Def).IsAssignableFrom(typeof(V)); List <Pair <K, V> > list = new List <Pair <K, V> >(); foreach (XmlNode xmlNode in this.wantedDictRefs) { XmlNode xmlNode2 = xmlNode["key"]; XmlNode xmlNode3 = xmlNode["value"]; K first; if (flag) { first = DirectXmlCrossRefLoader.TryResolveDef <K>(xmlNode2.InnerText, failReportMode, this.debugWanterInfo); } else { first = DirectXmlToObject.ObjectFromXml <K>(xmlNode2, true); } V second; if (flag2) { second = DirectXmlCrossRefLoader.TryResolveDef <V>(xmlNode3.InnerText, failReportMode, this.debugWanterInfo); } else { second = DirectXmlToObject.ObjectFromXml <V>(xmlNode3, true); } list.Add(new Pair <K, V>(first, second)); } Dictionary <K, V> dictionary = (Dictionary <K, V>) this.wanter; dictionary.Clear(); foreach (Pair <K, V> pair in list) { try { dictionary.Add(pair.First, pair.Second); } catch { Log.Error(string.Concat(new object[] { "Failed to load key/value pair: ", pair.First, ", ", pair.Second }), false); } } return(true); }
private static List <T> ListFromXml <T>(XmlNode listRootNode) where T : new() { List <T> list = new List <T>(); try { bool flag = typeof(Def).IsAssignableFrom(typeof(T)); IEnumerator enumerator = listRootNode.ChildNodes.GetEnumerator(); try { while (enumerator.MoveNext()) { object obj = enumerator.Current; XmlNode xmlNode = (XmlNode)obj; if (DirectXmlToObject.ValidateListNode(xmlNode, listRootNode, typeof(T))) { if (flag) { DirectXmlCrossRefLoader.RegisterListWantsCrossRef <T>(list, xmlNode.InnerText, listRootNode.Name); } else { list.Add(DirectXmlToObject.ObjectFromXml <T>(xmlNode, true)); } } } } finally { IDisposable disposable; if ((disposable = (enumerator as IDisposable)) != null) { disposable.Dispose(); } } } catch (Exception ex) { Log.Error(string.Concat(new object[] { "Exception loading list from XML: ", ex, "\nXML:\n", listRootNode.OuterXml }), false); } return(list); }
private static bool ValidateListNode(XmlNode listEntryNode, XmlNode listRootNode, Type listItemType) { if (listEntryNode is XmlComment) { return(false); } if (listEntryNode is XmlText) { Log.Error("XML format error: Raw text found inside a list element. Did you mean to surround it with list item <li> tags? " + listRootNode.OuterXml); return(false); } if (listEntryNode.Name != "li" && DirectXmlToObject.CustomDataLoadMethodOf(listItemType) == null) { Log.Error("XML format error: List item found with name that is not <li>, and which does not have a custom XML loader method, in " + listRootNode.OuterXml); return(false); } return(true); }
private static Dictionary <K, V> DictionaryFromXml <K, V>(XmlNode dictRootNode) where K : new() where V : new() { Dictionary <K, V> dictionary = new Dictionary <K, V>(); try { bool flag = typeof(Def).IsAssignableFrom(typeof(K)); bool flag2 = typeof(Def).IsAssignableFrom(typeof(V)); if (!flag && !flag2) { foreach (XmlNode xmlNode in dictRootNode.ChildNodes) { if (DirectXmlToObject.ValidateListNode(xmlNode, dictRootNode, typeof(KeyValuePair <K, V>))) { K key = DirectXmlToObject.ObjectFromXml <K>(xmlNode["key"], true); V value = DirectXmlToObject.ObjectFromXml <V>(xmlNode["value"], true); dictionary.Add(key, value); } } } else { foreach (XmlNode xmlNode2 in dictRootNode.ChildNodes) { if (DirectXmlToObject.ValidateListNode(xmlNode2, dictRootNode, typeof(KeyValuePair <K, V>))) { DirectXmlCrossRefLoader.RegisterDictionaryWantsCrossRef <K, V>(dictionary, xmlNode2); } } } } catch (Exception ex) { Log.Error(string.Concat(new object[] { "Malformed dictionary XML. Node: ", dictRootNode.OuterXml, ".\n\nException: ", ex })); } return(dictionary); }
public static Def DefFromNode(XmlNode node, LoadableXmlAsset loadingAsset) { if (node.NodeType != XmlNodeType.Element) { return(null); } XmlAttribute xmlAttribute = node.Attributes["Abstract"]; if (xmlAttribute != null && xmlAttribute.Value.ToLower() == "true") { return(null); } Type typeInAnyAssembly = GenTypes.GetTypeInAnyAssembly(node.Name); if (typeInAnyAssembly == null) { return(null); } if (!typeof(Def).IsAssignableFrom(typeInAnyAssembly)) { return(null); } Func <XmlNode, bool, object> objectFromXmlMethod = DirectXmlToObject.GetObjectFromXmlMethod(typeInAnyAssembly); Def result = null; try { result = (Def)objectFromXmlMethod(node, arg2: true); return(result); } catch (Exception ex) { Log.Error("Exception loading def from file " + ((loadingAsset != null) ? loadingAsset.name : "(unknown)") + ": " + ex); return(result); } }
private void LoadPatches() { DeepProfiler.Start("Loading all patches"); this.patches = new List <PatchOperation>(); List <LoadableXmlAsset> list = DirectXmlLoader.XmlAssetsInModFolder(this, "Patches/").ToList <LoadableXmlAsset>(); for (int i = 0; i < list.Count; i++) { XmlElement documentElement = list[i].xmlDoc.DocumentElement; if (documentElement.Name != "Patch") { Log.Error(string.Format("Unexpected document element in patch XML; got {0}, expected 'Patch'", documentElement.Name)); } else { for (int j = 0; j < documentElement.ChildNodes.Count; j++) { XmlNode xmlNode = documentElement.ChildNodes[j]; if (xmlNode.NodeType == XmlNodeType.Element) { if (xmlNode.Name != "Operation") { Log.Error(string.Format("Unexpected element in patch XML; got {0}, expected 'Operation'", documentElement.ChildNodes[j].Name)); } else { PatchOperation patchOperation = DirectXmlToObject.ObjectFromXml <PatchOperation>(xmlNode, false); patchOperation.sourceFile = list[i].FullFilePath; this.patches.Add(patchOperation); } } } } } DeepProfiler.End(); }
private static Dictionary <K, V> DictionaryFromXml <K, V>(XmlNode dictRootNode) where K : new() where V : new() { Dictionary <K, V> dictionary = new Dictionary <K, V>(); try { bool flag = typeof(Def).IsAssignableFrom(typeof(K)); bool flag2 = typeof(Def).IsAssignableFrom(typeof(V)); if (!flag && !flag2) { IEnumerator enumerator = dictRootNode.ChildNodes.GetEnumerator(); try { while (enumerator.MoveNext()) { object obj = enumerator.Current; XmlNode xmlNode = (XmlNode)obj; if (DirectXmlToObject.ValidateListNode(xmlNode, dictRootNode, typeof(KeyValuePair <K, V>))) { K key = DirectXmlToObject.ObjectFromXml <K>(xmlNode["key"], true); V value = DirectXmlToObject.ObjectFromXml <V>(xmlNode["value"], true); dictionary.Add(key, value); } } } finally { IDisposable disposable; if ((disposable = (enumerator as IDisposable)) != null) { disposable.Dispose(); } } } else { IEnumerator enumerator2 = dictRootNode.ChildNodes.GetEnumerator(); try { while (enumerator2.MoveNext()) { object obj2 = enumerator2.Current; XmlNode xmlNode2 = (XmlNode)obj2; if (DirectXmlToObject.ValidateListNode(xmlNode2, dictRootNode, typeof(KeyValuePair <K, V>))) { DirectXmlCrossRefLoader.RegisterDictionaryWantsCrossRef <K, V>(dictionary, xmlNode2, dictRootNode.Name); } } } finally { IDisposable disposable2; if ((disposable2 = (enumerator2 as IDisposable)) != null) { disposable2.Dispose(); } } } } catch (Exception ex) { Log.Error(string.Concat(new object[] { "Malformed dictionary XML. Node: ", dictRootNode.OuterXml, ".\n\nException: ", ex }), false); } return(dictionary); }
public static object Convert(object obj, Type to, object defaultValue) { if (obj == null) { return(defaultValue); } if (to.IsAssignableFrom(obj.GetType())) { return(obj); } if (to == typeof(string)) { return(obj.ToString()); } string text = obj as string; if (text != null && !to.IsPrimitive && ParseHelper.CanParse(to, (string)obj)) { if (text == "") { return(defaultValue); } return(ParseHelper.FromString(text, to)); } if (text != null && typeof(Def).IsAssignableFrom(to)) { if (text == "") { return(defaultValue); } return(GenDefDatabase.GetDef(to, text)); } if (text != null && to == typeof(Faction)) { if (text == "") { return(defaultValue); } List <Faction> allFactionsListForReading = Find.FactionManager.AllFactionsListForReading; for (int i = 0; i < allFactionsListForReading.Count; i++) { if (allFactionsListForReading[i].GetUniqueLoadID() == text) { return(allFactionsListForReading[i]); } } for (int j = 0; j < allFactionsListForReading.Count; j++) { if (allFactionsListForReading[j].HasName && allFactionsListForReading[j].Name == text) { return(allFactionsListForReading[j]); } } for (int k = 0; k < allFactionsListForReading.Count; k++) { if (allFactionsListForReading[k].def.defName == text) { return(allFactionsListForReading[k]); } } return(defaultValue); } if (CanConvertBetweenDataTypes(obj.GetType(), to)) { return(ConvertBetweenDataTypes(obj, to)); } if (IsXml(obj) && !to.IsPrimitive) { try { Type type = to; if (type == typeof(IEnumerable)) { type = typeof(List <string>); } if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IEnumerable <>) && type.GetGenericArguments().Length >= 1) { type = typeof(List <>).MakeGenericType(type.GetGenericArguments()[0]); } XmlDocument xmlDocument = new XmlDocument(); xmlDocument.LoadXml("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<root>\n" + text + "\n</root>"); object result = DirectXmlToObject.GetObjectFromXmlMethod(type)(xmlDocument.DocumentElement, arg2 : true); DirectXmlCrossRefLoader.ResolveAllWantedCrossReferences(FailMode.LogErrors); return(result); } finally { DirectXmlCrossRefLoader.Clear(); } } if (to.IsGenericType && (to.GetGenericTypeDefinition() == typeof(IEnumerable <>) || to.GetGenericTypeDefinition() == typeof(List <>)) && to.GetGenericArguments().Length >= 1 && (!(to.GetGenericArguments()[0] == typeof(string)) || !(obj is string))) { IEnumerable enumerable = obj as IEnumerable; if (enumerable != null) { Type type2 = to.GetGenericArguments()[0]; bool flag = true; foreach (object item in enumerable) { if (!CanConvert(item, type2)) { flag = false; break; } } if (flag) { IList list = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(type2)); { foreach (object item2 in enumerable) { list.Add(Convert(item2, type2)); } return(list); } } } } if (obj is IEnumerable && !(obj is string)) { IEnumerable e = (IEnumerable)obj; if (GenCollection.Count_EnumerableBase(e) == 1) { object obj2 = GenCollection.FirstOrDefault_EnumerableBase(e); if (CanConvert(obj2, to)) { return(Convert(obj2, to)); } } } if (typeof(IList).IsAssignableFrom(to)) { IList list2 = (IList)Activator.CreateInstance(to); Type[] genericArguments = to.GetGenericArguments(); if (genericArguments.Length >= 1) { list2.Add(Convert(obj, genericArguments[0])); } else { list2.Add(obj); } return(list2); } if (to == typeof(IEnumerable)) { return(Gen.YieldSingleNonGeneric(obj)); } if (to.IsGenericType && to.GetGenericTypeDefinition() == typeof(IEnumerable <>)) { Type[] genericArguments2 = to.GetGenericArguments(); if (genericArguments2.Length >= 1) { IList obj3 = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(genericArguments2[0])); obj3.Add(Convert(obj, genericArguments2[0])); return(obj3); } return(Gen.YieldSingleNonGeneric(obj)); } IConvertible convertible = obj as IConvertible; if (convertible == null) { return(defaultValue); } try { return(ConvertToPrimitive(convertible, to, defaultValue)); } catch (FormatException) { return(defaultValue); } }
public static T ObjectFromXml <T>(XmlNode xmlRoot, bool doPostLoad) where T : new() { MethodInfo methodInfo = DirectXmlToObject.CustomDataLoadMethodOf(typeof(T)); T result; if (methodInfo != null) { xmlRoot = XmlInheritance.GetResolvedNodeFor(xmlRoot); Type type = DirectXmlToObject.ClassTypeOf <T>(xmlRoot); DirectXmlToObject.currentlyInstantiatingObjectOfType.Push(type); T t; try { t = (T)((object)Activator.CreateInstance(type)); } finally { DirectXmlToObject.currentlyInstantiatingObjectOfType.Pop(); } try { methodInfo.Invoke(t, new object[] { xmlRoot }); } catch (Exception ex) { Log.Error(string.Concat(new object[] { "Exception in custom XML loader for ", typeof(T), ". Node is:\n ", xmlRoot.OuterXml, "\n\nException is:\n ", ex.ToString() }), false); t = default(T); } if (doPostLoad) { DirectXmlToObject.TryDoPostLoad(t); } result = t; } else if (xmlRoot.ChildNodes.Count == 1 && xmlRoot.FirstChild.NodeType == XmlNodeType.CDATA) { if (typeof(T) != typeof(string)) { Log.Error("CDATA can only be used for strings. Bad xml: " + xmlRoot.OuterXml, false); result = default(T); } else { result = (T)((object)xmlRoot.FirstChild.Value); } } else if (xmlRoot.ChildNodes.Count == 1 && xmlRoot.FirstChild.NodeType == XmlNodeType.Text) { try { return((T)((object)ParseHelper.FromString(xmlRoot.InnerText, typeof(T)))); } catch (Exception ex2) { Log.Error(string.Concat(new object[] { "Exception parsing ", xmlRoot.OuterXml, " to type ", typeof(T), ": ", ex2 }), false); } result = default(T); } else if (Attribute.IsDefined(typeof(T), typeof(FlagsAttribute))) { List <T> list = DirectXmlToObject.ListFromXml <T>(xmlRoot); int num = 0; foreach (T t2 in list) { int num2 = (int)((object)t2); num |= num2; } result = (T)((object)num); } else if (typeof(T).HasGenericDefinition(typeof(List <>))) { MethodInfo method = typeof(DirectXmlToObject).GetMethod("ListFromXml", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); Type[] genericArguments = typeof(T).GetGenericArguments(); MethodInfo methodInfo2 = method.MakeGenericMethod(genericArguments); object[] parameters = new object[] { xmlRoot }; object obj = methodInfo2.Invoke(null, parameters); result = (T)((object)obj); } else if (typeof(T).HasGenericDefinition(typeof(Dictionary <, >))) { MethodInfo method2 = typeof(DirectXmlToObject).GetMethod("DictionaryFromXml", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); Type[] genericArguments2 = typeof(T).GetGenericArguments(); MethodInfo methodInfo3 = method2.MakeGenericMethod(genericArguments2); object[] parameters2 = new object[] { xmlRoot }; object obj2 = methodInfo3.Invoke(null, parameters2); result = (T)((object)obj2); } else { if (!xmlRoot.HasChildNodes) { if (typeof(T) == typeof(string)) { return((T)((object)"")); } XmlAttribute xmlAttribute = xmlRoot.Attributes["IsNull"]; if (xmlAttribute != null && xmlAttribute.Value.ToUpperInvariant() == "TRUE") { return(default(T)); } if (typeof(T).IsGenericType) { Type genericTypeDefinition = typeof(T).GetGenericTypeDefinition(); if (genericTypeDefinition == typeof(List <>) || genericTypeDefinition == typeof(HashSet <>) || genericTypeDefinition == typeof(Dictionary <, >)) { return(Activator.CreateInstance <T>()); } } } xmlRoot = XmlInheritance.GetResolvedNodeFor(xmlRoot); Type type2 = DirectXmlToObject.ClassTypeOf <T>(xmlRoot); Type type3 = Nullable.GetUnderlyingType(type2) ?? type2; DirectXmlToObject.currentlyInstantiatingObjectOfType.Push(type3); T t3; try { t3 = (T)((object)Activator.CreateInstance(type3)); } finally { DirectXmlToObject.currentlyInstantiatingObjectOfType.Pop(); } List <string> list2 = null; if (xmlRoot.ChildNodes.Count > 1) { list2 = new List <string>(); } for (int i = 0; i < xmlRoot.ChildNodes.Count; i++) { XmlNode xmlNode = xmlRoot.ChildNodes[i]; if (!(xmlNode is XmlComment)) { if (xmlRoot.ChildNodes.Count > 1) { if (list2.Contains(xmlNode.Name)) { Log.Error(string.Concat(new object[] { "XML ", typeof(T), " defines the same field twice: ", xmlNode.Name, ".\n\nField contents: ", xmlNode.InnerText, ".\n\nWhole XML:\n\n", xmlRoot.OuterXml }), false); } else { list2.Add(xmlNode.Name); } } FieldInfo fieldInfo = DirectXmlToObject.GetFieldInfoForType(t3.GetType(), xmlNode.Name, xmlRoot); if (fieldInfo == null) { foreach (FieldInfo fieldInfo2 in t3.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)) { foreach (object obj3 in fieldInfo2.GetCustomAttributes(typeof(LoadAliasAttribute), true)) { string alias = ((LoadAliasAttribute)obj3).alias; if (alias.EqualsIgnoreCase(xmlNode.Name)) { fieldInfo = fieldInfo2; break; } } if (fieldInfo != null) { break; } } } if (fieldInfo == null) { bool flag = false; foreach (object obj4 in t3.GetType().GetCustomAttributes(typeof(IgnoreSavedElementAttribute), true)) { string elementToIgnore = ((IgnoreSavedElementAttribute)obj4).elementToIgnore; if (string.Equals(elementToIgnore, xmlNode.Name, StringComparison.OrdinalIgnoreCase)) { flag = true; break; } } if (!flag) { Log.Error(string.Concat(new string[] { "XML error: ", xmlNode.OuterXml, " doesn't correspond to any field in type ", t3.GetType().Name, ". Context: ", xmlRoot.OuterXml }), false); } } else if (typeof(Def).IsAssignableFrom(fieldInfo.FieldType)) { if (xmlNode.InnerText.NullOrEmpty()) { fieldInfo.SetValue(t3, null); } else { DirectXmlCrossRefLoader.RegisterObjectWantsCrossRef(t3, fieldInfo, xmlNode.InnerText); } } else { object value = null; try { MethodInfo method3 = typeof(DirectXmlToObject).GetMethod("ObjectFromXml", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); MethodInfo methodInfo4 = method3.MakeGenericMethod(new Type[] { fieldInfo.FieldType }); value = methodInfo4.Invoke(null, new object[] { xmlNode, doPostLoad }); } catch (Exception ex3) { Log.Error("Exception loading from " + xmlNode.ToString() + ": " + ex3.ToString(), false); goto IL_863; } if (!typeof(T).IsValueType) { fieldInfo.SetValue(t3, value); } else { object obj5 = t3; fieldInfo.SetValue(obj5, value); t3 = (T)((object)obj5); } } } IL_863 :; } if (doPostLoad) { DirectXmlToObject.TryDoPostLoad(t3); } result = t3; } return(result); }
public void LoadDataFromXmlCustom(XmlNode xmlRoot) { foreach (XmlNode childNode in xmlRoot.ChildNodes) { if (!(childNode is XmlComment)) { string text = childNode.Name.ToLower(); if (text.StartsWith("v")) { text = text.Substring(1); } if (!itemForVersion.ContainsKey(text)) { itemForVersion[text] = ((typeof(T) == typeof(string)) ? ((T)(object)childNode.FirstChild.Value) : DirectXmlToObject.ObjectFromXml <T>(childNode, doPostLoad: false)); } else { Log.Warning("More than one value for a same version of " + typeof(T).Name + " named " + xmlRoot.Name); } } } }
public static T ObjectFromXml <T>(XmlNode xmlRoot, bool doPostLoad) where T : new() { MethodInfo methodInfo = DirectXmlToObject.CustomDataLoadMethodOf(typeof(T)); if (methodInfo != null) { xmlRoot = XmlInheritance.GetResolvedNodeFor(xmlRoot); Type type = DirectXmlToObject.ClassTypeOf <T>(xmlRoot); T val = (T)Activator.CreateInstance(type); try { methodInfo.Invoke(val, new object[1] { xmlRoot }); } catch (Exception ex) { Log.Error("Exception in custom XML loader for " + typeof(T) + ". Node is:\n " + xmlRoot.OuterXml + "\n\nException is:\n " + ex.ToString()); val = default(T); } if (doPostLoad) { DirectXmlToObject.TryDoPostLoad(val); } return(val); } if (xmlRoot.ChildNodes.Count == 1 && xmlRoot.FirstChild.NodeType == XmlNodeType.CDATA) { if (typeof(T) != typeof(string)) { Log.Error("CDATA can only be used for strings. Bad xml: " + xmlRoot.OuterXml); return(default(T)); } return((T)(object)xmlRoot.FirstChild.Value); } if (xmlRoot.ChildNodes.Count == 1 && xmlRoot.FirstChild.NodeType == XmlNodeType.Text) { try { return((T)ParseHelper.FromString(xmlRoot.InnerText, typeof(T))); } catch (Exception ex2) { Log.Error("Exception parsing " + xmlRoot.OuterXml + " to type " + typeof(T) + ": " + ex2); } return(default(T)); } if (Attribute.IsDefined(typeof(T), typeof(FlagsAttribute))) { List <T> list = DirectXmlToObject.ListFromXml <T>(xmlRoot); int num = 0; foreach (T item in list) { int num2 = (int)(object)item; num |= num2; } return((T)(object)num); } if (typeof(T).HasGenericDefinition(typeof(List <>))) { MethodInfo method = typeof(DirectXmlToObject).GetMethod("ListFromXml", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); Type[] genericArguments = typeof(T).GetGenericArguments(); MethodInfo methodInfo2 = method.MakeGenericMethod(genericArguments); object[] parameters = new object[1] { xmlRoot }; object obj = methodInfo2.Invoke(null, parameters); return((T)obj); } if (typeof(T).HasGenericDefinition(typeof(Dictionary <, >))) { MethodInfo method2 = typeof(DirectXmlToObject).GetMethod("DictionaryFromXml", BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); Type[] genericArguments2 = typeof(T).GetGenericArguments(); MethodInfo methodInfo3 = method2.MakeGenericMethod(genericArguments2); object[] parameters2 = new object[1] { xmlRoot }; object obj2 = methodInfo3.Invoke(null, parameters2); return((T)obj2); } if (!xmlRoot.HasChildNodes) { if (typeof(T) == typeof(string)) { return((T)(object)string.Empty); } XmlAttribute xmlAttribute = xmlRoot.Attributes["IsNull"]; if (xmlAttribute != null && xmlAttribute.Value.ToUpperInvariant() == "TRUE") { return(default(T)); } if (typeof(T).IsGenericType) { Type genericTypeDefinition = typeof(T).GetGenericTypeDefinition(); if (genericTypeDefinition != typeof(List <>) && genericTypeDefinition != typeof(HashSet <>) && genericTypeDefinition != typeof(Dictionary <, >)) { goto IL_03ed; } return(new T()); } } goto IL_03ed; IL_03ed: xmlRoot = XmlInheritance.GetResolvedNodeFor(xmlRoot); Type type2 = DirectXmlToObject.ClassTypeOf <T>(xmlRoot); T val2 = (T)Activator.CreateInstance(type2); List <string> list2 = null; if (xmlRoot.ChildNodes.Count > 1) { list2 = new List <string>(); } for (int i = 0; i < xmlRoot.ChildNodes.Count; i++) { XmlNode xmlNode = xmlRoot.ChildNodes[i]; if (!(xmlNode is XmlComment)) { if (xmlRoot.ChildNodes.Count > 1) { if (list2.Contains(xmlNode.Name)) { Log.Error("XML " + typeof(T) + " defines the same field twice: " + xmlNode.Name + ".\n\nField contents: " + xmlNode.InnerText + ".\n\nWhole XML:\n\n" + xmlRoot.OuterXml); } else { list2.Add(xmlNode.Name); } } FieldInfo fieldInfo = DirectXmlToObject.GetFieldInfoForType(val2.GetType(), xmlNode.Name, xmlRoot); if (fieldInfo == null) { FieldInfo[] fields = val2.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); int num3 = 0; while (num3 < fields.Length) { FieldInfo fieldInfo2 = fields[num3]; object[] customAttributes = fieldInfo2.GetCustomAttributes(typeof(LoadAliasAttribute), true); foreach (object obj3 in customAttributes) { string alias = ((LoadAliasAttribute)obj3).alias; if (alias.EqualsIgnoreCase(xmlNode.Name)) { fieldInfo = fieldInfo2; break; } } if (fieldInfo == null) { num3++; continue; } break; } } if (fieldInfo == null) { bool flag = false; object[] customAttributes2 = val2.GetType().GetCustomAttributes(typeof(IgnoreSavedElementAttribute), true); foreach (object obj4 in customAttributes2) { string elementToIgnore = ((IgnoreSavedElementAttribute)obj4).elementToIgnore; if (string.Equals(elementToIgnore, xmlNode.Name, StringComparison.OrdinalIgnoreCase)) { flag = true; break; } } if (!flag) { Log.Error("XML error: " + xmlNode.OuterXml + " doesn't correspond to any field in type " + val2.GetType().Name + "."); } } else if (typeof(Def).IsAssignableFrom(fieldInfo.FieldType)) { if (xmlNode.InnerText.NullOrEmpty()) { fieldInfo.SetValue(val2, null); } else { DirectXmlCrossRefLoader.RegisterObjectWantsCrossRef(val2, fieldInfo, xmlNode.InnerText); } } else { object obj5 = null; try { MethodInfo method3 = typeof(DirectXmlToObject).GetMethod("ObjectFromXml", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); MethodInfo methodInfo4 = method3.MakeGenericMethod(fieldInfo.FieldType); obj5 = methodInfo4.Invoke(null, new object[2] { xmlNode, doPostLoad }); } catch (Exception ex3) { Log.Error("Exception loading from " + xmlNode.ToString() + ": " + ex3.ToString()); continue; } if (!typeof(T).IsValueType) { fieldInfo.SetValue(val2, obj5); } else { object obj6 = val2; fieldInfo.SetValue(obj6, obj5); val2 = (T)obj6; } } } } if (doPostLoad) { DirectXmlToObject.TryDoPostLoad(val2); } return(val2); }