public override bool WriteBinary(BinaryWriter writer, GData data, GObject inObj)
{
// todo: check if template field name is defined in type config.
for (int i = 0; i < FieldCount; ++i)
{
GStructField field = GetField(i);
GData fieldData = data.GetFieldWithInheritance(field.Name);
if (fieldData != null)
{
fieldData.WriteBinary(writer, inObj);
}
else
{
// write default
GType fieldTp = GTypeManager.Instance.GetType(field.Type);
if (fieldTp != null)
{
fieldTp.WriteDefault(writer, field.Default);
}
else
{
GLog.LogError("Can't find type definition of " + field.Type + data.debugInfo);
}
}
}
return(true);
}
public virtual bool WriteJson(ref JsonData jsonData, GData data)
{
if (Name.Equals(GType.Bool))
{
jsonData = new JsonData(data.Bool);
}
else if (Name.Equals(GType.Byte))
{
jsonData = new JsonData(data.Byte);
}
else if (Name.Equals(GType.Short))
{
jsonData = new JsonData(data.Short);
}
else if (Name.Equals(GType.Int))
{
jsonData = new JsonData(data.Int);
}
else if (Name.Equals(GType.Float))
{
jsonData = new JsonData((double)data.Float);
}
else if (Name.Equals(GType.String))
{
jsonData = new JsonData(data.String);
}
else if (Name.Equals(GType.TID))
{
jsonData = new JsonData(data.TID);
}
return(true);
}
public GData Clone()
{
GData ret = new GData(mType);
ret.inst_bool = inst_bool;
ret.inst_byte = inst_byte;
ret.inst_short = inst_short;
ret.inst_int = inst_int;
ret.inst_float = inst_float;
if (inst_string != null)
{
ret.inst_string = string.Copy(inst_string);
}
if (inst_tid != null)
{
ret.inst_tid = string.Copy(inst_tid);
}
if (inst_enum != null)
{
ret.inst_enum = string.Copy(inst_enum);
}
if (inst_bitfield != null)
{
ret.inst_bitfield = string.Copy(inst_bitfield);
}
if (inst_array != null)
{
ret.inst_array = new List <GData>();
for (int i = 0; i < inst_array.Count; ++i)
{
ret.inst_array.Add(inst_array[i].Clone());
}
}
if (inst_object != null)
{
ret.inst_object = new Dictionary <string, GData>();
var e = inst_object.GetEnumerator();
while (e.MoveNext())
{
ret.inst_object.Add(e.Current.Key, e.Current.Value.Clone());
}
}
if (inst_map != null)
{
ret.inst_map = new List <MapKV>();
for (int i = 0; i < inst_map.Count; ++i)
{
ret.inst_map.Add(new MapKV()
{
key = inst_map[i].key.Clone(), val = inst_map[i].val.Clone()
});
}
}
return(ret);
}
public void InheriteParent(GData parent)
{
if (parent == null)
{
return;
}
if (this.mType.Equals(GType.Array))
{
GLog.Log("inherit array '{0}' {1}", this.fieldInfo.Name, debugInfo);
if (!this.isKVArray)
{
int count = parent.inst_array.Count;
for (int i = 0; i < count; ++i)
{
inst_array.Insert(i, parent.inst_array[i].Clone());
}
}
else
{
int count = parent.inst_array.Count;
for (int i = 0; i < count; ++i)
{
if (inst_array.Count <= i)
{
inst_array.Add(parent.inst_array[i].Clone());
}
else if (inst_array[i] == null)
{
inst_array[i] = parent.inst_array[i].Clone();
}
}
}
for (int i = 0; i < inst_array.Count; ++i)
{
if (inst_array[i] == null)
{
GLog.LogError("Array item can't be null. Index '{0}' of '{1}' {2}", i, this.fieldInfo.Name, debugInfo);
}
}
}
else if (mType.Equals(GType.Map))
{
GLog.Log("inherit map '{0}' {1}", this.fieldInfo.Name, debugInfo);
IList <MapKV> parentData = parent.inst_map;
for (int i = 0; i < parentData.Count; ++i)
{
if (GetMapItem(parentData[i].key) == null)
{
inst_map.Insert(0, new MapKV()
{
key = parentData[i].key.Clone(), val = parentData[i].val.Clone()
});
}
}
}
}
protected bool ReadData_Impl(GData data, JsonData jsonData, GStructField field)
{
data.Obj = new Dictionary <string, GData>();
if (!jsonData.IsObject)
{
GLog.LogError("JsonData of {0}({1}) is not a struct {2}", field.Name, this.Name, data.debugInfo);
return(false);
}
bool inheritParent = false;
string fieldName;
// check if field name is not defined.
foreach (var key in jsonData.Keys)
{
if (key.Equals("ID") ||
key.Equals("Type") ||
key.Equals("Parent") ||
key.Equals("Singleton") ||
key.Equals("RuntimeLink")
)
{
continue;
}
if (key[0] == '+')
{
GLog.Log("inheritParent " + key);
inheritParent = true;
fieldName = key.Substring(1, key.Length - 1);
}
else
{
fieldName = key;
}
GStructField desc = GetField(fieldName);
if (desc == null)
{
GLog.LogError("{0} is not a field of {1} {2}", fieldName, this.Name, data.debugInfo);
return(false);
}
GType tp = GTypeManager.Instance.GetType(desc.Type);
GData subData = tp.ReadData(jsonData[key], inheritParent, desc, data.debugInfo);
if (subData == null)
{
return(false);
}
data.Obj.Add(desc.Name, subData);
}
return(true);
}
public override bool WriteJson(ref JsonData jsonData, GData data)
{
jsonData = new JsonData();
jsonData.SetJsonType(JsonType.Array);
for (int iSub = 0; iSub < data.Count; ++iSub)
{
JsonData item = new JsonData();
data.Array[iSub].WriteJson(ref item);
jsonData.Add(item);
}
return(true);
}
public override GData ReadData(string strData, GStructField field, DataDebugInfo ownerDebugInfo)
{
GData data = new GData(Name);
data.debugInfo = ownerDebugInfo;
data.Enum = strData;
if (!this.Contains(data.Enum))
{
GLog.LogError(data.Enum + " is not in " + Name + data.debugInfo);
return(null);
}
return(data);
}
public override GData ReadData(JsonData jsonData, bool inherit, GStructField field, DataDebugInfo ownerDebugInfo)
{
GData data = new GData(Name);
data.inheritParent = inherit;
data.debugInfo = ownerDebugInfo;
data.fieldInfo = field;
if (!ReadData_Impl(data, jsonData, field))
{
return(null);
}
return(data);
}
public override bool WriteBinary(BinaryWriter writer, GData data, GObject inObj)
{
writer.Write(data.Count);
for (int iSub = 0; iSub < data.Count; ++iSub)
{
if (data.Array[iSub] == null)
{
GLog.LogError("Array item is null! in {1}:{0}", data.fieldInfo.Name, inObj.ID);
return(false);
}
data.Array[iSub].WriteBinary(writer, inObj);
}
return(true);
}
public override GData ReadData(JsonData jsonData, bool inherit, GStructField field, DataDebugInfo ownerDebugInfo)
{
GData data = new GData(Name);
data.inheritParent = inherit;
data.debugInfo = ownerDebugInfo;
data.Enum = (string)jsonData;
if (!this.Contains(data.Enum))
{
GLog.LogError(data.Enum + " is not in " + Name + data.debugInfo);
return(null);
}
return(data);
}
public override bool WriteBinary(BinaryWriter writer, GData data, GObject inObj)
{
writer.Write(data.Count);
for (int iSub = 0; iSub < data.Count; ++iSub)
{
if (data.Map[iSub] == null)
{
GLog.LogError("Map item is null!");
}
data.Map[iSub].key.WriteBinary(writer, inObj);
data.Map[iSub].val.WriteBinary(writer, inObj);
}
return(true);
}
public GData GetMapItem(GData key)
{
if (inst_map == null)
{
return(null);
}
for (int i = 0; i < inst_map.Count; ++i)
{
if (inst_map[i].key.Equals(key))
{
return(inst_map[i].val);
}
}
return(null);
}
public override GData ReadData(string strData, GStructField field, DataDebugInfo ownerDebugInfo)
{
GData data = new GData(Name);
data.debugInfo = ownerDebugInfo;
data.BitField = strData;
if (!string.IsNullOrEmpty(data.BitField))
{
if (GetVal(data.BitField, data.debugInfo) == 0)
{
return(null);
}
}
return(data);
}
public override GData GetFieldWithInheritance(string fieldName)
{
GData ret = this.GetField(fieldName);
if (ret == null && !string.IsNullOrEmpty(this.Parent))
{
GObject parent = GDataManager.Instance.GetObj(this.Parent);
// TODO: check errors
if (parent == null)
{
GLog.LogError("Can't find template definition: " + this.Parent + debugInfo);
return(null);
}
ret = parent.GetFieldWithInheritance(fieldName);
}
return(ret);
}
public override GData ReadData(JsonData jsonData, bool inherit, GStructField field, DataDebugInfo ownerDebugInfo)
{
GData data = new GData(Name);
data.inheritParent = inherit;
data.debugInfo = ownerDebugInfo;
data.BitField = (string)jsonData;
if (!string.IsNullOrEmpty(data.BitField))
{
if (GetVal(data.BitField, data.debugInfo) == 0)
{
return(null);
}
}
return(data);
}
public override GData ReadData(JsonData jsonData, bool inherit, GStructField field, DataDebugInfo ownerDebugInfo)
{
GData data = new GData(GType.Map);
data.inheritParent = inherit;
data.debugInfo = ownerDebugInfo;
data.fieldInfo = field;
data.Map = new List <MapKV>();
GType keyType = GTypeManager.Instance.GetType(field.SubTypes[0]);
GType valType = GTypeManager.Instance.GetType(field.SubTypes[1]);
if (jsonData.IsObject)
{
var keys = jsonData.Keys;
var e = keys.GetEnumerator();
while (e.MoveNext())
{
GData key = keyType.ReadData(e.Current, field, data.debugInfo);
if (key == null)
{
return(null);
}
GData val = valType.ReadData(jsonData[e.Current], false, field, data.debugInfo);
if (val == null)
{
return(null);
}
data.Map.Add(new MapKV()
{
key = key, val = val
});
}
return(data);
}
else
{
GLog.LogError("Field '{0}' expect array data.{1}", field.Name, data.debugInfo);
return(null);
}
}
public virtual bool WriteBinary(BinaryWriter writer, GData data, GObject inObj)
{
if (Name.Equals(GType.Bool))
{
writer.Write(data.Bool);
}
else if (Name.Equals(GType.Byte))
{
writer.Write(data.Byte);
}
else if (Name.Equals(GType.Short))
{
writer.Write(data.Short);
}
else if (Name.Equals(GType.Int))
{
writer.Write(data.Int);
}
else if (Name.Equals(GType.Float))
{
writer.Write(data.Float);
}
else if (Name.Equals(GType.String))
{
SerializeUtil.WriteString(writer, inObj.ReplaceMacro(data.String, data.debugInfo));
}
else if (Name.Equals(GType.TID))
{
string realTID = inObj.ReplaceMacro(data.TID, data.debugInfo);
//GObject obj = GDataManager.Instance.GetObj(realTID);
int id = GTIDGenerator.Instance.GetID(realTID);
if (id == 0)
{
GLog.LogError("Can't find the definition of '" + realTID + "'" + data.debugInfo);
writer.Write(0);
}
else
{
writer.Write(id);
}
}
return(true);
}
public override bool WriteBinary(BinaryWriter writer, GData data, GObject inObj)
{
switch (bitSize)
{
case 8:
writer.Write((sbyte)GetVal(data.Enum));
break;
case 16:
writer.Write((short)GetVal(data.Enum));
break;
case 32:
writer.Write((int)GetVal(data.Enum));
break;
case 64:
writer.Write((long)GetVal(data.Enum));
break;
}
return(true);
}
public override bool WriteJson(ref JsonData jsonData, GData data)
{
if (jsonData == null)
{
jsonData = new JsonData();
}
jsonData.SetJsonType(JsonType.Object);
for (int i = 0; i < this.FieldCount; ++i)
{
GStructField desc = this.GetField(i);
if (!data.Obj.Keys.Contains(desc.Name))
{
continue;
}
JsonData subJsonData = new JsonData();
data.GetField(desc.Name).WriteJson(ref subJsonData);
jsonData.Add(desc.Name, subJsonData);
}
return(true);
}
public bool PreBuild()
{
if (prebuilded)
{
return(true);
}
prebuilded = true;
if (!string.IsNullOrEmpty(Parent))
{
GLog.Log("Build: " + this.ID);
GObject parentObj = GDataManager.Instance.GetObj(Parent);
if (parentObj == null)
{
GLog.LogError("Parent '{0}' can't be found.{1}", Parent, debugInfo);
return(false);
}
// 0. parent prebuild
parentObj.PreBuild();
// 1. Inherite Array、Map ...
var e = inst_object.GetEnumerator();
while (e.MoveNext())
{
if (e.Current.Value.inheritParent)
{
GLog.Log("inheriteParent true");
GData parentData = parentObj.GetField(e.Current.Key);
e.Current.Value.InheriteParent(parentData);
}
}
}
return(true);
}
public bool Equals(GData b)
{
if (mType.Equals(GType.Bool))
{
return(inst_bool == b.inst_bool);
}
else if (mType.Equals(GType.Byte))
{
return(inst_byte == b.inst_byte);
}
else if (mType.Equals(GType.Short))
{
return(inst_short == b.inst_short);
}
else if (mType.Equals(GType.Int))
{
return(inst_int == b.inst_int);
}
else if (mType.Equals(GType.Float))
{
return(inst_float == b.inst_float);
}
else if (mType.Equals(GType.String))
{
return(inst_string.Equals(b.inst_string));
}
else if (mType.Equals(GType.TID))
{
return(inst_tid.Equals(b.inst_tid));
}
else
{
// todo: demonyang not implement
return(false);
}
}
public virtual GData ReadData(string strData, GStructField field, DataDebugInfo ownerDebugInfo)
{
GData data = new GData(Name);
data.debugInfo = ownerDebugInfo;
if (Name.Equals(GType.Bool))
{
bool ret;
if (bool.TryParse(strData, out ret))
{
data.Bool = bool.Parse(strData);
}
else
{
GLog.LogError("Parse Bool failed: {0}", strData);
return(null);
}
}
else if (Name.Equals(GType.Byte) ||
Name.Equals(GType.Short) ||
Name.Equals(GType.Int))
{
int intVal = 0;
int ret;
if (int.TryParse(strData, out ret))
{
intVal = ret;
}
else
{
string[] splits = strData.Split('.');
if (splits.Length >= 2)
{
GType tp = GTypeManager.Instance.GetType(splits[0]);
if (tp.IsEnum())
{
GTypeEnum enumTp = tp as GTypeEnum;
int val = (int)enumTp.GetVal(splits[1]);
if (val != -1)
{
intVal = val;
}
else
{
GLog.LogError("Can't parse {0} while assigning to int field {1}{2}", strData, field.Name, data.debugInfo);
}
}
else
{
GLog.LogError("Can't parse {0} while assigning to int field {1}{2}", strData, field.Name, data.debugInfo);
}
}
else
{
GLog.LogError("Can't parse {0} while assigning to int field {1}{2}", strData, field.Name, data.debugInfo);
}
}
if (Name.Equals(GType.Int))
{
data.Int = intVal;
}
else if (Name.Equals(GType.Short))
{
data.Short = (short)intVal;
if (data.Short != intVal)
{
GLog.LogError("{0} is cast to short {1}", intVal, data.Short);
}
}
else if (Name.Equals(GType.Byte))
{
data.Byte = (byte)intVal;
if (data.Byte != intVal)
{
GLog.LogError("{0} is cast to byte {1}", intVal, data.Byte);
}
}
}
else if (Name.Equals(GType.Float))
{
float ret;
if (float.TryParse(strData, out ret))
{
data.Float = ret;
}
else
{
GLog.LogError("(" + strData + ") is not a number" + data.debugInfo);
return(null);
}
}
else if (Name.Equals(GType.String))
{
data.String = strData;
}
else if (Name.Equals(GType.TID))
{
if (string.IsNullOrEmpty(field.Category))
{
data.TID = strData;
}
else
{
data.TID = field.Category + "." + strData;
}
}
return(data);
}
public virtual GData ReadData(JsonData jsonData, bool inherit, GStructField field, DataDebugInfo ownerDebugInfo)
{
GData data = new GData(Name);
data.inheritParent = inherit;
data.debugInfo = ownerDebugInfo;
if (Name.Equals(GType.Bool))
{
data.Bool = (bool)jsonData;
}
else if (Name.Equals(GType.Byte) ||
Name.Equals(GType.Short) ||
Name.Equals(GType.Int))
{
int intVal = 0;
if (jsonData.IsInt)
{
intVal = (int)jsonData;
}
else if (jsonData.IsDouble)
{
float tmp = (float)jsonData;
intVal = (int)tmp;
if (tmp > intVal)
{
GLog.LogError(jsonData + " is converted to int!" + data.debugInfo);
}
}
else if (jsonData.IsString)
{
string[] splits = ((string)jsonData).Split('.');
if (splits.Length >= 2)
{
GType tp = GTypeManager.Instance.GetType(splits[0]);
if (tp.IsEnum())
{
GTypeEnum enumTp = tp as GTypeEnum;
int val = (int)enumTp.GetVal(splits[1]);
if (val != -1)
{
intVal = val;
}
else
{
GLog.LogError("Can't parse {0} while assigning to int field {1}{2}", (string)jsonData, field.Name, data.debugInfo);
}
}
else
{
GLog.LogError("Can't parse {0} while assigning to int field {1}{2}", (string)jsonData, field.Name, data.debugInfo);
}
}
else
{
GLog.LogError("Can't parse string \"{0}\" to enum while assigning to int field {1}{2}", (string)jsonData, field.Name, data.debugInfo);
}
}
else
{
GLog.LogError("(" + jsonData.GetJsonType() + ") is not int" + data.debugInfo);
}
if (Name.Equals(GType.Int))
{
data.Int = intVal;
}
else if (Name.Equals(GType.Short))
{
data.Short = (short)intVal;
if (data.Short != intVal)
{
GLog.LogError("{0} is cast to short {1}", intVal, data.Short);
}
}
else if (Name.Equals(GType.Byte))
{
data.Byte = (byte)intVal;
if (data.Byte != intVal)
{
GLog.LogError("{0} is cast to byte {1}", intVal, data.Byte);
}
}
}
else if (Name.Equals(GType.Float))
{
if (jsonData.IsInt)
{
data.Float = (int)jsonData;
}
else if (jsonData.IsDouble)
{
data.Float = (float)jsonData;
}
else
{
GLog.LogError("(" + jsonData.GetJsonType() + ") is not a number" + data.debugInfo);
}
}
else if (Name.Equals(GType.String))
{
data.String = (string)jsonData;
}
else if (Name.Equals(GType.TID))
{
if (string.IsNullOrEmpty(field.Category))
{
data.TID = (string)jsonData;
}
else
{
// todo: ����Ƿ��Ѿ�����Ϊ Catagory.Name ��ʽ
data.TID = field.Category + "." + (string)jsonData;
}
}
return(data);
}
public override bool WriteJson(ref JsonData jsonData, GData data)
{
GLog.LogError("GTypeMap WriteJson is not implemented.");
return(false);
}
public override GData ReadData(JsonData jsonData, bool inherit, GStructField field, DataDebugInfo ownerDebugInfo)
{
GData data = new GData(GType.Array);
data.inheritParent = inherit;
data.debugInfo = ownerDebugInfo;
data.fieldInfo = field;
data.Array = new List <GData>();
GType itemType = GTypeManager.Instance.GetType(field.SubTypes[0]);
// 完整数组 //
if (jsonData.IsArray)
{
for (int iSub = 0; iSub < jsonData.Count; ++iSub)
{
GData arrayItem = itemType.ReadData(jsonData[iSub], false, field, data.debugInfo);
if (arrayItem == null)
{
return(null);
}
data.Array.Add(arrayItem);
}
return(data);
}
// 指定index的数组 //
else if (jsonData.IsObject)
{
data.isKVArray = true;
var keys = jsonData.Keys;
int lastIndex = -1;
var e = keys.GetEnumerator();
while (e.MoveNext())
{
int index = 0;
if (!int.TryParse(e.Current, out index))
{
GLog.LogError("Array index must be integer. '{0}' {1}", e.Current, data.debugInfo);
return(null);
}
if (index <= lastIndex)
{
GLog.LogError("Array index must be incremental. '{0}' {1}", e.Current, data.debugInfo);
return(null);
}
while (lastIndex++ < index - 1)
{
data.Array.Add(null);
}
GData arrayItem = itemType.ReadData(jsonData[e.Current], false, field, data.debugInfo);
if (arrayItem == null)
{
return(null);
}
data.Array.Add(arrayItem);
}
return(data);
}
else
{
GLog.LogError("Field '{0}' expect array data.{1}", field.Name, data.debugInfo);
return(null);
}
}
public override bool WriteJson(ref JsonData jsonData, GData data)
{
jsonData = new JsonData(data.BitField);
return(true);
}
public override bool WriteBinary(BinaryWriter writer, GData data, GObject inObj)
{
writer.Write(GetVal(data.BitField, data.debugInfo));
return(true);
}
