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); } } }
public static TypeSignature GetTypeSignature(Type type) { if (type == null) { return(TypeSignature.Null); } if (type.IsPrimitive() == true || type == typeof(Decimal) || type == typeof(string)) { return(TypeSignature.Primitive); } if (type.IsEnum() == true || type == typeof(EnumInstance)) { return(TypeSignature.Enum); } if (typeof(Object).IsAssignableFrom(type) == true || type == typeof(UnityObject)) { return(TypeSignature.UnityObject); } if (type.IsArray == true) { return(TypeSignature.Array | TypeHandlersManager.GetTypeSignature(type.GetElementType())); } if (type.GetInterface(typeof(IList <>).Name) != null) // IList<> with Serializable elements. { return(TypeSignature.Array | TypeHandlersManager.GetTypeSignature(type.GetInterface(typeof(IList <>).Name).GetGenericArguments()[0])); } if (typeof(IList).IsAssignableFrom(type) == true) { return(TypeSignature.Array); } return(TypeSignature.Class); }
public static Type GetClientType(Type type) { return(TypeHandlersManager.GetClientType(type, TypeHandlersManager.GetTypeSignature(type))); }
public static void Serializer(ByteBuffer buffer, Type fieldType, object instance) { using (SafeWrapByteBuffer.Get(buffer)) { IEnumerable array = instance as IEnumerable; if (array == null) { buffer.Append(-1); // -1 = null array return; } bool isBigArray = false; int count = 0; if (fieldType.IsArray == true) { Array a = array as Array; count = a.Length; isBigArray = a.Length > ArrayData.BigArrayThreshold; } else if (typeof(IList).IsAssignableFrom(fieldType) == true) { IList a = array as IList; count = a.Count; isBigArray = a.Count > ArrayData.BigArrayThreshold; } else { throw new InvalidCastException("Array of type \"" + fieldType + "\" is not supported."); } buffer.Append(count); if (ArrayData.forceBigArray == true) { ArrayData.forceBigArray = false; isBigArray = false; } buffer.Append(isBigArray); if (isBigArray == false) { Type subType = Utility.GetArraySubType(fieldType); TypeHandler subHandler; if (subType != null) { subHandler = TypeHandlersManager.GetTypeHandler(subType); } else { subType = typeof(object); subHandler = TypeHandlersManager.GetTypeHandler(subType); } if (subHandler != null) { buffer.AppendUnicodeString(subHandler.GetType().GetShortAssemblyType()); buffer.Append((byte)TypeHandlersManager.GetTypeSignature(subType)); foreach (object item in array) { subHandler.Serialize(buffer, subType, item); } } else { buffer.Append(0); } } } }