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