public override bool LoadFrom(Stream stream)
{
base.LoadFrom(stream);
Attribute.LoadFrom(stream);
BaseTypeName = stream.ReadString();
//types
uint typeCount = stream.ReadUInt();
for (int i = 0; i < typeCount; i++)
{
byte isClass = (byte)stream.ReadByte();
if (isClass == 1)
{
SirenCustomClass type = new SirenCustomClass();
type.LoadFrom(stream);
type.Parent = this;
Types.Add(type.Name, type);
}
else
{
SirenCustomEnum type = new SirenCustomEnum();
type.LoadFrom(stream);
type.Parent = this;
Types.Add(type.Name, type);
}
}
//fields
uint fieldCount = stream.ReadUInt();
for (int i = 0; i < fieldCount; i++)
{
SirenField field = new SirenField();
field.LoadFrom(stream);
field.ParentType = this;
FieldNameDict.Add(field.Name, field);
field.Index = (ushort)(FieldNameDict.Count - 1);
}
return(true);
}
public override object Clone()
{
SirenCustomClass val = new SirenCustomClass(Name)
{
Attribute = Attribute.Clone() as SirenClassAttribute
};
val.BaseTypeName = BaseTypeName;
val.BaseType = BaseType.Clone() as SirenCustomClass;
foreach (var baseSirenCustomType in Types)
{
val.Types.Add(baseSirenCustomType.Key, baseSirenCustomType.Value.Clone() as BaseSirenCustomType);
}
foreach (var sirenField in FieldNameDict)
{
val.FieldNameDict.Add(sirenField.Key, sirenField.Value.Clone() as SirenField);
}
return(val);
}
public static SirenType FindType(Type type)
{
if (type.IsGenericType)
{
if (type.Name.StartsWith("List"))
{
return new SirenBuildinList(type);
}
if (type.Name.StartsWith("Dictionary"))
{
return new SirenBuildinDictionary(type);
}
}
else
{
if (type.IsValueType)
{
if (type == typeof(bool))
{
return Bool;
}
if (type == typeof(char))
{
return Int8;
}
if (type == typeof(short))
{
return Int16;
}
if (type == typeof(int))
{
return Int32;
}
if (type == typeof(Int64))
{
return Int64;
}
if (type == typeof(byte))
{
return UInt8;
}
if (type == typeof(ushort))
{
return UInt16;
}
if (type == typeof(uint))
{
return UInt32;
}
if (type == typeof(UInt64))
{
return UInt64;
}
if (type == typeof(float))
{
return Float;
}
if (type == typeof(double))
{
return Double;
}
}
else
{
if (type == typeof(string))
{
return String;
}
if (type == typeof(byte[]))
{
return Blob;
}
}
}
SirenCustomClass sirenClass;
if (AllSirenClasses.TryGetValue(type, out sirenClass)) return sirenClass;
if (GenerictSirenClasses.TryGetValue(type, out sirenClass))
{
return sirenClass;
}
SirenCustomEnum sirenEnum;
if (AllSirenEnums.TryGetValue(type, out sirenEnum)) return sirenEnum;
if (type.IsGenericType)
{
Type testType = null;
foreach (var temp in AllSirenClasses)
{
var oldType = temp.Key;
if (oldType.IsGenericTypeDefinition)
{
testType = oldType.MakeGenericType(type.GetGenericArguments());
if (testType == type)
{
var attr2 = type.GetCustomAttributes(typeof(SirenClassAttribute), false);
if (attr2.Length <= 0)
{
return null;
}
sirenClass = new SirenCustomClass(type, attr2[0] as SirenClassAttribute);
sirenClass.Initialize();
break;
}
testType = null;
}
}
if (testType != null)
{
GenerictSirenClasses.Add(testType, sirenClass);
}
}
return sirenClass;
}
static SirenMachine()
{
BuildinTypes.Add(Bool.Name, Bool);
BuildinTypes.Add(Int8.Name, Int8);
BuildinTypes.Add(UInt8.Name, UInt8);
BuildinTypes.Add(Int16.Name, Int16);
BuildinTypes.Add(UInt16.Name, UInt16);
BuildinTypes.Add(Int32.Name, Int32);
BuildinTypes.Add(UInt32.Name, UInt32);
BuildinTypes.Add(Int64.Name, Int64);
BuildinTypes.Add(UInt64.Name, UInt64);
BuildinTypes.Add(Float.Name, Float);
BuildinTypes.Add(Double.Name, Double);
BuildinTypes.Add(String.Name, String);
BuildinTypes.Add(Blob.Name, Blob);
BuildinTypes.Add(List.Name, List);
BuildinTypes.Add(Dictionary.Name, Dictionary);
//alias
BuildinTypes.Add("int8", Int8);
BuildinTypes.Add("uint8", UInt8);
BuildinTypes.Add("int16", Int16);
BuildinTypes.Add("uint16", UInt16);
BuildinTypes.Add("int32", Int32);
BuildinTypes.Add("uint32", UInt32);
BuildinTypes.Add("long", Int64);
BuildinTypes.Add("ulong", UInt64);
BuildinTypes.Add("string", String);
BuildinTypes.Add("String", String);
BuildinTypes.Add("blob", Blob);
//register types
var allAssemblies = GetAllAssemblies();
foreach (var assemblyName in allAssemblies)
{
var assembly = Assembly.Load(assemblyName.Value);
var types = assembly.GetTypes();
foreach (var type in types)
{
var attr2 = type.GetCustomAttributes(typeof(SirenClassAttribute), false);
if (attr2.Length > 0)
{
SirenCustomClass sirenClass = new SirenCustomClass(type, attr2[0] as SirenClassAttribute);
AllSirenClasses.Add(type, sirenClass);
}
var attr3 = type.GetCustomAttributes(typeof(SirenEnumAttribute), false);
if (attr3.Length > 0)
{
SirenCustomEnum sirenEnum = new SirenCustomEnum(type, attr3[0] as SirenEnumAttribute);
AllSirenEnums.Add(type, sirenEnum);
}
}
}
foreach (var sirenClass in AllSirenClasses)
{
sirenClass.Value.Initialize();
}
foreach (var sirenClass in AllSirenEnums)
{
sirenClass.Value.Initialize();
}
}
public override bool LoadFrom(Stream stream)
{
base.LoadFrom(stream);
Attribute.LoadFrom(stream);
BaseTypeName = stream.ReadString();
//types
uint typeCount = stream.ReadUInt();
for (int i = 0; i < typeCount; i++)
{
byte isClass = (byte)stream.ReadByte();
if (isClass == 1)
{
SirenCustomClass type = new SirenCustomClass();
type.LoadFrom(stream);
type.Parent = this;
Types.Add(type.Name, type);
}
else
{
SirenCustomEnum type = new SirenCustomEnum();
type.LoadFrom(stream);
type.Parent = this;
Types.Add(type.Name, type);
}
}
//fields
uint fieldCount = stream.ReadUInt();
for (int i = 0; i < fieldCount; i++)
{
SirenField field = new SirenField();
field.LoadFrom(stream);
field.ParentType = this;
FieldNameDict.Add(field.Name, field);
field.Index = (ushort)(FieldNameDict.Count - 1);
}
return true;
}
public static SirenCustomClass FindClass(Type type)
{
if (type.IsPrimitive || type == typeof(string) || type == typeof(byte[]))
{
return null;
}
SirenCustomClass sirenClass;
if (AllSirenClasses.TryGetValue(type, out sirenClass)) return sirenClass;
if (GenerictSirenClasses.TryGetValue(type, out sirenClass))
{
return sirenClass;
}
if (type.IsGenericType)
{
Type testType = null;
foreach (var temp in AllSirenClasses)
{
var oldType = temp.Key;
if (oldType.IsGenericTypeDefinition)
{
testType = oldType.MakeGenericType(type.GetGenericArguments());
if (testType == type)
{
var attr2 = type.GetCustomAttributes(typeof(SirenClassAttribute), false);
if (attr2.Length <= 0)
{
return null;
}
sirenClass = new SirenCustomClass(type, attr2[0] as SirenClassAttribute);
sirenClass.Initialize();
break;
}
testType = null;
}
}
if (testType != null)
{
GenerictSirenClasses.Add(testType, sirenClass);
}
}
return sirenClass;
}
public override object Clone()
{
SirenCustomClass val = new SirenCustomClass(Name) { Attribute = Attribute.Clone() as SirenClassAttribute };
val.BaseTypeName = BaseTypeName;
val.BaseType = BaseType.Clone() as SirenCustomClass;
foreach (var baseSirenCustomType in Types)
{
val.Types.Add(baseSirenCustomType.Key, baseSirenCustomType.Value.Clone() as BaseSirenCustomType);
}
foreach (var sirenField in FieldNameDict)
{
val.FieldNameDict.Add(sirenField.Key, sirenField.Value.Clone() as SirenField);
}
return val;
}
public void SerializeBase(object obj, SirenCustomClass sirenClass)
{
if (sirenClass.BaseType != null)
{
SerializeBase(obj, sirenClass.BaseType);
}
foreach (var sirenField in sirenClass.Fields)
{
if (sirenField.Attribute.Mode != SirenFieldGenerateMode.Optional)
{
if (!sirenField.HasValue(obj))
{
Logger.ErrorLine("Forget to set {0}.{1}", sirenClass.Name, sirenField.Name);
Writer.OnError();
return;
}
}
else
{
if (!sirenField.HasValue(obj))
{
//skip
return;
}
}
Writer.OnFieldBegin(sirenField.Name, sirenField.Id, sirenField.DataType);
switch (sirenField.FieldType)
{
case SirenPropertyFieldType.Value:
Writer.OnValue(sirenField.Info.GetValue(obj, null));
break;
case SirenPropertyFieldType.String:
Writer.OnString(sirenField.Info.GetValue(obj, null) as string);
break;
case SirenPropertyFieldType.Blob:
Writer.OnMemoryData(sirenField.Info.GetValue(obj, null) as byte[]);
break;
case SirenPropertyFieldType.List:
{
object items = sirenField.Info.GetValue(obj, null);
var listType = sirenField.Type;
int count = Convert.ToInt32(listType.Type.GetProperty("Count").GetValue(items, null));
var itemType = sirenField.Type.Type.GetGenericArguments()[0];
SirenTypeId itemDataType = SirenMachine.GetTypeId(itemType);
Writer.OnListBegin(itemDataType, count);
var itemsProperty = listType.Type.GetProperty("Item");
for (int i = 0; i < count; i++)
{
object listItem = itemsProperty.GetValue(items, new object[] { i });
SerializeHelper(listItem, sirenField.ValueType);
}
Writer.OnListEnd();
}
break;
case SirenPropertyFieldType.Dictionary:
{
object items = sirenField.Info.GetValue(obj, null);
var dictType = sirenField.Type;
int count = Convert.ToInt32(dictType.Type.GetProperty("Count").GetValue(items, null));
var keyType = sirenField.Type.Type.GetGenericArguments()[0];
var valueType = sirenField.Type.Type.GetGenericArguments()[1];
SirenTypeId keyDataType = SirenMachine.GetTypeId(keyType);
SirenTypeId valueDataType = SirenMachine.GetTypeId(valueType);
Writer.OnDictionaryBegin(keyDataType, valueDataType, count);
foreach (var o in (items as IEnumerable))
{
var itemKey = o.GetType().GetProperty("Key").GetValue(o, null);
SerializeHelper(itemKey, sirenField.KeyType);
var itemValue = o.GetType().GetProperty("Value").GetValue(o, null);
SerializeHelper(itemValue, sirenField.ValueType);
}
Writer.OnDictionaryEnd();
}
break;
case SirenPropertyFieldType.Struct:
{
object val = sirenField.Info.GetValue(obj, null);
SerializeHelper(val, sirenField.ValueType);
}
break;
}
Writer.OnFieldEnd();
}
}
public void SerializeStruct(object obj, SirenCustomClass sirenClass)
{
Writer.OnStructBegin();
SerializeBase(obj, sirenClass);
Writer.OnStructEnd();
}
public SirenField(SirenCustomClass parentSirenClass, PropertyInfo info, SirenFieldAttribute attribute, uint index, ushort id)
{
ParentType = parentSirenClass;
Info = info;
Name = Info.Name;
Id = id;
Attribute = attribute;
Index = index;
FieldType = SirenPropertyFieldType.Struct;
Type = SirenMachine.GetType(info.PropertyType);
DataType = SirenMachine.GetTypeId(Type.Type);
if (Type.Type.IsGenericType)
{
if (Type.Name.StartsWith("List"))
{
FieldType = SirenPropertyFieldType.List;
var valueType = Type.Type.GetGenericArguments()[0];
ValueType = SirenMachine.GetType(valueType);
}
else if (Type.Name.StartsWith("Dictionary"))
{
FieldType = SirenPropertyFieldType.Dictionary;
var keyType = Type.Type.GetGenericArguments()[0];
var valueType = Type.Type.GetGenericArguments()[1];
KeyType = SirenMachine.GetType(keyType);
ValueType = SirenMachine.GetType(valueType);
}
else
{
throw new Exception("Invalid siren field");
}
DefaultValueString = String.Empty;
}
else
{
if (Type.Type.IsPrimitive || Type.Type == typeof(string) || Type.Type == typeof(byte[]))
{
if (Type.Type == typeof(string))
{
FieldType = SirenPropertyFieldType.String;
}
else if (Type.Type == typeof(byte[]))
{
FieldType = SirenPropertyFieldType.Blob;
}
else
{
FieldType = SirenPropertyFieldType.Value;
}
}
else
{
FieldType = SirenPropertyFieldType.Struct;
ValueType = SirenMachine.GetType(Type.Type);
}
DefaultValueString = String.Empty;
if (Type.Type.IsValueType)
{
if (Attribute.DefaultValue != null)
{
if (Type.Type.IsEnum)
{
DefaultValueString = String.Format("({0}){1}", Type.Name, Convert.ToUInt32(Attribute.DefaultValue));
}
else
{
DefaultValueString = Attribute.DefaultValue.ToString();
}
}
//else
//{
// if (Type.Type == typeof(bool))
// {
// DefaultValueString = "false";
// }
// else if (Type.Type == typeof(float))
// {
// DefaultValueString = "0.f";
// }
// else if (Type.Type == typeof(double))
// {
// DefaultValueString = "0.0";
// }
// else
// {
// if (Type.Type.IsEnum)
// {
// DefaultValueString = String.Format("({0})0", Type.Name);
// }
// else
// {
// DefaultValueString = "0";
// }
// }
//}
}
}
}
public SirenField(SirenCustomClass parentSirenClass, PropertyInfo info, SirenFieldAttribute attribute, uint index, ushort id)
{
ParentType = parentSirenClass;
Info = info;
Name = Info.Name;
Id = id;
Attribute = attribute;
Index = index;
FieldType = SirenPropertyFieldType.Struct;
Type = SirenMachine.GetType(info.PropertyType);
DataType = SirenMachine.GetTypeId(Type.Type);
if (Type.Type.IsGenericType)
{
if (Type.Name.StartsWith("List"))
{
FieldType = SirenPropertyFieldType.List;
var valueType = Type.Type.GetGenericArguments()[0];
ValueType = SirenMachine.GetType(valueType);
}
else if (Type.Name.StartsWith("Dictionary"))
{
FieldType = SirenPropertyFieldType.Dictionary;
var keyType = Type.Type.GetGenericArguments()[0];
var valueType = Type.Type.GetGenericArguments()[1];
KeyType = SirenMachine.GetType(keyType);
ValueType = SirenMachine.GetType(valueType);
}
else
{
throw new Exception("Invalid siren field");
}
DefaultValueString = String.Empty;
}
else
{
if (Type.Type.IsPrimitive || Type.Type == typeof(string) || Type.Type == typeof(byte[]))
{
if (Type.Type == typeof(string))
{
FieldType = SirenPropertyFieldType.String;
}
else if (Type.Type == typeof(byte[]))
{
FieldType = SirenPropertyFieldType.Blob;
}
else
{
FieldType = SirenPropertyFieldType.Value;
}
}
else
{
FieldType = SirenPropertyFieldType.Struct;
ValueType = SirenMachine.GetType(Type.Type);
}
DefaultValueString = String.Empty;
if (Type.Type.IsValueType)
{
if (Attribute.DefaultValue != null)
{
if (Type.Type.IsEnum)
{
DefaultValueString = String.Format("({0}){1}", Type.Name, Convert.ToUInt32(Attribute.DefaultValue));
}
else
{
DefaultValueString = Attribute.DefaultValue.ToString();
}
}
//else
//{
// if (Type.Type == typeof(bool))
// {
// DefaultValueString = "false";
// }
// else if (Type.Type == typeof(float))
// {
// DefaultValueString = "0.f";
// }
// else if (Type.Type == typeof(double))
// {
// DefaultValueString = "0.0";
// }
// else
// {
// if (Type.Type.IsEnum)
// {
// DefaultValueString = String.Format("({0})0", Type.Name);
// }
// else
// {
// DefaultValueString = "0";
// }
// }
//}
}
}
}
