public Match(object instance, IFieldModifier fieldModifier)
{
this.path = fieldModifier.Name;
this.instance = instance;
this.fieldModifier = fieldModifier;
this.type = this.fieldModifier.Type;
}
public MemberCommand(IFieldModifier member, object instance) : base(instance, member.Name, string.Empty)
{
this.member = member;
this.constraints = member.GetCustomAttributes(typeof(PropertyConstraintAttribute), true) as PropertyConstraintAttribute[];
if (this.member.Type.IsClass() == true &&
this.member.Type != typeof(string))
{
throw new NotSupportedMemberTypeException(this.member);
}
}
public MonitorArray(string path, IFieldModifier fieldInfo, Func <object> getInstance) : base(path, getInstance)
{
this.sizeHandler = TypeHandlersManager.GetTypeHandler(typeof(int));
this.fieldInfo = fieldInfo;
this.lastSize = this.GetSize();
object instance = this.fieldInfo.GetValue(this.getInstance());
if (instance != null)
{
this.MonitorSubData(instance.GetType(), () => this.fieldInfo.GetValue(this.getInstance()));
}
}
public MemberDrawer(TypeDrawer typeDrawer, IFieldModifier fieldModifier)
{
this.typeDrawer = typeDrawer;
this.fieldModifier = fieldModifier;
if (this.fieldModifier is FieldModifier)
{
FieldModifier modifier = (this.fieldModifier as FieldModifier);
this.isEditable = modifier.fieldInfo.IsLiteral == false && modifier.fieldInfo.IsInitOnly == false;
}
else
{
this.isEditable = (this.fieldModifier as PropertyModifier).propertyInfo.GetSetMethod() != null;
}
}
public IFieldModifier[] GetFields()
{
FieldInfo[] fields = this.GetFieldInfos();
PropertyInfo[] properties = this.GetPropertyInfos();
IFieldModifier[] result = new IFieldModifier[fields.Length + properties.Length];
int i = 0;
for (; i < fields.Length; ++i)
{
result[i] = new FieldModifier(fields[i]);
}
for (int j = 0; j < properties.Length; ++j, ++i)
{
result[i] = new PropertyModifier(properties[j]);
}
return(result);
}
public static void Serialize(ByteBuffer buffer, object instance, IFieldModifier field)
{
using (SafeWrapByteBuffer.Get(buffer))
{
buffer.AppendUnicodeString(field.Type.GetShortAssemblyType());
buffer.AppendUnicodeString(field.Name);
buffer.Append(field.IsPublic);
TypeHandler handler = TypeHandlersManager.GetTypeHandler(field.Type);
if (handler != null)
{
if (field.MemberInfo.DeclaringType.IsGenericTypeDefinition == false || ((field is FieldModifier) == true && (field as FieldModifier).fieldInfo.IsLiteral == true))
{
buffer.AppendUnicodeString(handler.GetType().GetShortAssemblyType());
try
{
buffer.Append((byte)TypeHandlersManager.GetTypeSignature(field.Type));
ByteBuffer handlerBuffer = Utility.GetBBuffer();
handler.Serialize(handlerBuffer, field.Type, field.GetValue(instance));
buffer.Append(Utility.ReturnBBuffer(handlerBuffer));
}
catch (Exception ex)
{
buffer.Append((byte)TypeSignature.Null);
InternalNGDebug.LogException("Member \"" + field.Name + "\" failed.", ex);
throw;
}
}
else // Leave it unsupported.
{
buffer.Append(0);
}
}
else
{
buffer.Append(0);
}
}
}
private ImportNode(ImportNode parent, SettingsExporter.Node node, Type workingType, object workingInstance)
{
this.parent = parent;
this.node = node;
// Instance is null only when the parent is an array.
this.instanceType = workingType;
// Look for class.
//if (this.instanceType.FullName == node.name)
// this.instance = instance;
// Look for array element.
if (typeof(IEnumerable).IsAssignableFrom(this.instanceType) == true)
{
this.arrayElementType = Type.GetType(node.name);
if (this.arrayElementType == null)
{
Debug.LogWarning("Type \"" + node.name + "\" was not recognized.");
}
else
{
foreach (ExportableAttribute attribute in this.arrayElementType.EachCustomAttributesIncludingBaseInterfaces <ExportableAttribute>())
{
this.arrayExportOptions = attribute.options;
if ((attribute.options & ExportableAttribute.ArrayOptions.Add) != 0)
{
this.arrayImportOption = ArrayImportOption.Add;
}
else if ((attribute.options & ExportableAttribute.ArrayOptions.Overwrite) != 0)
{
this.arrayImportOption = ArrayImportOption.Overwrite;
}
}
}
this.instance = null;
this.instanceType = this.arrayElementType;
if (workingInstance != null)
{
IEnumerable array = workingInstance as IEnumerable;
foreach (var item in array)
{
if (item.GetType() == this.arrayElementType &&
ImportSettingsWizard.trackObjects.Contains(item) == false)
{
this.instance = item;
ImportSettingsWizard.trackObjects.Add(item);
break;
}
}
}
//if (this.instance == null)
// this.instance = Activator.CreateInstance(this.arrayElementType);
}
// Look for field.
else
{
FieldInfo fieldInfo = this.instanceType.GetField(node.name, SettingsExporter.SearchFlags);
if (fieldInfo != null)
{
if (fieldInfo.IsDefined(typeof(HideFromExportAttribute), true) == true)
{
node.options = SettingsExporter.Node.Option.Hidden;
}
this.fieldInfo = new FieldModifier(fieldInfo);
if (this.fieldInfo.IsDefined(typeof(ExportableAttribute), true) == true)
{
this.arrayExportOptions = (this.fieldInfo.GetCustomAttributes(typeof(ExportableAttribute), true)[0] as ExportableAttribute).options;
this.instanceType = this.fieldInfo.Type;
if (workingInstance != null)
{
this.instance = this.fieldInfo.GetValue(workingInstance);
}
}
}
else
{
PropertyInfo propertyInfo = this.instanceType.GetProperty(node.name, SettingsExporter.SearchFlags);
if (propertyInfo == null)
{
Debug.LogWarning("Name \"" + node.name + "\" was not found in " + this.instanceType.FullName + ".");
}
else
{
if (propertyInfo.IsDefined(typeof(HideFromExportAttribute), true) == true)
{
node.options = SettingsExporter.Node.Option.Hidden;
}
this.fieldInfo = new PropertyModifier(propertyInfo);
if (this.fieldInfo.IsDefined(typeof(ExportableAttribute), true) == true)
{
this.arrayExportOptions = (this.fieldInfo.GetCustomAttributes(typeof(ExportableAttribute), true)[0] as ExportableAttribute).options;
this.instanceType = this.fieldInfo.Type;
if (workingInstance != null)
{
this.instance = this.fieldInfo.GetValue(workingInstance);
}
}
}
}
//else
// Debug.LogWarning("Field \"" + node.name + "\" is not decorated with the attribute \"" + typeof(ExportableAttribute) + "\" in " + this.instanceType.FullName + ".");
}
//if (this.instance != null)
//{
this.children = new ImportNode[node.children.Count];
for (int i = 0; i < this.children.Length; i++)
{
this.children[i] = new ImportNode(this, node.children[i], this.instanceType, this.instance);
}
//}
//else
// this.children = new ImportNode[0];
}
private void CopyObject(StringBuilder buffer, object instance, string prefix)
{
if (instance != null)
{
Type type = instance.GetType();
object[] actions;
if (this.typeDrawers.TryGetValue(type, out actions) == true)
{
buffer.AppendLine((actions[1] as Func <object, string, string>)(instance, prefix));
}
else
{
if (instance.GetType().IsArray == true)
{
IEnumerable array = instance as IEnumerable;
foreach (object element in array)
{
this.CopyObject(buffer, element, " ");
}
}
else if (type != typeof(string) &&
(type.IsClass == true || type.IsStruct() == true))
{
ClassDefinition classDefinition;
if (this.refMembers.TryGetValue(type, out classDefinition) == false)
{
int j = 0;
FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.Instance);
PropertyInfo[] properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
IFieldModifier[] members = new IFieldModifier[fields.Length + properties.Length];
for (int i = 0; i < fields.Length; i++, ++j)
{
members[j] = new FieldModifier(fields[i]);
}
for (int i = 0; i < properties.Length; i++, ++j)
{
members[j] = new PropertyModifier(properties[i]);
}
classDefinition = new ClassDefinition(members);
this.refMembers.Add(type, classDefinition);
}
for (int i = 0; i < classDefinition.members.Length; i++)
{
this.CopyObject(buffer, classDefinition.members[i].GetValue(instance), " " + classDefinition.nicifiedNames[i] + " : ");
}
}
else
{
buffer.AppendLine(prefix + instance.ToString());
}
}
}
else
{
buffer.AppendLine(prefix + "NULL");
}
}
private object SetValue(string path, object instance, string name, object value)
{
IFieldModifier field = InnerUtility.GetFieldInfo(instance.GetType(), name);
InternalNGDebug.Assert(field != null, "Field \"" + name + "\" was not found in type \"" + instance.GetType() + "\".");
object fieldValue = field.GetValue(instance);
UnityObject uo = value as UnityObject;
if (uo != null)
{
field.SetValue(instance, this.TryFetchFromProject(path, uo));
return(instance);
}
ClientClass gc = value as ClientClass;
if (gc != null)
{
if (fieldValue == null)
{
fieldValue = Activator.CreateInstance(field.Type);
}
IncompleteGameObjectException incompleteEx = null;
for (int j = 0; j < gc.fields.Length; j++)
{
FieldInfo subField = field.Type.GetField(gc.fields[j].name);
InternalNGDebug.Assert(subField != null, "Field \"" + gc.fields[j].name + "\" was not found in type \"" + field.Type + "\".");
if (subField.IsLiteral == true)
{
continue;
}
try
{
fieldValue = this.SetValue(path + '.' + gc.fields[j].name, fieldValue, gc.fields[j].name, gc.fields[j].value);
}
catch (IncompleteGameObjectException ex)
{
if (incompleteEx == null)
{
incompleteEx = ex;
}
else
{
incompleteEx.Aggregate(ex);
}
}
}
if (incompleteEx != null)
{
throw incompleteEx;
}
field.SetValue(instance, fieldValue);
return(instance);
}
ArrayData a = value as ArrayData;
if (a != null)
{
if (a.array != null)
{
Type subType = Utility.GetArraySubType(field.Type);
if (fieldValue == null)
{
fieldValue = Array.CreateInstance(subType, a.array.Length);
}
if (field.Type.IsArray == true)
{
IncompleteGameObjectException incompleteEx = null;
Array fieldArray = fieldValue as Array;
if (fieldArray.Length != a.array.Length)
{
fieldValue = Array.CreateInstance(subType, a.array.Length);
fieldArray = fieldValue as Array;
}
for (int j = 0; j < a.array.Length; j++)
{
try
{
fieldArray.SetValue(this.ConvertValue(path + "#" + j, subType, a.array.GetValue(j)), j);
}
catch (IncompleteGameObjectException ex)
{
if (incompleteEx == null)
{
incompleteEx = ex;
}
else
{
incompleteEx.Aggregate(ex);
}
}
}
if (incompleteEx != null)
{
throw incompleteEx;
}
}
else if (typeof(IList).IsAssignableFrom(field.Type) == true)
{
IncompleteGameObjectException incompleteEx = null;
IList fieldArray = fieldValue as IList;
for (int j = 0; j < a.array.Length; j++)
{
try
{
fieldArray[j] = this.ConvertValue(path + "#" + j, subType, a.array.GetValue(j));
}
catch (IncompleteGameObjectException ex)
{
if (incompleteEx == null)
{
incompleteEx = ex;
}
else
{
incompleteEx.Aggregate(ex);
}
}
}
if (incompleteEx != null)
{
throw incompleteEx;
}
}
else
{
throw new InvalidCastException("Type \"" + field.Type + "\" is not supported as an array.");
}
field.SetValue(instance, fieldValue);
}
return(instance);
}
EnumInstance e = value as EnumInstance;
if (e != null)
{
field.SetValue(instance, e.value);
}
else
{
field.SetValue(instance, value);
}
return(instance);
}
public NotSupportedMemberTypeException(IFieldModifier type)
{
this.member = type;
}
