private void _WriteGetMetadataTypeMethod(Type type)
{
_writer.WriteLine("[Export(ExportFlags.AutoCode)]");
if (_rootTypes.Contains(type))
{
_writer.WriteLine("public virtual ushort GetMetadataType ()");
using (CodeScope.CreateCSharpScope(_writer))
{
_writer.WriteLine("throw new NotImplementedException(\"This method should be override~\");");
}
}
else
{
var overrideText = _rootTypes.Contains(EditorMetaCommon.GetRootMetadata(type)) ? "override " : string.Empty;
_writer.WriteLine("public {0}ushort GetMetadataType ()", overrideText);
using (CodeScope.CreateCSharpScope(_writer))
{
//var typeName = EditorMetaCommon.GetMetaTypeName(type);
//_writer.WriteLine("return (ushort) MetadataType.{0};", typeName);
_writer.WriteLine("throw new NotImplementedException(\"This method should be override~\");");
}
}
}
private void _WriteSaveMethod(Type type, List <MemberBase> members)
{
if (_rootTypes.Contains(type))
{
_writer.WriteLine("[Export(ExportFlags.AutoCode)]");
_writer.WriteLine("public virtual void Save (IOctetsWriter writer)");
using (CodeScope.CreateCSharpScope(_writer))
{
_writer.WriteLine("throw new NotImplementedException(\"This method should be override~\");");
}
}
else
{
using (MacroScope.CreateEditorScope(_writer.BaseWriter))
{
_writer.WriteLine("[Export(ExportFlags.AutoCode)]");
var overrideText = _rootTypes.Contains(EditorMetaCommon.GetRootMetadata(type)) ? "override " : string.Empty;
_writer.WriteLine("public {0}void Save (IOctetsWriter writer)", overrideText);
using (CodeScope.Create(_writer, "{\n", "}\n"))
{
for (int index = 0; index < members.Count; ++index)
{
var member = members[index];
member.WriteSave(_writer);
}
}
}
}
}
private void _WriteOneClassOrStruct(Type type, ExportFlags flags)
{
var classOrStruct = type.IsClass ? "class" : "struct";
var sealedClass = type.IsClass && EditorMetaCommon.IsFinalType(type) ? "sealed " : string.Empty;
_writer.WriteLine("[Serializable]");
_writer.WriteLine("{0}partial {1} {2} : {3}", sealedClass, classOrStruct, type.Name, typeof(ILoadable).Name);
using (MacroScope.CreateEditorScope(_writer.BaseWriter))
{
_writer.WriteLine(", {0}", typeof(ISavable).Name);
}
using (CodeScope.CreateCSharpScope(_writer))
{
var nestedTypes = type.GetNestedTypes(BindingFlags.Instance | BindingFlags.Public);
_WriteNestedTypes(nestedTypes, flags);
var members = new List <MemberBase>();
_CollectSerializableMembers(type, members);
_WriteSaveMethod(type, members);
_WriteLoadMethod(type, members);
_WriteToStringMethod(type, members);
_WriteGetMetadataTypeMethod(type);
}
}
private void _WriteSaveMetadata(CodeWriter writer)
{
if (!EditorMetaCommon.IsFinalType(_type))
{
writer.WriteLine("var {0}Type = {0}.GetMetadataType();", _name);
writer.WriteLine("writer.Write({0}Type);", _name);
}
writer.WriteLine("{0}.Save(writer);", _name);
}
private void _InitRootTypes(MetaManager metaManager)
{
foreach (var type in metaManager.MetaTypes)
{
var rootType = EditorMetaCommon.GetRootMetadata(type.RawType);
if (type.RawType != rootType)
{
_rootTypes.Add(rootType);
}
}
}
private void _WriteLoadMetadata(CodeWriter writer)
{
if (EditorMetaCommon.IsFinalType(_type))
{
writer.WriteLine("{0} = new {1}();", _name, EditorMetaCommon.GetMetaTypeName(_type));
}
else
{
Console.Error.WriteLine("IMetadata must be assignableFrom from MetadataMemmbers!");
}
writer.WriteLine("{0}.Load(reader);", _name);
}
public override void WriteLoad(CodeWriter writer)
{
Type elementType = _type.GetGenericArguments() [0];
string elementTypeName = EditorMetaCommon.GetNestedClassName(elementType);
writer.WriteLine("int {0}Count = reader.ReadInt32();", _name);
writer.WriteLine("if (null == {0}) {{ {0} = new List<{1}>({0}Count); }} else {{ {0}.Clear(); }}", _name, elementTypeName);
writer.WriteLine("for (int index= 0; index < {0}Count; ++index)", _name);
using (CodeScope.CreateCSharpScope(writer))
{
writer.WriteLine("{0}.Add (default({1}));", _name, elementTypeName);
_WriteLoadType(writer, elementType, _name + "[index]");
}
}
private void _WriteEqualsToMethod(Type type, List <MemberBase> members)
{
_writer.WriteLine("[Export(ExportFlags.AutoCode)]");
if (_rootTypes.Contains(type))
{
_writer.WriteLine("public virtual bool EqualsTo (IMetadata other)");
using (CodeScope.CreateCSharpScope(_writer))
{
_writer.WriteLine("throw new NotImplementedException(\"This method should be override~\");");
}
}
else
{
var overrideText = _rootTypes.Contains(EditorMetaCommon.GetRootMetadata(type)) ? "override " : string.Empty;
_writer.WriteLine("public {0}bool EqualsTo (IMetadata other)", overrideText);
using (CodeScope.CreateCSharpScope(_writer))
{
var typeName = EditorMetaCommon.GetNestedClassName(type);
_writer.WriteLine("var that = ({0}) other;", typeName);
if (type.IsClass)
{
_writer.WriteLine("if (null == that)");
using (CodeScope.CreateCSharpScope(_writer))
{
_writer.WriteLine("return false;");
}
}
var memberCount = members.Count;
for (int index = 0; index < memberCount; ++index)
{
var member = members[index];
member.WriteNotEqualsReturn(_writer);
}
_writer.WriteLine("return true;");
}
}
}
public override void WriteLoad(CodeWriter writer)
{
string childtype = EditorMetaCommon.GetNestedClassName(_type.GetElementType()).Replace("+", ".");
string prefix = childtype;
string postfix = string.Empty;
int first = childtype.IndexOf("[", StringComparison.Ordinal);
if (first >= 0)
{
prefix = childtype.Substring(0, first);
postfix = childtype.Substring(first);
}
writer.WriteLine("{0} = new {1}[reader.ReadInt32()]{2};", _name, prefix, postfix);
writer.WriteLine("for (int i{1} = 0; i{1} < {0}.Length; i{1}++)", _name, writer.Indent);
using (CodeScope.CreateCSharpScope(writer))
{
_WriteLoadType(writer, _type.GetElementType(), _name + string.Format("[i{0}]", writer.Indent - 1));
}
}
private void _CollectSerializableMembers(Type type, List <MemberBase> members)
{
var flags = BindingFlags.Instance | BindingFlags.Public;
var idDecalringTemplate = 0;
foreach (var field in type.GetFields(flags))
{
if (!EditorMetaCommon.IsAutoCodeIgnore(field))
{
var member = MemberBase.Create(field.FieldType, field.Name);
if (field.DeclaringType == typeof(Template))
{
members.Insert(idDecalringTemplate++, member);
}
else
{
members.Add(member);
}
}
}
}
public static MemberBase Create(Type type, string name)
{
MemberBase member = null;
if (null != type)
{
if (type.IsPrimitive)
{
member = new PrimitiveMember();
}
else if (type == typeof(string))
{
member = new StringMember();
}
else if (type == typeof(Vector2))
{
member = new Vector2Member();
}
else if (type == typeof(Vector3))
{
member = new Vector3Member();
}
else if (type == typeof(Vector4))
{
member = new Vector4Member();
}
else if (type == typeof(Color))
{
member = new ColorMember();
}
else if (type.IsArray)
{
member = new ArrayMember();
}
else if (type.IsEnum)
{
member = new EnumMember();
}
else if (type.IsGenericType)
{
var genericTypeDefinition = type.GetGenericTypeDefinition();
if (typeof(List <>) == genericTypeDefinition)
{
member = new ListMember();
}
}
else if (EditorMetaCommon.IsMetadata(type))
{
member = new MetadataMember();
}
}
if (null != member)
{
member._type = type;
member._name = name;
}
else
{
var text = string.Format("Invalid type found: typeof({0}) = {1}", name, type);
Console.Error.WriteLine(text);
}
return(member);
}
public override void WriteLoad(CodeWriter writer)
{
writer.WriteLine("{0} = ({1}) reader.ReadUInt16();", _name, EditorMetaCommon.GetNestedClassName(_type));
}
