public override ShapeBase CreateShape(string classname, string name, PropertyEntryCollection properties)
{
Type t = GetTypeByName(classname, typeof(ShapeBase), ThrowExceptions);
if (t == null)
{
return(null);
}
string moreFailInfo = "";
try
{
object[] args = new object[1] {
name
}; // always use the "name" constructor
ShapeBase newObject = Activator.CreateInstance(t, args) as ShapeBase;
if (newObject == null)
{
if (ThrowExceptions)
{
throw new Exception("Failed to create instance of class '" + classname + "'");
}
return(null);
}
RecursiveParseProperties(newObject, properties);
return(newObject);
}
catch (Exception ex)
{
EditorManager.DumpException(ex, false);
moreFailInfo = "\nDetailed: ";
if (ex.InnerException != null)
{
moreFailInfo += ex.InnerException.ToString();
}
else
{
moreFailInfo += ex.Message;
}
}
if (ThrowExceptions)
{
throw new Exception("Failed to create instance of class '" + classname + "'" + moreFailInfo);
}
return(null);
}
public override ShapeBase CreateShape(string classname, string name, PropertyEntryCollection properties)
{
Type t = GetTypeByName(classname,typeof(ShapeBase),ThrowExceptions);
if (t == null)
return null;
string moreFailInfo = "";
try
{
object[] args = new object[1] { name }; // always use the "name" constructor
ShapeBase newObject = Activator.CreateInstance(t, args) as ShapeBase;
if (newObject == null)
{
if (ThrowExceptions)
throw new Exception("Failed to create instance of class '" + classname + "'");
return null;
}
RecursiveParseProperties(newObject, properties);
return newObject;
}
catch (Exception ex)
{
EditorManager.DumpException(ex, false);
moreFailInfo = "\nDetailed: ";
if (ex.InnerException != null)
moreFailInfo += ex.InnerException.ToString();
else
moreFailInfo += ex.Message;
}
if (ThrowExceptions)
throw new Exception("Failed to create instance of class '" + classname + "'" + moreFailInfo);
return null;
}
public override void RecursiveParseProperties(object target, PropertyEntryCollection properties)
{
Type t = target.GetType();
int iSuccess = 0;
if (properties != null)
{
// match up properties from passed dictionary
PropertyInfo[] props = t.GetProperties();
foreach (PropertyInfo prop in props)
{
if (!prop.CanWrite)
continue;
PropertyEntry entry;
if (!properties.TryGetValue(prop.Name, out entry))
continue;
if (entry == null || (!entry.HasSubProperties && string.IsNullOrEmpty(entry.ValueString)))
continue;
iSuccess++;
// convert string value to object
object newValue = SerializationHelper.GetObjectFromStringData(prop.PropertyType, entry.ValueString, ",");
if (newValue != null)
{
if ((newValue is string) && !string.IsNullOrEmpty(FilenameResolvePath))
{
object[] isFilename = prop.GetCustomAttributes(typeof(PrefabResolveFilenameAttribute), false);
if (isFilename != null && isFilename.Length > 0)
{
//ensure that only backslashes are in the string. Otherwise could have mixed back and frontslashes in the string
newValue = ((string)newValue).Replace("/", @"\");
newValue = Path.Combine(FilenameResolvePath, (string)newValue);
newValue = FileHelper.ResolveFilename((string)newValue);
}
}
prop.SetValue(target, newValue, null);
}
// assume we have a class here:
if (entry.SubProperties != null)
{
// is the property there already? otherwise create a new instance...
object childObj = prop.GetValue(target, null);
if (childObj == null)
{
throw new Exception("Prefab xml reading error: Property value is not set for '" + prop.Name + "'");
}
// parse the sub-property:
RecursiveParseProperties(childObj, entry.SubProperties);
continue; // everything OK
}
if (ThrowExceptions && SerializationHelper.LastException != null)
throw SerializationHelper.LastException;
}
//////////////////////////////
// The following check is for debug purposes only:
// The number of successfully set properties should match the size of the passed property list.
if (iSuccess != properties.Count)
{
string missingProperties = "";
// At this point it is not very easy to find out *which* one was missing, so loop the other way around:
string[] sourceKeys = properties.AllKeys;
foreach (string key in sourceKeys)
{
bool bFound = false;
bool bExact = false;
foreach (PropertyInfo prop in props)
if (prop.CanWrite && string.Compare(prop.Name, key, true) == 0)
{
bExact = string.Compare(prop.Name, key, false) == 0;
bFound = true;
break;
}
if (!bFound || !bExact)
{
if (!bFound)
missingProperties += "\n" + key + " : missing";
else if (!bExact)
missingProperties += "\n" + key + " : Casing (warning)";
}
}
Log.Error("The definition contains some invalid properties:\n" + missingProperties);
}
//////////////////////////////////
}
}
public override void RecursiveParseProperties(object target, PropertyEntryCollection properties)
{
Type t = target.GetType();
int iSuccess = 0;
if (properties != null)
{
// match up properties from passed dictionary
PropertyInfo[] props = t.GetProperties();
foreach (PropertyInfo prop in props)
{
if (!prop.CanWrite)
{
continue;
}
PropertyEntry entry;
if (!properties.TryGetValue(prop.Name, out entry))
{
continue;
}
if (entry == null || (!entry.HasSubProperties && string.IsNullOrEmpty(entry.ValueString)))
{
continue;
}
iSuccess++;
// convert string value to object
object newValue = SerializationHelper.GetObjectFromStringData(prop.PropertyType, entry.ValueString, ",");
if (newValue != null)
{
if ((newValue is string) && !string.IsNullOrEmpty(FilenameResolvePath))
{
object[] isFilename = prop.GetCustomAttributes(typeof(PrefabResolveFilenameAttribute), false);
if (isFilename != null && isFilename.Length > 0)
{
//ensure that only backslashes are in the string. Otherwise could have mixed back and frontslashes in the string
newValue = ((string)newValue).Replace("/", @"\");
newValue = Path.Combine(FilenameResolvePath, (string)newValue);
newValue = FileHelper.ResolveFilename((string)newValue);
}
}
prop.SetValue(target, newValue, null);
}
// assume we have a class here:
if (entry.SubProperties != null)
{
// is the property there already? otherwise create a new instance...
object childObj = prop.GetValue(target, null);
if (childObj == null)
{
throw new Exception("Prefab xml reading error: Property value is not set for '" + prop.Name + "'");
}
// parse the sub-property:
RecursiveParseProperties(childObj, entry.SubProperties);
continue; // everything OK
}
if (ThrowExceptions && SerializationHelper.LastException != null)
{
throw SerializationHelper.LastException;
}
}
//////////////////////////////
// The following check is for debug purposes only:
// The number of successfully set properties should match the size of the passed property list.
if (iSuccess != properties.Count)
{
string missingProperties = "";
// At this point it is not very easy to find out *which* one was missing, so loop the other way around:
string[] sourceKeys = properties.AllKeys;
foreach (string key in sourceKeys)
{
bool bFound = false;
bool bExact = false;
foreach (PropertyInfo prop in props)
{
if (prop.CanWrite && string.Compare(prop.Name, key, true) == 0)
{
bExact = string.Compare(prop.Name, key, false) == 0;
bFound = true;
break;
}
}
if (!bFound || !bExact)
{
if (!bFound)
{
missingProperties += "\n" + key + " : missing";
}
else if (!bExact)
{
missingProperties += "\n" + key + " : Casing (warning)";
}
}
}
EditorManager.EditorConsole.PrintError("The definition contains some invalid properties:\n" + missingProperties);
}
//////////////////////////////////
}
}
public override void RecursiveParseProperties(object target, PropertyEntryCollection properties)
{
Type t = target.GetType();
int iSuccess = 0;
if (properties != null)
{
// match up properties from passed dictionary
PropertyInfo[] props = t.GetProperties();
foreach (PropertyInfo prop in props)
{
if (!prop.CanWrite)
continue;
PropertyEntry entry;
if (!properties.TryGetValue(prop.Name, out entry))
continue;
if (entry == null || (!entry.HasSubProperties && string.IsNullOrEmpty(entry.ValueString)))
continue;
iSuccess++;
// special treatment for array
if (prop.PropertyType.IsArray && entry.HasSubProperties)
{
List<object> array = new List<object>();
Dictionary<string, PropertyEntry>.ValueCollection elements = entry.SubProperties.Values;
foreach (PropertyEntry arrayElemEntry in elements)
{
Type elemType = prop.PropertyType.GetElementType();
// Get TypeByName is not necessary here as we already have the type
// and resolving by name can lead to wrong types when the type name is not unique (as in Vector3F).
// this.GetTypeByName(arrayElemEntry.ValueString, typeof(object), ThrowExceptions);
object arrayElem = Activator.CreateInstance(elemType);
if (arrayElem != null)
{
RecursiveParseProperties(arrayElem, arrayElemEntry.SubProperties);
}
// fill up:
for (int i = array.Count; i < arrayElemEntry.ArrayElementIndex; i++)
array.Add(null);
array.Add(arrayElem);
}
// set the array
object[] args = new object[] { array.Count };
object targetArrayObj = Activator.CreateInstance(prop.PropertyType, args);
{
Array targetArrayArr = (Array)targetArrayObj;
for (int i = 0; i < array.Count; ++i)
{
targetArrayArr.SetValue(array[i], i);
}
}
prop.SetValue(target, targetArrayObj, null);
continue;
}
// convert string value to object
object newValue = SerializationHelper.GetObjectFromStringData(prop.PropertyType, entry.ValueString, ",");
if (newValue != null)
{
if ((newValue is string) && !string.IsNullOrEmpty(FilenameResolvePath))
{
object[] isFilename = prop.GetCustomAttributes(typeof(PrefabResolveFilenameAttribute), false);
if (isFilename != null && isFilename.Length > 0)
{
//ensure that only backslashes are in the string. Otherwise could have mixed back and forward slashes in the string
newValue = ((string)newValue).Replace("/", @"\");
newValue = Path.Combine(FilenameResolvePath, (string)newValue);
newValue = FileHelper.ResolveFilename((string)newValue);
}
}
prop.SetValue(target, newValue, null);
}
// assume we have a class here:
if (entry.SubProperties != null)
{
// is the property there already? otherwise create a new instance...
object childObj = prop.GetValue(target, null);
if (childObj == null)
{
throw new Exception("Prefab xml reading error: Property value is not set for '" + prop.Name + "'");
}
// parse the sub-property:
RecursiveParseProperties(childObj, entry.SubProperties);
continue; // everything OK
}
if (ThrowExceptions && SerializationHelper.LastException != null)
throw SerializationHelper.LastException;
}
//////////////////////////////
// The following check is for debug purposes only:
// The number of successfully set properties should match the size of the passed property list.
if (iSuccess != properties.Count)
{
string missingProperties = "";
// At this point it is not very easy to find out *which* one was missing, so loop the other way around:
string[] sourceKeys = properties.AllKeys;
foreach (string key in sourceKeys)
{
bool bFound = false;
bool bExact = false;
foreach (PropertyInfo prop in props)
if (prop.CanWrite && string.Compare(prop.Name, key, true) == 0)
{
bExact = string.Compare(prop.Name, key, false) == 0;
bFound = true;
break;
}
if (!bFound || !bExact)
{
if (!bFound)
missingProperties += "\n" + key + " : missing";
else if (!bExact)
missingProperties += "\n" + key + " : Casing (warning)";
}
}
Log.Error("The definition contains some invalid properties:\n" + missingProperties);
}
//////////////////////////////////
}
}
public PropertyEntryCollectionWrapper(PropertyEntryCollection propertyEntryCollection)
{
this.propertyEntryCollection = propertyEntryCollection;
this.customProperties = new Collection <PropertyReferenceProperty>();
}
public override void RecursiveParseProperties(object target, PropertyEntryCollection properties)
{
Type t = target.GetType();
int iSuccess = 0;
if (properties != null)
{
// match up properties from passed dictionary
PropertyInfo[] props = t.GetProperties();
foreach (PropertyInfo prop in props)
{
if (!prop.CanWrite)
{
continue;
}
PropertyEntry entry;
if (!properties.TryGetValue(prop.Name, out entry))
{
continue;
}
if (entry == null || (!entry.HasSubProperties && string.IsNullOrEmpty(entry.ValueString)))
{
continue;
}
iSuccess++;
// special treatment for array
if (prop.PropertyType.IsArray && entry.HasSubProperties)
{
List <object> array = new List <object>();
Dictionary <string, PropertyEntry> .ValueCollection elements = entry.SubProperties.Values;
foreach (PropertyEntry arrayElemEntry in elements)
{
Type elemType = prop.PropertyType.GetElementType();
// Get TypeByName is not necessary here as we already have the type
// and resolving by name can lead to wrong types when the type name is not unique (as in Vector3F).
// this.GetTypeByName(arrayElemEntry.ValueString, typeof(object), ThrowExceptions);
object arrayElem = Activator.CreateInstance(elemType);
if (arrayElem != null)
{
RecursiveParseProperties(arrayElem, arrayElemEntry.SubProperties);
}
// fill up:
for (int i = array.Count; i < arrayElemEntry.ArrayElementIndex; i++)
{
array.Add(null);
}
array.Add(arrayElem);
}
// set the array
object[] args = new object[] { array.Count };
object targetArrayObj = Activator.CreateInstance(prop.PropertyType, args);
{
Array targetArrayArr = (Array)targetArrayObj;
for (int i = 0; i < array.Count; ++i)
{
targetArrayArr.SetValue(array[i], i);
}
}
prop.SetValue(target, targetArrayObj, null);
continue;
}
// convert string value to object
object newValue = SerializationHelper.GetObjectFromStringData(prop.PropertyType, entry.ValueString, ",");
if (newValue != null)
{
if ((newValue is string) && !string.IsNullOrEmpty(FilenameResolvePath))
{
object[] isFilename = prop.GetCustomAttributes(typeof(PrefabResolveFilenameAttribute), false);
if (isFilename != null && isFilename.Length > 0)
{
//ensure that only backslashes are in the string. Otherwise could have mixed back and forward slashes in the string
newValue = ((string)newValue).Replace("/", @"\");
newValue = Path.Combine(FilenameResolvePath, (string)newValue);
newValue = FileHelper.ResolveFilename((string)newValue);
}
}
prop.SetValue(target, newValue, null);
}
// assume we have a class here:
if (entry.SubProperties != null)
{
// is the property there already? otherwise create a new instance...
object childObj = prop.GetValue(target, null);
if (childObj == null)
{
throw new Exception("Prefab xml reading error: Property value is not set for '" + prop.Name + "'");
}
// parse the sub-property:
RecursiveParseProperties(childObj, entry.SubProperties);
continue; // everything OK
}
if (ThrowExceptions && SerializationHelper.LastException != null)
{
throw SerializationHelper.LastException;
}
}
//////////////////////////////
// The following check is for debug purposes only:
// The number of successfully set properties should match the size of the passed property list.
if (iSuccess != properties.Count)
{
string missingProperties = "";
// At this point it is not very easy to find out *which* one was missing, so loop the other way around:
string[] sourceKeys = properties.AllKeys;
foreach (string key in sourceKeys)
{
bool bFound = false;
bool bExact = false;
foreach (PropertyInfo prop in props)
{
if (prop.CanWrite && string.Compare(prop.Name, key, true) == 0)
{
bExact = string.Compare(prop.Name, key, false) == 0;
bFound = true;
break;
}
}
if (!bFound || !bExact)
{
if (!bFound)
{
missingProperties += "\n" + key + " : missing";
}
else if (!bExact)
{
missingProperties += "\n" + key + " : Casing (warning)";
}
}
}
Log.Error("The definition contains some invalid properties:\n" + missingProperties);
}
//////////////////////////////////
}
}
