// 把值写入到ab当中
public void WriteTo(object value, Nested.AnyBase ab)
{
if (value == null)
{
ab.valueType = 0;
return;
}
var cnt = fieldInfos.Count;
ab.valueType = cnt == 0 ? (byte)2 : (byte)1;
if (cnt == 0)
{
return;
}
ITypeSerialize its;
for (int i = 0; i < cnt; ++i)
{
var field = fieldInfos[i];
object cv = field.GetValue(value);
its = BinarySerializable.GetByFieldInfo(field);
its.WriteTo(cv, ab.Create(field.Name, its.typeFlag));
}
}
void ITypeSerialize.MergeFrom(ref object value, Nested.AnyBase ab)
{
string fullName = ab.typeName;
if (string.IsNullOrEmpty(fullName))
{
value = null;
return;
}
RefType refType = (RefType)value;
if (refType == null || refType.Instance == null)
{
refType = new RefType(fullName);
value = refType;
}
else
{
var type = IL.Help.GetInstanceType(refType.Instance);
if (type.FullName != fullName)
{
refType.SetInstance(IL.Help.CreateInstaince(type, null));
}
}
var instance = refType.Instance;
BinarySerializable.GetByInstance(instance).MergeFrom(ref instance, ab);
refType.SetInstance(instance);
}
// value = this
public void CopyTo(AnyBase value)
{
value.dataKey = dataKey;
value.typeName = typeName;
value.valueType = valueType;
value.typeFlags = typeFlags;
value.baseValue = baseValue;
value.unityObj = unityObj;
value.listCount = listCount;
value.elementTypeFlags = elementTypeFlags;
}
// 把值写入到ab当中
void ITypeSerialize.WriteTo(object value, Nested.AnyBase ab)
{
RefType refType = (RefType)value;
if (refType == null || refType.Instance == null)
{
return;
}
typeSerialize.WriteTo(refType.Instance, ab);
}
// 把值写入到ab当中
public void WriteTo(object value, Nested.AnyBase ab)
{
RefType refType = (RefType)value;
if (refType == null || refType.Instance == null)
{
ab.typeName = string.Empty;
return;
}
var type = IL.Help.GetInstanceType(value);
ab.typeName = type.FullName;
BinarySerializable.GetByType(type).WriteTo(value, ab);
}
// 通过ab来设置值
void ITypeSerialize.MergeFrom(ref object value, Nested.AnyBase ab)
{
RefType refType = (RefType)value;
if (refType == null)
{
refType = new RefType(type);
value = refType;
}
var instance = refType.Instance;
typeSerialize.MergeFrom(ref instance, ab);
refType.SetInstance(instance);
}
public override bool Get(string key, out AnyBase ab)
{
int cnt = fields.Count;
for (int i = 0; i < cnt; ++i)
{
if (fields[i].dataKey == key)
{
ab = fields[i];
return(true);
}
}
ab = null;
return(false);
}
void ITypeSerialize.MergeFrom(ref object value, Nested.AnyBase ab)
{
byte flag = ab.valueType;
if (flag == 0)
{
value = null;
return;
}
if (value == null)
{
value = IL.Help.Create(type);
}
if (flag == 2)
{
return;
}
int cnt = fieldInfos.Count;
FieldInfo field;
ITypeSerialize its;
for (int i = 0; i < cnt; ++i)
{
field = fieldInfos[i];
if (ab.Get(field.Name, out var fieldValue))
{
object cv = field.GetValue(value);
{
its = BinarySerializable.GetByFieldInfo(field);
if (fieldValue.typeFlags == its.typeFlag)
{
its.MergeFrom(ref cv, fieldValue);
if (its.typeFlag == TypeFlags.unityObjectType)
{
cv = UnityObjectSerialize.To((UnityEngine.Object)cv, field.FieldType);
}
field.SetValue(value, cv);
}
}
}
}
}
protected static void Blend(AnyBase now, AnyBase old)
{
if (old == null)
{
return;
}
var newFields = now.items;
var oldFields = old.items;
int nowCnt = newFields.Count;
int oldCnt = oldFields.Count;
Dictionary <string, AnyBase> keyToIndexs = new Dictionary <string, AnyBase>();
for (int i = 0; i < nowCnt; ++i)
{
keyToIndexs.Add(newFields[i].dataKey, newFields[i]);
}
List <AnyBase> news = new List <AnyBase>();
for (int i = 0; i < oldCnt; ++i)
{
var od = oldFields[i];
if (keyToIndexs.TryGetValue(od.dataKey, out var v))
{
// 新值与老值，都有值
news.Add(v);
Blend(v, od);
keyToIndexs.Remove(od.dataKey);
}
else
{
// 新的没有值，旧的有值，保留旧的
news.Add(od);
}
}
foreach (var ator in keyToIndexs)
{
news.Add(ator.Value);
}
now.items = news;
}
public static void MergeFrom(object obj, Nested.AnyBase ab)
{
var its = GetByInstance(obj);
if (its == null)
{
return;
}
try
{
its.MergeFrom(ref obj, ab);
}
catch (System.Exception ex)
{
UnityEngine.Debug.LogException(ex);
}
}
// 通过ab来设置值
public void MergeFrom(ref object value, Nested.AnyBase ab)
{
if (ab.valueType == 0)
{
value = null;
return;
}
var dic = (IDictionary)value;
if (value == null)
{
value = System.Activator.CreateInstance(type);
dic = (IDictionary)value;
}
int cnt = ab.listCount;
for (int i = 0; i < cnt; ++i)
{
if (ab.Get($"key:{i}", out var keyValue))
{
object key = IL.Help.Create(keyType);
keyTypeSerialize.MergeFrom(ref key, keyValue);
if (ab.Get($"value:{i}", out var valueValue))
{
object kv = IL.Help.Create(valueType);
valueTypeSerialize.MergeFrom(ref kv, valueValue);
dic[key] = kv;
}
else
{
Debug.LogError($"dic {ab.dataKey} {i} value not find value!");
}
}
else
{
Debug.LogError($"dic {ab.dataKey} {i} not find value!");
}
}
}
// 把值写入到ab当中
public void WriteTo(object value, Nested.AnyBase ab)
{
if (value == null)
{
ab.valueType = 0;
return;
}
ab.valueType = 1;
var dic = (IDictionary)value;
int cnt = 0;
ab.listCount = dic.Count;
foreach (DictionaryEntry ator in dic)
{
string key = cnt.ToString();
keyTypeSerialize.WriteTo(ator.Key, ab.Create($"key:{key}", keyTypeSerialize.typeFlag));
valueTypeSerialize.WriteTo(ator.Value, ab.Create($"value:{key}", valueTypeSerialize.typeFlag));
++cnt;
}
}
// 通过ab来设置值
void ITypeSerialize.MergeFrom(ref object value, Nested.AnyBase ab)
{
byte flag = ab.valueType;
if (flag == 0)
{
value = null;
return;
}
bool isTypeTrue = ab.elementTypeFlags == elementTypeSerialize.typeFlag; // 类型是否一致
var array = value as IList;
int length = ab.listCount;
if (isTypeTrue && (array == null || array.Count != length))
{
array = Create(length);
value = array;
}
if (isTypeTrue)
{
for (int i = 0; i < length; ++i)
{
object v = array[i];
ab.Get($"[{i}]", out var vv);
elementTypeSerialize.MergeFrom(ref v, vv);
try
{
array[i] = v;
}
catch (System.Exception /*ex*/)
{
}
}
}
}
// 把值写入到ab当中
void ITypeSerialize.WriteTo(object value, Nested.AnyBase ab)
{
IList array = (IList)value;
if (array == null)
{
ab.valueType = 0;
return;
}
ab.valueType = 1;
ab.elementTypeFlags = elementTypeSerialize.typeFlag;
object elementObj;
int cnt = array.Count;
ab.listCount = cnt;
for (int i = 0; i < cnt; ++i)
{
elementObj = array[i];
var cts = ab.Create($"[{i}]", elementTypeSerialize.typeFlag);
elementTypeSerialize.WriteTo(elementObj, cts);
}
}
void ITypeSerialize.WriteTo(object value, Nested.AnyBase ab)
{
ab.baseValue = writeToS((T)value);
}
public static void Blend(Any0 now, Any0 old)
{
AnyBase.Blend(now, old);
}
// 通过ab来设置值
void ITypeSerialize.MergeFrom(ref object value, Nested.AnyBase ab)
{
SetObject(ref value, ab.unityObj);
}
// 把值写入到ab当中
void ITypeSerialize.WriteTo(object value, Nested.AnyBase ab)
{
ab.unityObj = GetUnityObject(type, value);
}
void ITypeSerialize.MergeFrom(ref object value, Nested.AnyBase ab)
{
value = int.Parse(ab.baseValue);
}
// 把值写入到ab当中
void ITypeSerialize.WriteTo(object value, Nested.AnyBase ab)
{
ab.baseValue = ((int)value).ToString();
}
public override bool Get(string key, out AnyBase ab)
{
throw new System.Exception("AnyEnd.Get");
}
public abstract bool Get(string key, out AnyBase ab);
// 通过ab来设置值
void ITypeSerialize.MergeFrom(ref object value, Nested.AnyBase ab)
{
value = Str2Enum.To(ab.baseValue, enumType);
}
// 把值写入到ab当中
void ITypeSerialize.WriteTo(object value, Nested.AnyBase ab)
{
ab.baseValue = Str2Enum.GetEnumStr(value, enumType);
}
public static void MergeFrom(object obj, Nested.AnyBase ab)
{
BinarySerializable.MergeFrom(obj, ab);
}
void ITypeSerialize.MergeFrom(ref object value, Nested.AnyBase ab)
{
value = System.Enum.ToObject(enumType, int.Parse(ab.baseValue));
}
