public void SetObjectData(ref object obj, IObjectGraphNode node)
{
Type objType = obj.GetType();
Type elemType = TypeTools.GetGenericArguments(objType)[0];
IGraphNode comparerData = node["comparer"];
if (comparerData != null)
{
Type comparerType = typeof(IEqualityComparer <>).MakeGenericType(elemType);
var comparer = comparerData.RebuildObject(comparerType);
objType.GetConstructor(false, comparerType).Invoke(obj, new[] { comparer });
}
else
{
objType.GetConstructor(false).Invoke(obj, null);
}
ISequenceGraphNode elements = node["elements"] as ISequenceGraphNode;
if (elements != null)
{
var m = TypeTools.GetRuntimeMethod(objType, "UnionWith");
var a = Array.CreateInstance(elemType, elements.Length);
elements.Select(e => e.RebuildObject(elemType)).ToArray().CopyTo(a, 0);
m.Invoke(obj, new object[] { a });
}
}
public void SetObjectData(ref object obj, IObjectGraphNode node)
{
IDictionary d = (IDictionary)obj;
Type objType = d.GetType();
Type keyType = typeof(object);
Type valueType = typeof(object);
if (objType.IsGenericType)
{
Type[] gen = objType.GetGenericArguments();
keyType = gen[0];
valueType = gen[1];
}
//TODO missing add comparer
ISequenceGraphNode elements = node["dictionary"] as ISequenceGraphNode;
foreach (var e in elements)
{
IObjectGraphNode entry = e as IObjectGraphNode;
object key = entry["key"].RebuildObject(keyType);
object value = entry["value"].RebuildObject(valueType);
d.Add(key, value);
}
}
private void WriteObjectNode(BinaryWriter writer, IObjectGraphNode node)
{
byte code = 0;
if (node.IsReferedMultipleTimes && node.RefId >= 0)
{
code |= 0x1;
}
if (node.ObjectType != null)
{
code |= 0x2;
}
writer.Write(code);
if (node.IsReferedMultipleTimes && node.RefId >= 0)
{
writer.Write(node.RefId);
}
if (node.ObjectType != null)
{
writer.Write(node.ObjectType.TypeId);
}
writer.Write(node.NumOfFields);
using (var it = node.GetEnumerator())
{
while (it.MoveNext())
{
writer.Write(it.Current.FieldName);
WriteNode(writer, it.Current.FieldNode);
}
}
}
public void GetObjectData(object obj, IObjectGraphNode holder)
{
IDictionary e = (IDictionary)obj;
Type objType = e.GetType();
Type keyType = typeof(object);
Type valueType = typeof(object);
if (objType.IsGenericType)
{
Type[] gen = objType.GetGenericArguments();
keyType = gen[0];
valueType = gen[1];
}
ISequenceGraphNode elements = holder.ParentGraph.BuildSequenceNode();
holder["dictionary"] = elements;
IDictionaryEnumerator it = e.GetEnumerator();
while (it.MoveNext())
{
IObjectGraphNode entry = holder.ParentGraph.CreateObjectData();
entry["key"] = holder.ParentGraph.BuildNode(it.Key, keyType);
entry["value"] = holder.ParentGraph.BuildNode(it.Value, valueType);
elements.Add(entry);
}
//TODO missing add comparer
}
public void SetObjectData(ref object obj, IObjectGraphNode node)
{
Type objType = obj.GetType();
Type elemType = objType.GetGenericArguments()[0];
IGraphNode comparerData = node["comparer"];
if (comparerData != null)
{
Type comparerType = typeof(IEqualityComparer <>).MakeGenericType(elemType);
var comparerObject = comparerData.RebuildObject(comparerType);
var f = objType.GetField("m_comparer", BindingFlags.NonPublic | BindingFlags.Instance);
f.SetValue(obj, comparerObject);
}
ISequenceGraphNode elements = node["elements"] as ISequenceGraphNode;
if (elements != null)
{
var m = objType.GetMethod("UnionWith");
var a = Array.CreateInstance(elemType, elements.Length);
elements.Select(e => e.RebuildObject(elemType)).ToArray().CopyTo(a, 0);
m.Invoke(obj, new object[] { a });
}
}
public void SetObjectData(ref object obj, IObjectGraphNode node)
{
IDictionary d = (IDictionary)obj;
Type objType = d.GetType();
Type keyType = typeof(object);
Type valueType = typeof(object);
if (objType.IsGenericType())
{
Type[] gen = TypeTools.GetGenericArguments(objType);
keyType = gen[0];
valueType = gen[1];
}
objType.GetConstructor(false).Invoke(obj, null);
//TODO missing add comparer
ISequenceGraphNode elements = node["dictionary"] as ISequenceGraphNode;
foreach (var e in elements)
{
IObjectGraphNode entry = e as IObjectGraphNode;
object key = entry["key"].RebuildObject(keyType);
object value = entry["value"].RebuildObject(valueType);
d.Add(key, value);
}
}
public void GetObjectData(object obj, IObjectGraphNode holder)
{
IDictionary e = (IDictionary)obj;
Type objType = e.GetType();
Type keyType = typeof(object);
Type valueType = typeof(object);
if (objType.IsGenericType())
{
Type[] gen = TypeTools.GetGenericArguments(objType);
keyType = gen[0];
valueType = gen[1];
}
ISequenceGraphNode elements = holder.ParentGraph.BuildSequenceNode();
holder["dictionary"] = elements;
IDictionaryEnumerator it = e.GetEnumerator();
while (it.MoveNext())
{
IObjectGraphNode entry = holder.ParentGraph.CreateObjectData();
entry["key"] = holder.ParentGraph.BuildNode(it.Key, keyType);
entry["value"] = holder.ParentGraph.BuildNode(it.Value, valueType);
elements.Add(entry);
}
//TODO missing add comparer
}
private JsonObject NodeToJson(IObjectGraphNode node)
{
JsonObject json = new JsonObject();
if (node.IsReferedMultipleTimes)
{
if (node.RefId >= 0)
{
json["refId"] = new JsonNumber(node.RefId);
}
}
if (node.ObjectType != null)
{
json["classId"] = new JsonNumber(node.ObjectType.TypeId);
}
using (var it = node.GetEnumerator())
{
while (it.MoveNext())
{
json[it.Current.FieldName] = ToJson(it.Current.FieldNode);
}
}
return(json);
}
private JsonToken ToJson(IGraphNode node)
{
if (node == null)
{
return(null);
}
switch (node.DataType)
{
case SerializedDataType.Boolean:
return(new JsonBool((bool)((IPrimitiveGraphNode)node).Value));
case SerializedDataType.Number:
return(new JsonNumber((node as IPrimitiveGraphNode).Value));
case SerializedDataType.String:
return(new JsonString((node as IStringGraphNode).Value));
case SerializedDataType.DataSequence:
return(new JsonArray((node as ISequenceGraphNode).Select(n => ToJson(n))));
case SerializedDataType.Type:
return(new JsonString("class@" + (node as ITypeGraphNode).TypeId));
}
IObjectGraphNode objNode = node as IObjectGraphNode;
if (objNode.IsReferedMultipleTimes)
{
return(new JsonString("refId@" + objNode.RefId.ToString()));
}
return(NodeToJson(objNode));
}
public IObjectGraphNode BuildObjectGraph(Type type, string nodeName)
{
ComplexObjectGraphNode node = new ComplexObjectGraphNode()
{
NodeType = type,
NodeName = nodeName
};
if (_cachedNodes.ContainsKey(type))
{
node.ChildrenObjectGraphNodes = _cachedNodes[type];
return(node);
}
Type genericType = type.GenericTypeArguments.SingleOrDefault();
IObjectGrapher objectGrapher = ObjectGraphers.GetApplicableObjectGrapher(genericType);
IObjectGraphNode childNode = objectGrapher?.BuildObjectGraph(genericType, genericType.Name);
node.ChildrenObjectGraphNodes.Add(childNode);
_cachedNodes.Add(type, node.ChildrenObjectGraphNodes);
return(node);
}
public IObjectGraphNode BuildObjectGraph(Type type, string nodeName)
{
ComplexObjectGraphNode node = new ComplexObjectGraphNode()
{
NodeType = type,
NodeName = nodeName
};
if (_cachedNodes.ContainsKey(type))
{
node.ChildrenObjectGraphNodes = _cachedNodes[type];
return(node);
}
PropertyInfo[] propertyInfos = type.GetProperties();
foreach (PropertyInfo propertyInfo in propertyInfos)
{
IObjectGrapher objectGrapher = ObjectGraphers.GetApplicableObjectGrapher(propertyInfo.PropertyType);
IObjectGraphNode childNode = objectGrapher.BuildObjectGraph(propertyInfo.PropertyType, propertyInfo.Name);
node.ChildrenObjectGraphNodes.Add(childNode);
}
_cachedNodes.Add(type, node.ChildrenObjectGraphNodes);
return(node);
}
/// <summary>
/// Deserialization constructor
/// </summary>
protected BaseActionDefinition(IObjectGraphNode node, object contextData)
{
var actionTemplate = node["Action"].RebuildObject <Name>();
var terms = actionTemplate.GetTerms().ToArray();
var name = terms[0];
if (!name.IsPrimitive)
{
throw new Exception("Invalid Action Template format");
}
for (int i = 1; i < terms.Length; i++)
{
if (terms[i].IsComposed)
{
throw new Exception("Invalid Action Template format");
}
}
var target = SerializationServices.GetFieldOrDefault(node, "Target", Name.NIL_SYMBOL);
if (target.IsComposed)
{
throw new ArgumentException("Action Definition Target must be a symbol definition", nameof(target));
}
Id = Guid.NewGuid();
m_actionTemplate = actionTemplate;
Target = target;
ActivationConditions = node["Conditions"].RebuildObject <ConditionSet>();
}
public override void GetSerializationData(Graph serializationParent, IObjectGraphNode node, object contextData)
{
base.GetSerializationData(serializationParent, node, contextData);
if (ActivationCooldown != (float)contextData)
{
node["Cooldown"] = serializationParent.BuildNode(ActivationCooldown);
}
}
public virtual void GetSerializationData(Graph serializationParent, IObjectGraphNode node, object contextData)
{
node["Action"] = serializationParent.BuildNode(GetActionTemplate());
if (Target != null && Target != Name.NIL_SYMBOL)
{
node["Target"] = serializationParent.BuildNode(Target);
}
node["Conditions"] = serializationParent.BuildNode(ActivationConditions);
}
public static T GetFieldOrDefault <T>(IObjectGraphNode node, string fieldName, T defaultValue)
{
IGraphNode target;
if (node.TryGetField(fieldName, out target))
{
return(target.RebuildObject <T>());
}
return(defaultValue);
}
public void Given_PrimitiveType_Expect_RootNode()
{
// Arrange
Type type = typeof(int);
string rootNodeName = "Int";
// Act
IObjectGraphNode node = _objectGrapher.BuildObjectGraph(type, rootNodeName);
// Assert
node.Should().NotBeNull();
node.NodeType.Should().Be(type);
node.NodeName.Should().Be(rootNodeName);
}
public bool GetObjectNode(object obj, out IObjectGraphNode dataNode)
{
int id;
if (m_links.TryGetValue(obj, out id))
{
dataNode = m_refs[id];
return(false);
}
var node = new ObjectGraphNode(m_idCounter++, this);
m_refs[node.RefId] = node;
m_links[obj] = node.RefId;
dataNode = node;
return(true);
}
public void GetObjectData(object obj, IObjectGraphNode holder)
{
Type objType = obj.GetType();
var allFields = TypeTools.GetRuntimeFields(objType);
var f = allFields.FirstOrDefault(field => CompareRegex.IsMatch(field.Name));
if (f != null)
{
var comparator = f.GetValue(obj);
Type comparatorType = comparator.GetType();
if (!(comparatorType.IsGenericType() && DefaultComparatorTypes.Contains(comparatorType.GetGenericTypeDefinition())))
holder["comparer"] = holder.ParentGraph.BuildNode(comparator, null);
}
Type elementType = TypeTools.GetGenericArguments(objType)[0];
var nodeSequence = ((IEnumerable) obj).Cast<object>().Select(o => holder.ParentGraph.BuildNode(o, elementType));
ISequenceGraphNode sequence = holder.ParentGraph.BuildSequenceNode();
sequence.AddRange(nodeSequence);
holder["elements"] = sequence;
}
public void GetObjectData(object obj, IObjectGraphNode holder)
{
Type objType = obj.GetType();
var allFields = objType.GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
var f = allFields.FirstOrDefault(field => CompareRegex.IsMatch(field.Name));
if (f != null)
{
var comparator = f.GetValue(obj);
Type comparatorType = comparator.GetType();
if (!(comparatorType.IsGenericType && DefaultComparatorTypes.Contains(comparatorType.GetGenericTypeDefinition())))
{
holder["comparer"] = holder.ParentGraph.BuildNode(comparator, null);
}
}
Type elementType = objType.GetGenericArguments()[0];
var nodeSequence = ((IEnumerable)obj).Cast <object>().Select(o => holder.ParentGraph.BuildNode(o, elementType));
ISequenceGraphNode sequence = holder.ParentGraph.BuildSequenceNode();
sequence.AddRange(nodeSequence);
holder["elements"] = sequence;
}
public void SetObjectData(ref object obj, IObjectGraphNode node)
{
Type objType = obj.GetType();
Type elemType = TypeTools.GetGenericArguments(objType)[0];
IGraphNode comparerData = node["comparer"];
if (comparerData != null)
{
Type comparerType = typeof (IEqualityComparer<>).MakeGenericType(elemType);
var comparer = comparerData.RebuildObject(comparerType);
objType.GetConstructor(false, comparerType).Invoke(obj, new[] {comparer});
}
else
objType.GetConstructor(false).Invoke(obj, null);
ISequenceGraphNode elements = node["elements"] as ISequenceGraphNode;
if (elements != null)
{
var m = TypeTools.GetRuntimeMethod(objType,"UnionWith");
var a = Array.CreateInstance(elemType, elements.Length);
elements.Select(e => e.RebuildObject(elemType)).ToArray().CopyTo(a, 0);
m.Invoke(obj, new object[] {a});
}
}
public void GetObjectData(object obj, IObjectGraphNode holder)
{
((ICustomSerialization)obj).GetObjectData(holder.ToSerializationData(),holder.ParentGraph.Context);
}
public void SetObjectData(ref object obj, IObjectGraphNode node)
{
var data = node.ToSerializationData();
((ICustomSerialization)obj).SetObjectData(data, node.ParentGraph.Context);
}
public void GetObjectData(object obj, IObjectGraphNode holder)
{
((ICustomSerialization)obj).GetObjectData(holder.ToSerializationData(), holder.ParentGraph.Context);
}
public void SetObjectData(ref object obj, IObjectGraphNode node)
{
var data = node.ToSerializationData();
((ICustomSerialization)obj).SetObjectData(data, node.ParentGraph.Context);
}
public void SetObjectData(ref object obj, IObjectGraphNode node)
{
var data = node.ToSerializationData();
SerializationServices.ExtractFromFieldData(data,ref obj,true);
}
/// <summary>
/// Deserialization constructor
/// </summary>
public ActionTendency(IObjectGraphNode node, object contextData) : base(node, contextData)
{
ActivationCooldown = SerializationServices.GetFieldOrDefault(node, "Cooldown", (float)contextData);
}
public void SetObjectData(ref object obj, IObjectGraphNode node)
{
var data = node.ToSerializationData();
SerializationServices.ExtractFromFieldData(data, ref obj, true);
}
private void WriteObjectNode(BinaryWriter writer, IObjectGraphNode node)
{
byte code = 0;
if (node.IsReferedMultipleTimes && node.RefId >= 0)
code |= 0x1;
if (node.ObjectType != null)
code |= 0x2;
writer.Write(code);
if (node.IsReferedMultipleTimes && node.RefId >= 0)
writer.Write(node.RefId);
if (node.ObjectType != null)
writer.Write(node.ObjectType.TypeId);
writer.Write(node.NumOfFields);
using (var it = node.GetEnumerator())
{
while (it.MoveNext())
{
writer.Write(it.Current.FieldName);
WriteNode(writer, it.Current.FieldNode);
}
}
}
public void GetObjectData(object obj, IObjectGraphNode holder)
{
var data = holder.ToSerializationData();
SerializationServices.PopulateWithFieldData(data, obj, true,false);
}
public void GetObjectData(object obj, IObjectGraphNode holder)
{
var data = holder.ToSerializationData();
SerializationServices.PopulateWithFieldData(data, obj, true, false);
}
public SerializationData(IObjectGraphNode holder)
{
_holder = holder;
}
