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