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 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());
}
}
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);
}
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);
}
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 (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;
}
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();
}
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 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);
}
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();
}
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);
}
}
}
}
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);
}
