public bool Save(object fieldValue, ConfigNode node, OperationContext context)
{
node.ThrowIfNullArgument(nameof(node));
fieldValue.EnsureArgumentType(listType, nameof(fieldValue));
IList list = (IList)fieldValue;
if (list.IsNullOrEmpty())
{
return(false);
}
foreach (object value in list)
{
if (value.IsNull())
{
continue;
}
ConfigNode innerNode = new ConfigNode();
NodeObjectWrapper.Save(value, innerNode, context);
node.AddNode(name, innerNode);
}
return(true);
}
public bool Load(ref object fieldValue, ConfigNode node, OperationContext context)
{
node.ThrowIfNullArgument(nameof(node));
fieldValue.EnsureArgumentType(listType, nameof(fieldValue));
ConfigNode[] nodes = node.GetNodes(name);
if (nodes.IsNullOrEmpty())
{
return(false);
}
if (fieldValue.IsNull())
{
fieldValue = Activator.CreateInstance(listType);
}
IList list = (IList)fieldValue;
if (context.Operation == Operation.Deserialize)
{
list.Clear();
}
foreach (ConfigNode innerNode in nodes)
{
if (innerNode.IsNull())
{
continue;
}
object obj = Activator.CreateInstance(elementType);
NodeObjectWrapper.Load(obj, innerNode, context);
list.Add(obj);
}
return(true);
}
public void TestLoad__UnrecognizedType()
{
object dummy = "this is a string";
ConfigNode node = new ConfigNode();
OperationContext context = new OperationContext(Operation.LoadInstance, "some object");
Assert.Throws <ArgumentException>(() => NodeObjectWrapper.Load(dummy, node, context));
}
public void TestLoad__NotLoadingContext()
{
object dummy = new DummyIConfigNode();
ConfigNode node = new ConfigNode();
OperationContext context = new OperationContext(Operation.Save, "some object");
Assert.Throws <ArgumentException>(() => NodeObjectWrapper.Load(dummy, node, context));
}
public void TestFor__OtherType()
{
NotImplementedException ex = Assert.Throws <NotImplementedException>(delegate
{
NodeObjectWrapper.For(typeof(string));
});
Assert.Equal("No way to build node object wrapper for type System.String", ex.Message);
}
public INodeDataMapper BuildMapper()
{
if (!CanBuild)
{
throw new InvalidOperationException();
}
return(new NodeScalarMapper(nodeDataName, NodeObjectWrapper.For(fieldType)));
}
public INodeDataMapper BuildMapper()
{
if (!CanBuild)
{
throw new InvalidOperationException();
}
return(new NodeListMapper(nodeDataName, elementType, NodeObjectWrapper.For(elementType)));
}
public void TestLoad__Null()
{
object dummy = new DummyIConfigNode();
ConfigNode node = new ConfigNode();
OperationContext context = new OperationContext(Operation.LoadInstance, "some object");
Assert.Throws <ArgumentNullException>(() => NodeObjectWrapper.Load(null, node, context));
Assert.Throws <ArgumentNullException>(() => NodeObjectWrapper.Load(dummy, null, context));
Assert.Throws <ArgumentNullException>(() => NodeObjectWrapper.Load(dummy, node, null));
}
public NodeScalarMapper(string name, Type fieldType)
{
name.ThrowIfNullArgument(nameof(name));
fieldType.ThrowIfNullArgument(nameof(fieldType));
if (!NodeObjectWrapper.IsNodeType(fieldType))
{
throw new ArgumentException($"Type {fieldType} does not implement {typeof(IConfigNode)} or {typeof(IContextualNode)}", nameof(fieldType));
}
this.name = name;
this.fieldType = fieldType;
}
public void TestSave__IConfigNode()
{
ConfigNode node = new ConfigNode();
DummyIConfigNode dummy = new DummyIConfigNode();
dummy.value = "test5678";
OperationContext context = new OperationContext(Operation.Save, "some object");
NodeObjectWrapper.Save(dummy, node, context);
Assert.Equal("test5678", node.GetValue("value"));
}
public void TestLoad__IConfigNode()
{
ConfigNode node = new TestConfigNode
{
{ "value", "blah1234" }
};
DummyIConfigNode dummy = new DummyIConfigNode();
OperationContext context = new OperationContext(Operation.LoadInstance, "some object");
NodeObjectWrapper.Load(dummy, node, context);
Assert.Equal("blah1234", dummy.value);
}
public NodeListMapper(string name, Type elementType)
{
name.ThrowIfNullArgument(nameof(name));
elementType.ThrowIfNullArgument(nameof(elementType));
if (!NodeObjectWrapper.IsNodeType(elementType))
{
throw new ArgumentException($"Type {elementType} does not implement {typeof(IConfigNode)} or {typeof(IContextualNode)}", nameof(elementType));
}
this.name = name;
this.elementType = elementType;
listType = typeof(List <>).MakeGenericType(elementType);
}
public bool Save(object fieldValue, ConfigNode node, OperationContext context)
{
node.ThrowIfNullArgument(nameof(node));
fieldValue.EnsureArgumentType <IConfigNode, IContextualNode>(nameof(fieldValue));
if (fieldValue.IsNull())
{
return(false);
}
ConfigNode innerNode = new ConfigNode();
NodeObjectWrapper.Save(fieldValue, innerNode, context);
node.AddNode(name, innerNode);
return(true);
}
public bool Load(ref object fieldValue, ConfigNode node, OperationContext context)
{
node.ThrowIfNullArgument(nameof(node));
fieldValue.EnsureArgumentType <IConfigNode, IContextualNode>(nameof(fieldValue));
ConfigNode innerNode = node.GetNode(name);
if (innerNode.IsNull())
{
return(false);
}
if (fieldValue.IsNull())
{
fieldValue = Activator.CreateInstance(fieldType);
}
NodeObjectWrapper.Load(fieldValue, innerNode, context);
return(true);
}
public void TestFor__IContextualNode()
{
NodeObjectWrapperIContextualNode wrapper = Assert.IsType <NodeObjectWrapperIContextualNode>(NodeObjectWrapper.For(typeof(DummyIContextualNode)));
Assert.Equal(typeof(DummyIContextualNode), wrapper.type);
}
public void TestIsNodeType__IContextualNode()
{
Assert.True(NodeObjectWrapper.IsNodeType(typeof(DummyIContextualNode)));
}
public void TestIsNodeType__ConfigNode()
{
Assert.True(NodeObjectWrapper.IsNodeType(typeof(ConfigNode)));
}
public void TestIsNodeType__Not()
{
Assert.False(NodeObjectWrapper.IsNodeType(typeof(DummyClass)));
}
public void TestIsNodeType()
{
Assert.True(NodeObjectWrapper.IsNodeType(typeof(DummyIConfigNode)));
Assert.True(NodeObjectWrapper.IsNodeType(typeof(DummyIContextualNode)));
Assert.False(NodeObjectWrapper.IsNodeType(typeof(DummyClass)));
}
public void TestFor__ConfigNode()
{
Assert.IsType <NodeObjectWrapperConfigNode>(NodeObjectWrapper.For(typeof(ConfigNode)));
}
