public void Serialize(BinaryWriter writer, CSWCSerizlizer serizlizer)
{
/// <summary>
/// 参数名
/// </summary>
//public string name;
writer.Write(name);
///// <summary>
///// 参数类型
///// </summary>
//public RunTimeDataType type;
writer.Write(type);
///// <summary>
///// 默认值
///// </summary>
//public RightValueBase defaultValue;
serizlizer.SerializeObject(writer, defaultValue);
///// <summary>
///// 是否是参数数组
///// </summary>
//public bool isPara;
writer.Write(isPara);
///// <summary>
///// 是否通过栈来传递
///// </summary>
//public bool isOnStack;
writer.Write(isOnStack);
//public LeftValueBase varorreg;
serizlizer.SerializeObject(writer, varorreg);
}
public static FunctionScope LoadFunctionScope(BinaryReader reader, CSWCSerizlizer serizlizer, IDictionary <int, object> serizlized, int key)
{
rtti.FunctionDefine function = serizlizer.DeserializeObject <rtti.FunctionDefine>(reader, rtti.FunctionDefine.LoadFunctionDefine);
FunctionScope scope = new FunctionScope(function); serizlized.Add(key, scope);
scope.LoadScopeBase(reader, serizlizer);
return(scope);
}
public override void Serialize(BinaryWriter writer, CSWCSerizlizer serizlizer)
{
writer.Write(RunTimeDataType.rt_string);
writer.Write((value == null));
if (value != null)
{
writer.Write(value);
}
}
//public void CopyFrom(rtArray right)
//{
// //_objid = right._objid;
// array = right.array;
// objHandle = right.objHandle;
//}
//public override int GetHashCode()
//{
// return array.GetHashCode() ^ objHandle.GetHashCode();
//}
//public override bool Equals(object obj)
//{
// rtArray right = obj as rtArray;
// if (right == null)
// {
// return false;
// }
// return array.Equals(right.array) && objHandle.Equals(right.objHandle);
//}
public override void Serialize(BinaryWriter writer, CSWCSerizlizer serizlizer)
{
writer.Write((int)rtType);
writer.Write(array.Count);
for (int i = 0; i < array.Count; i++)
{
array[i].Serialize(writer, serizlizer);
}
}
public static RightValue LoadRightValue(BinaryReader reader, CSWCSerizlizer serizlizer, IDictionary <int, object> serizlized, int key)
{
RunTimeDataType vtype = reader.ReadInt32();
RunTimeValueBase v = serizlizer.DeserializeObject <RunTimeValueBase>(reader, RunTimeValueBase.LoadRunTimeValueBase);
RightValue rv = new RightValue(v); serizlized.Add(key, rv);
rv.valueType = vtype;
return(rv);
}
public virtual void Serialize(BinaryWriter writer, CSWCSerizlizer serizlizer)
{
serizlizer.SerializeObject(writer, (ScopeBase)_parent);
writer.Write(memberlist.Count);
for (int i = 0; i < memberlist.Count; i++)
{
//((ISWCSerializable)memberlist[i]).Serialize(writer, serizlizer);
serizlizer.SerializeObject(writer, (ISWCSerializable)memberlist[i]);
}
}
protected void LoadScopeBase(BinaryReader reader, CSWCSerizlizer serizlizer)
{
_parent = serizlizer.DeserializeObject <ScopeBase>(reader, Deserialize);
int count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
memberlist.Add((IMember)serizlizer.DeserializeObject <ISWCSerializable>(reader, ISWCSerializableLoader.LoadIMember));
}
}
public void Serialize(BinaryWriter writer, CSWCSerizlizer serizlizer)
{
//public List<FunctionParameter> parameters;
writer.Write(parameters.Count);
for (int i = 0; i < parameters.Count; i++)
{
serizlizer.SerializeObject(writer, parameters[i]);
}
//public RunTimeDataType returnType;
writer.Write(returnType);
//public int onStackParameters;
writer.Write(onStackParameters);
}
public static FunctionSignature LoadSignature(BinaryReader reader, CSWCSerizlizer serizlizer, IDictionary<int, object> serizlized, int key)
{
FunctionSignature signature = new FunctionSignature();serizlized.Add(key, signature);
signature.parameters = new List<FunctionParameter>();
int count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
signature.parameters.Add(serizlizer.DeserializeObject<FunctionParameter>(reader, FunctionParameter.LoadFunctionParameter ));
}
signature.returnType = reader.ReadInt32();
signature.onStackParameters = reader.ReadInt32();
return signature;
}
public void Serialize(BinaryWriter writer, CSWCSerizlizer serizlizer)
{
//public readonly int functionid;
writer.Write(functionid);
// public bool IsAnonymous;
writer.Write(IsAnonymous);
//public string name;
writer.Write(name);
//public bool isMethod;
writer.Write(isMethod);
//public bool isStatic;
writer.Write(isStatic);
//public bool isConstructor;
writer.Write(isConstructor);
//public int blockid;
writer.Write(blockid);
///// <summary>
///// 是否本地函数
///// </summary>
//public bool isNative;
writer.Write(isNative);
//public string native_name;
if (native_name == null)
{
writer.Write(false);
}
else
{
writer.Write(true);
writer.Write(native_name);
}
//public int native_index;
writer.Write(native_index);
///// <summary>
///// 是否为yield返回
///// </summary>
//public bool isYield;
writer.Write(isYield);
//public FunctionSignature signature;
serizlizer.SerializeObject(writer, signature);
}
public static FunctionDefine LoadFunctionDefine(BinaryReader reader, CSWCSerizlizer serizlizer, IDictionary <int, object> serizlized, int key)
{
int functionid = reader.ReadInt32();
FunctionDefine functionDefine = new FunctionDefine(functionid); serizlized.Add(key, functionDefine);
// public bool IsAnonymous;
functionDefine.IsAnonymous = reader.ReadBoolean();
//public string name;
functionDefine.name = reader.ReadString();
//public bool isMethod;
functionDefine.isMethod = reader.ReadBoolean();
//public bool isStatic;
functionDefine.isStatic = reader.ReadBoolean();
//public bool isConstructor;
functionDefine.isConstructor = reader.ReadBoolean();
//public int blockid;
functionDefine.blockid = reader.ReadInt32();
///// <summary>
///// 是否本地函数
///// </summary>
//public bool isNative;
functionDefine.isNative = reader.ReadBoolean();
//public string native_name;
if (reader.ReadBoolean())
{
functionDefine.native_name = reader.ReadString();
}
//public int native_index;
functionDefine.native_index = reader.ReadInt32();
///// <summary>
///// 是否为yield返回
///// </summary>
//public bool isYield;
functionDefine.isYield = reader.ReadBoolean();
//public FunctionSignature signature;
functionDefine.signature = serizlizer.DeserializeObject <FunctionSignature>(reader, FunctionSignature.LoadSignature);
return(functionDefine);
}
public static ScopeBase Deserialize(BinaryReader reader, CSWCSerizlizer serizlizer, IDictionary <int, object> serizlized, int key)
{
string type = reader.ReadString();
if (type == "FunctionScope")
{
return(FunctionScope.LoadFunctionScope(reader, serizlizer, serizlized, key));
}
else if (type == "ObjectInstanceScope")
{
return(ObjectInstanceScope.LoadObjectInstanceScope(reader, serizlizer, serizlized, key));
}
else if (type == "OutPackageMemberScope")
{
return(OutPackageMemberScope.LoadOutPackageMemberScope(reader, serizlizer, serizlized, key));
}
else
{
throw new IOException("异常的Scope类型");
}
}
public static FunctionParameter LoadFunctionParameter(BinaryReader reader, CSWCSerizlizer serizlizer, IDictionary <int, object> serizlized, int key)
{
FunctionParameter parameter = new FunctionParameter(); serizlized.Add(key, parameter);
/// <summary>
/// 参数名
/// </summary>
//public string name;
parameter.name = reader.ReadString();
///// <summary>
///// 参数类型
///// </summary>
//public RunTimeDataType type;
parameter.type = reader.ReadInt32();
///// <summary>
///// 默认值
///// </summary>
//public RightValueBase defaultValue;
parameter.defaultValue = (RightValueBase)serizlizer.DeserializeObject <ISWCSerializable>(reader, ISWCSerializableLoader.LoadIMember);
///// <summary>
///// 是否是参数数组
///// </summary>
//public bool isPara;
parameter.isPara = reader.ReadBoolean();
///// <summary>
///// 是否通过栈来传递
///// </summary>
//public bool isOnStack;
parameter.isOnStack = reader.ReadBoolean();
//public LeftValueBase varorreg;
parameter.varorreg = (LeftValueBase)serizlizer.DeserializeObject <ISWCSerializable>(reader, ISWCSerializableLoader.LoadIMember);
return(parameter);
}
public void Serialize(BinaryWriter writer, CSWCSerizlizer serizlizer)
{
///// <summary>
///// 成员名
///// </summary>
//public string name;
writer.Write(name);
serizlizer.SerializeObject(writer, refClass);
//public readonly IMember bindField;
serizlizer.SerializeObject(writer, bindField);
//public bool isPublic;
writer.Write(isPublic);
//public bool isInternal;
writer.Write(isInternal);
//public bool isPrivate;
writer.Write(isPrivate);
//public bool isProtectd;
writer.Write(isProtectd);
///// <summary>
///// 是否属性读取器
///// </summary>
//public bool isGetter;
writer.Write(isGetter);
///// <summary>
///// 是否属性设置器
///// </summary>
//public bool isSetter;
writer.Write(isSetter);
///// <summary>
///// 是否覆盖基类方法
///// </summary>
//public bool isOverride;
writer.Write(isOverride);
//public bool isFinal;
writer.Write(isFinal);
///// <summary>
///// 是否是静态成员
///// </summary>
//public bool isStatic;
writer.Write(isStatic);
///// <summary>
///// 是否是常量
///// </summary>
//public bool isConst;
writer.Write(isConst);
///// <summary>
///// 是否是构造函数
///// </summary>
//public bool isConstructor;
writer.Write(isConstructor);
///// <summary>
///// 成员字面值,比如1000,"aabc"等确定的字面值
///// </summary>
//public RunTimeValueBase defaultValue;
serizlizer.SerializeObject(writer, defaultValue);
///// <summary>
///// 从哪个类继承而来
///// </summary>
//public Class inheritFrom;
serizlizer.SerializeObject(writer, inheritFrom);
///// <summary>
///// 继承源
///// </summary>
//public ClassMember inheritSrcMember;
serizlizer.SerializeObject(writer, inheritSrcMember);
//public ClassMember virtualLink;
serizlizer.SerializeObject(writer, virtualLink);
//public Class virtualLinkFromClass;
//serizlizer.SerializeObject(writer, virtualLinkFromClass);
//serizlizer.SerializeObject(writer, overridedMember);
//private RunTimeDataType _type;
writer.Write((int)_type);
}
public static ClassMember LoadClassMember(BinaryReader reader, CSWCSerizlizer serizlizer, IDictionary <int, object> serizlized, int key)
{
///// <summary>
///// 成员名
///// </summary>
//public string name;
string name = reader.ReadString();
ClassMember classMember = new ClassMember(); serizlized.Add(key, classMember);
classMember.name = name;
Class refClass = serizlizer.DeserializeObject <Class>(reader, Class.LoadClass
);
//public readonly IMember bindField;
IMember bindField = (IMember)serizlizer.DeserializeObject <ISWCSerializable>(reader, ISWCSerializableLoader.LoadIMember
);
classMember.refClass = refClass;
classMember.bindField = bindField;
//public bool isPublic;
classMember.isPublic = reader.ReadBoolean();
//public bool isInternal;
classMember.isInternal = reader.ReadBoolean();
//public bool isPrivate;
classMember.isPrivate = reader.ReadBoolean();
//public bool isProtectd;
classMember.isProtectd = reader.ReadBoolean();
///// <summary>
///// 是否属性读取器
///// </summary>
//public bool isGetter;
classMember.isGetter = reader.ReadBoolean();
///// <summary>
///// 是否属性设置器
///// </summary>
//public bool isSetter;
classMember.isSetter = reader.ReadBoolean();
///// <summary>
///// 是否覆盖基类方法
///// </summary>
//public bool isOverride;
classMember.isOverride = reader.ReadBoolean();
//public bool isFinal;
classMember.isFinal = reader.ReadBoolean();
///// <summary>
///// 是否是静态成员
///// </summary>
//public bool isStatic;
classMember.isStatic = reader.ReadBoolean();
///// <summary>
///// 是否是常量
///// </summary>
//public bool isConst;
classMember.isConst = reader.ReadBoolean();
///// <summary>
///// 是否是构造函数
///// </summary>
//public bool isConstructor;
classMember.isConstructor = reader.ReadBoolean();
///// <summary>
///// 成员字面值,比如1000,"aabc"等确定的字面值
///// </summary>
//public RunTimeValueBase defaultValue;
classMember.defaultValue = serizlizer.DeserializeObject <RunTimeValueBase>(reader, RunTimeValueBase.LoadRunTimeValueBase);
///// <summary>
///// 从哪个类继承而来
///// </summary>
//public Class inheritFrom;
classMember.inheritFrom = serizlizer.DeserializeObject <Class>(reader, Class.LoadClass);
///// <summary>
///// 继承源
///// </summary>
//public ClassMember inheritSrcMember;
classMember.inheritSrcMember = serizlizer.DeserializeObject <ClassMember>(reader, ClassMember.LoadClassMember);
//public ClassMember virtualLink;
classMember.virtualLink = serizlizer.DeserializeObject <ClassMember>(reader, ClassMember.LoadClassMember);
//public Class virtualLinkFromClass;
//classMember.virtualLinkFromClass = serizlizer.DeserializeObject<Class>(reader, Class.LoadClass);
//classMember.overridedMember = serizlizer.DeserializeObject<ClassMember>(reader, ClassMember.LoadClassMember);
//private RunTimeDataType _type;
classMember._type = reader.ReadInt32();
return(classMember);
}
public void Serialize(BinaryWriter writer, CSWCSerizlizer serizlizer)
{
// /// <summary>
// /// 指明这是否是一个接口定义
// /// </summary>
//public bool isInterface;
writer.Write(isInterface);
///// <summary>
///// 指明这是否是一个包级函数
///// </summary>
//public bool isPackageFunction;
writer.Write(isPackageFunction);
///// <summary>
///// 是否文档类
///// </summary>
//public bool isdocumentclass;
writer.Write(isdocumentclass);
///// <summary>
///// 是否是需要非托管类
///// </summary>
//public bool isUnmanaged;
writer.Write(isUnmanaged);
///// <summary>
///// 链接到的系统对象是否是一个结构体
///// </summary>
//public bool isStruct;
writer.Write(isStruct);
///// <summary>
///// 结构体排序序号(从1开始排起)
///// </summary>
//public int structIndex;
writer.Write(structIndex);
///// <summary>
///// 是否链接到系统对象
///// </summary>
//public bool isLink_System;
writer.Write(isLink_System);
writer.Write(isCrossExtend);
//public readonly string md5key;
writer.Write(md5key);
//public readonly int classid;
writer.Write(classid);
// /// <summary>
// /// 类定义代码所在blockid
// /// </summary>
//public readonly int blockid;
writer.Write(blockid);
///// <summary>
///// 系统对象创建器
///// </summary>
//public ClassMember linkObjCreator;
serizlizer.SerializeObject <ClassMember>(writer, linkObjCreator);
serizlizer.SerializeObject <ClassMember>(writer, crossExtendAdapterCreator);
///// <summary>
///// 是否已编译成功
///// </summary>
//public bool isbuildSuccess;
writer.Write(isbuildSuccess);
///// <summary>
///// 是否不可实例化
///// </summary>
//public bool no_constructor;
writer.Write(no_constructor);
///// <summary>
///// 包外代码所在blockid;
///// </summary>
//public int outscopeblockid;
writer.Write(outscopeblockid);
///// <summary>
///// 类名
///// </summary>
//public string name;
writer.Write(name);
//public string package;
writer.Write(package);
//public bool dynamic;
writer.Write(dynamic);
//public bool final;
writer.Write(final);
///// <summary>
///// 是否公开。如果不是，则只能在相同包内访问
///// </summary>
//public bool isPublic;
writer.Write(isPublic);
///// <summary>
///// 包含此类的静态成员。
///// </summary>
//public Class staticClass;
serizlizer.SerializeObject(writer, staticClass);
///// <summary>
///// 如果是静态成员类，则指向类的定义
///// </summary>
//public Class instanceClass;
serizlizer.SerializeObject(writer, instanceClass);
///// <summary>
///// 是否包外类
///// </summary>
//public bool ispackageout;
writer.Write(ispackageout);
///// <summary>
///// 如果是包外类，则显示所从属的主类
///// </summary>
//public Class mainClass;
serizlizer.SerializeObject(writer, mainClass);
///// <summary>
///// 构造函数
///// </summary>
//public ClassMember constructor;
serizlizer.SerializeObject(writer, constructor);
///// <summary>
///// 构造函数id
///// </summary>
//public int constructor_functionid;
writer.Write(constructor_functionid);
///// <summary>
///// 隐式类型转换到原始类型函数
///// </summary>
//public ClassMember implicit_to;
serizlizer.SerializeObject(writer, implicit_to);
//public RunTimeDataType implicit_to_type;
writer.Write((int)implicit_to_type);
//public int implicit_to_functionid;
writer.Write((int)implicit_to_functionid);
///// <summary>
///// 隐式从原始类型转换过来
///// </summary>
//public ClassMember implicit_from;
serizlizer.SerializeObject(writer, implicit_from);
//public int implicit_from_functionid;
writer.Write(implicit_from_functionid);
//public RunTimeDataType implicit_from_type;
writer.Write((int)implicit_from_type);
///// <summary>
///// 显式类型转换
///// </summary>
//public ClassMember explicit_from;
serizlizer.SerializeObject(writer, explicit_from);
//public int explicit_from_functionid;
writer.Write(explicit_from_functionid);
//public RunTimeDataType explicit_from_type;
writer.Write((int)explicit_from_type);
///// <summary>
///// 索引器 取值
///// </summary>
//public ClassMember get_this_item;
serizlizer.SerializeObject(writer, get_this_item);
///// <summary>
///// 索引器 赋值
///// </summary>
//public ClassMember set_this_item;
serizlizer.SerializeObject(writer, set_this_item);
///// <summary>
///// 类成员定义
///// </summary>
//public ClassMemberList classMembers;
writer.Write(classMembers.Count);
for (int i = 0; i < classMembers.Count; i++)
{
serizlizer.SerializeObject(writer, classMembers[i]);
}
///// <summary>
///// 数据字段表
///// </summary>
//public List<ClassMember> fields;
writer.Write(fields.Count);
for (int i = 0; i < fields.Count; i++)
{
serizlizer.SerializeObject(writer, fields[i]);
}
///// <summary>
///// 父类的定义（如果有）
///// </summary>
//public Class super;
serizlizer.SerializeObject(writer, super);
///// <summary>
///// 实现的各种接口
///// 记录了接口的一个方法对应类的哪个成员实现
///// </summary>
//public Dictionary<Class, int[]> implements;
if (!isInterface)
{
writer.Write(implements.Count);
foreach (var item in implements)
{
serizlizer.SerializeObject(writer, item.Key);
writer.Write(item.Value.Length);
for (int i = 0; i < item.Value.Length; i++)
{
writer.Write(item.Value[i]);
}
}
}
else
{
writer.Write(0);
}
}
public override void Serialize(BinaryWriter writer, CSWCSerizlizer serizlizer)
{
writer.Write("FunctionScope");
serizlizer.SerializeObject(writer, function);
base.Serialize(writer, serizlizer);
}
public static ObjectInstanceScope LoadObjectInstanceScope(BinaryReader reader, CSWCSerizlizer serizlizer, IDictionary <int, object> serizlized, int key)
{
ObjectInstanceScope scope = new ObjectInstanceScope(null); serizlized.Add(key, scope);
rtti.Class _class = serizlizer.DeserializeObject <rtti.Class>(reader, rtti.Class.LoadClass);
scope._class = _class;
scope.LoadScopeBase(reader, serizlizer);
return(scope);
}
public override void Serialize(BinaryWriter writer, CSWCSerizlizer serizlizer)
{
writer.Write(6);
base.Serialize(writer, serizlizer);
serizlizer.SerializeObject(writer, value);
}
public void Serialize(BinaryWriter writer, CSWCSerizlizer serizlizer)
{
throw new NotImplementedException();
}
public override void Serialize(BinaryWriter writer, CSWCSerizlizer serizlizer)
{
writer.Write("OutPackageMemberScope");
serizlizer.SerializeObject(writer, mainclass);
base.Serialize(writer, serizlizer);
}
public override void Serialize(BinaryWriter writer, CSWCSerizlizer serizlizer)
{
writer.Write(rtType);
writer.Write(value);
}
public override void Serialize(BinaryWriter writer, CSWCSerizlizer serizlizer)
{
writer.Write("ObjectInstanceScope");
serizlizer.SerializeObject(writer, _class);
base.Serialize(writer, serizlizer);
}
public static rtti.Class LoadClass(BinaryReader reader, CSWCSerizlizer serizlizer, IDictionary <int, object> serizlized, int key)
{
// /// <summary>
// /// 指明这是否是一个接口定义
// /// </summary>
//public bool isInterface;
bool isInterface = reader.ReadBoolean();
///// <summary>
///// 指明这是否是一个包级函数
///// </summary>
//public bool isPackageFunction;
bool isPackageFunction = reader.ReadBoolean();
///// <summary>
///// 是否文档类
///// </summary>
//public bool isdocumentclass;
bool isdocumentclass = reader.ReadBoolean();
///// <summary>
///// 是否是需要非托管类
///// </summary>
//public bool isUnmanaged;
bool isUnmanaged = reader.ReadBoolean();
///// <summary>
///// 链接到的系统对象是否是一个结构体
///// </summary>
//public bool isStruct;
bool isStruct = reader.ReadBoolean();
///// <summary>
///// 结构体排序序号(从1开始排起)
///// </summary>
//public int structIndex;
int structIndex = reader.ReadInt32();
///// <summary>
///// 是否链接到系统对象
///// </summary>
//public bool isLink_System;
bool isLink_System = reader.ReadBoolean();
bool isCrossExtend = reader.ReadBoolean();
//public readonly string md5key;
string md5key = reader.ReadString();
//public readonly int classid;
int classid = reader.ReadInt32();
// /// <summary>
// /// 类定义代码所在blockid
// /// </summary>
//public readonly int blockid;
int blockid = reader.ReadInt32();
rtti.Class _class = new Class(classid, blockid, serizlizer.loadingSwc, md5key); serizlized.Add(key, _class);
_class.isInterface = isInterface;
_class.isPackageFunction = isPackageFunction;
_class.isdocumentclass = isdocumentclass;
_class.isUnmanaged = isUnmanaged;
_class.isStruct = isStruct;
_class.structIndex = structIndex;
_class.isLink_System = isLink_System;
_class.isCrossExtend = isCrossExtend;
///// <summary>
///// 系统对象创建器
///// </summary>
//public ClassMember linkObjCreator;
_class.linkObjCreator = serizlizer.DeserializeObject <ClassMember>(reader, ClassMember.LoadClassMember);
_class.crossExtendAdapterCreator = serizlizer.DeserializeObject <ClassMember>(reader, ClassMember.LoadClassMember);
///// <summary>
///// 是否已编译成功
///// </summary>
//public bool isbuildSuccess;
_class.isbuildSuccess = reader.ReadBoolean();
///// <summary>
///// 是否不可实例化
///// </summary>
//public bool no_constructor;
_class.no_constructor = reader.ReadBoolean();
///// <summary>
///// 包外代码所在blockid;
///// </summary>
//public int outscopeblockid;
_class.outscopeblockid = reader.ReadInt32();
///// <summary>
///// 类名
///// </summary>
//public string name;
_class.name = reader.ReadString();
//public string package;
_class.package = reader.ReadString();
//public bool dynamic;
_class.dynamic = reader.ReadBoolean();
//public bool final;
_class.final = reader.ReadBoolean();
///// <summary>
///// 是否公开。如果不是，则只能在相同包内访问
///// </summary>
//public bool isPublic;
_class.isPublic = reader.ReadBoolean();
///// <summary>
///// 包含此类的静态成员。
///// </summary>
//public Class staticClass;
_class.staticClass = serizlizer.DeserializeObject <Class>(reader, Class.LoadClass);
///// <summary>
///// 如果是静态成员类，则指向类的定义
///// </summary>
//public Class instanceClass;
_class.instanceClass = serizlizer.DeserializeObject <Class>(reader, Class.LoadClass);
///// <summary>
///// 是否包外类
///// </summary>
//public bool ispackageout;
_class.ispackageout = reader.ReadBoolean();
///// <summary>
///// 如果是包外类，则显示所从属的主类
///// </summary>
//public Class mainClass;
_class.mainClass = serizlizer.DeserializeObject <Class>(reader, Class.LoadClass);
///// <summary>
///// 构造函数
///// </summary>
//public ClassMember constructor;
_class.constructor = serizlizer.DeserializeObject <ClassMember>(reader, ClassMember.LoadClassMember);
///// <summary>
///// 构造函数id
///// </summary>
//public int constructor_functionid;
_class.constructor_functionid = reader.ReadInt32();
///// <summary>
///// 隐式类型转换到原始类型函数
///// </summary>
//public ClassMember implicit_to;
_class.implicit_to = serizlizer.DeserializeObject <ClassMember>(reader, ClassMember.LoadClassMember);
//public RunTimeDataType implicit_to_type;
_class.implicit_to_type = reader.ReadInt32();
//public int implicit_to_functionid;
_class.implicit_to_functionid = reader.ReadInt32();
///// <summary>
///// 隐式从原始类型转换过来
///// </summary>
//public ClassMember implicit_from;
_class.implicit_from = serizlizer.DeserializeObject <ClassMember>(reader, ClassMember.LoadClassMember);
//public int implicit_from_functionid;
_class.implicit_from_functionid = reader.ReadInt32();
//public RunTimeDataType implicit_from_type;
_class.implicit_from_type = reader.ReadInt32();
///// <summary>
///// 显式类型转换
///// </summary>
//public ClassMember explicit_from;
_class.explicit_from = serizlizer.DeserializeObject <ClassMember>(reader, ClassMember.LoadClassMember);
//public int explicit_from_functionid;
_class.explicit_from_functionid = reader.ReadInt32();
//public RunTimeDataType explicit_from_type;
_class.explicit_from_type = reader.ReadInt32();
///// <summary>
///// 索引器 取值
///// </summary>
//public ClassMember get_this_item;
_class.get_this_item = serizlizer.DeserializeObject <ClassMember>(reader, ClassMember.LoadClassMember);
///// <summary>
///// 索引器 赋值
///// </summary>
//public ClassMember set_this_item;
_class.set_this_item = serizlizer.DeserializeObject <ClassMember>(reader, ClassMember.LoadClassMember);
///// <summary>
///// 类成员定义
///// </summary>
//public ClassMemberList classMembers;
int membercount = reader.ReadInt32();
for (int i = 0; i < membercount; i++)
{
_class.classMembers.Add(serizlizer.DeserializeObject <ClassMember>(reader, ClassMember.LoadClassMember));
}
///// <summary>
///// 数据字段表
///// </summary>
//public List<ClassMember> fields;
int fieldscount = reader.ReadInt32();
for (int i = 0; i < fieldscount; i++)
{
_class.fields.Add(serizlizer.DeserializeObject <ClassMember>(reader, ClassMember.LoadClassMember));
}
///// <summary>
///// 父类的定义（如果有）
///// </summary>
//public Class super;
_class.super = serizlizer.DeserializeObject <Class>(reader, Class.LoadClass);
///// <summary>
///// 实现的各种接口
///// 记录了接口的一个方法对应类的哪个成员实现
///// </summary>
//public Dictionary<Class, int[]> implements;
int implementscount = reader.ReadInt32();
for (int i = 0; i < implementscount; i++)
{
Class keyclass = serizlizer.DeserializeObject <Class>(reader, Class.LoadClass);
int count = reader.ReadInt32();
int[] impls = new int[count];
for (int j = 0; j < count; j++)
{
impls[j] = reader.ReadInt32();
}
_class.implements.Add(keyclass, impls);
}
return(_class);
}
public override void Serialize(BinaryWriter writer, CSWCSerizlizer serizlizer)
{
writer.Write(rtType);
writer.Write(_functionid);
writer.Write(_ismethod);
}
public static OutPackageMemberScope LoadOutPackageMemberScope(BinaryReader reader, CSWCSerizlizer serizlizer, IDictionary <int, object> serizlized, int key)
{
OutPackageMemberScope scope = new OutPackageMemberScope(null); serizlized.Add(key, scope);
rtti.Class mainclass = serizlizer.DeserializeObject <rtti.Class>(reader, rtti.Class.LoadClass);
scope.mainclass = mainclass;
scope.LoadScopeBase(reader, serizlizer);
return(scope);
}
