public OverrideValueParseMap(IValueParseMap innerParseMap, params IValueParser[] overrides)
{
innerParseMap.ThrowIfNullArgument(nameof(innerParseMap));
overrides.ThrowIfNullArgument(nameof(overrides));
this.overrides = new IValueParser[overrides.Length];
for (int i = 0; i < overrides.Length; i++)
{
IValueParser parser = overrides[i];
if (parser.IsNull())
{
throw new ArgumentNullException($"Encountered null value at index {i}", nameof(overrides));
}
if (this.overrides.Any(x => x?.ParseType == parser.ParseType))
{
throw new ArgumentException($"Attempted to register override for type {parser.ParseType} more than once", nameof(overrides));
}
this.overrides[i] = parser;
}
this.innerParseMap = innerParseMap;
}
public void TestInstance()
{
IValueParseMap instance = DefaultValueParseMap.Instance;
Assert.NotNull(instance);
Assert.Null(instance as IMutableValueParseMap);
}
public void TestInstance()
{
IValueParseMap instance = DefaultValueParseMap.Instance;
Assert.NotNull(instance);
Assert.IsNotType <IMutableValueParseMap>(instance);
}
public void TestNew__NullArgument()
{
IValueParseMap parseMap = Substitute.For <IValueParseMap>();
Assert.Throws <ArgumentNullException>(() => new ValueScalarMapperBuilder(null, typeof(DummyClass), parseMap));
Assert.Throws <ArgumentNullException>(() => new ValueScalarMapperBuilder("foo", null, parseMap));
Assert.Throws <ArgumentNullException>(() => new ValueScalarMapperBuilder("foo", typeof(DummyClass), null));
}
public void TestBuildMapper__CantBuild()
{
IValueParseMap parseMap = Substitute.For <IValueParseMap>();
ValueScalarMapperBuilder builder = new ValueScalarMapperBuilder("foo", typeof(DummyClass), parseMap);
parseMap.CanParse(typeof(DummyClass)).Returns(false);
Assert.Throws <InvalidOperationException>(() => builder.BuildMapper());
}
public void TestCanBuild__False()
{
IValueParseMap parseMap = Substitute.For <IValueParseMap>();
ValueScalarMapperBuilder builder = new ValueScalarMapperBuilder("foo", typeof(DummyClass), parseMap);
parseMap.CanParse(typeof(DummyClass)).Returns(false);
Assert.False(builder.CanBuild);
}
public void TestNew()
{
IValueParseMap parseMap = Substitute.For <IValueParseMap>();
ValueScalarMapperBuilder builder = new ValueScalarMapperBuilder("foo", typeof(DummyClass), parseMap);
Assert.Equal("foo", builder.nodeDataName);
Assert.Same(typeof(DummyClass), builder.fieldType);
Assert.Same(parseMap, builder.parseMap);
}
public void TestCanBuild__True()
{
IValueParseMap parseMap = Substitute.For <IValueParseMap>();
ValueListMapperBuilder builder = new ValueListMapperBuilder("foo", typeof(List <DummyClass>), parseMap);
parseMap.CanParse(typeof(DummyClass)).Returns(true);
Assert.True(builder.CanBuild);
}
public ValueScalarMapperBuilder(string nodeDataName, Type fieldType, IValueParseMap parseMap)
{
nodeDataName.ThrowIfNullArgument(nameof(nodeDataName));
fieldType.ThrowIfNullArgument(nameof(fieldType));
parseMap.ThrowIfNullArgument(nameof(parseMap));
this.nodeDataName = nodeDataName;
this.fieldType = fieldType;
this.parseMap = parseMap;
}
public ValueListMapperBuilder(string nodeDataName, Type fieldType, IValueParseMap parseMap)
{
nodeDataName.ThrowIfNullArgument(nameof(nodeDataName));
fieldType.ThrowIfNullArgument(nameof(fieldType));
parseMap.ThrowIfNullArgument(nameof(parseMap));
this.nodeDataName = nodeDataName;
this.parseMap = parseMap;
if (fieldType.IsListType())
{
elementType = fieldType.GetGenericArguments()[0];
}
}
public void TestCreateFieldBuilder()
{
NodeDataListBuilder builder = new NodeDataListBuilder(Substitute.For <Type>());
NodeData nodeData = new NodeData {
name = "fieldbro"
};
IFieldWrapper fieldWrapper = Substitute.For <IFieldWrapper>();
IValueParseMap parseMap = Substitute.For <IValueParseMap>();
NodeDataBuilder fieldBuilder = Assert.IsType <NodeDataBuilder>(builder.CreateFieldBuilder(nodeData, fieldWrapper, parseMap));
Assert.Same(nodeData, fieldBuilder.nodeData);
Assert.Same(fieldWrapper, fieldBuilder.fieldWrapper);
Assert.Same(parseMap, fieldBuilder.valueParseMap);
}
public void TestBuildMapper()
{
IValueParseMap parseMap = Substitute.For <IValueParseMap>();
ValueScalarMapperBuilder builder = new ValueScalarMapperBuilder("foo", typeof(DummyClass), parseMap);
IValueParser parser = Substitute.For <IValueParser>();
parseMap.CanParse(typeof(DummyClass)).Returns(true);
parseMap.GetParser(typeof(DummyClass)).Returns(parser);
ValueScalarMapper mapper = Assert.IsType <ValueScalarMapper>(builder.BuildMapper());
parseMap.Received().GetParser(typeof(DummyClass));
Assert.Equal("foo", mapper.name);
Assert.Same(parser, mapper.parser);
}
public NodeDataBuilder(NodeData nodeData, IFieldWrapper fieldWrapper, IValueParseMap defaultValueParseMap)
{
nodeData.ThrowIfNullArgument(nameof(nodeData));
fieldWrapper.ThrowIfNullArgument(nameof(fieldWrapper));
defaultValueParseMap.ThrowIfNullArgument(nameof(defaultValueParseMap));
this.nodeData = nodeData;
this.fieldWrapper = fieldWrapper;
object[] attributes = fieldWrapper.MemberInfo.GetCustomAttributes(true);
if (attributes.OfType <IUseParser>().Any())
{
IValueParser[] overrides = attributes.OfType <IUseParser>().Select(x => x.CreateParser()).ToArray();
valueParseMap = new OverrideValueParseMap(defaultValueParseMap, overrides);
}
else
{
valueParseMap = defaultValueParseMap;
}
}
public virtual NodeDataList CreateList()
{
List <INodeDataField> builtFields = new List <INodeDataField>();
IValueParseMap parseMap = DefaultValueParseMap.Instance;
foreach (FieldInfo field in type.GetFields(FIELD_BINDING_FLAGS))
{
NodeData nodeData = (NodeData)field.GetCustomAttributes(typeof(NodeData), true).FirstOrDefault();
if (nodeData == null)
{
continue;
}
IFieldWrapper fieldWrapper = new FieldWrapper(field);
INodeDataBuilder builder = CreateFieldBuilder(nodeData, fieldWrapper, parseMap);
builtFields.Add(builder.CreateNodeDataField());
}
foreach (PropertyInfo property in type.GetProperties(FIELD_BINDING_FLAGS))
{
NodeData nodeData = (NodeData)property.GetCustomAttributes(typeof(NodeData), true).FirstOrDefault();
if (nodeData == null)
{
continue;
}
IFieldWrapper fieldWrapper = new PropertyWrapper(property);
INodeDataBuilder builder = CreateFieldBuilder(nodeData, fieldWrapper, parseMap);
builtFields.Add(builder.CreateNodeDataField());
}
return(new NodeDataList(builtFields.ToArray()));
}
public virtual INodeDataBuilder CreateFieldBuilder(NodeData nodeData, IFieldWrapper fieldWrapper, IValueParseMap defaultValueParseMap)
{
return(new NodeDataBuilder(nodeData, fieldWrapper, defaultValueParseMap));
}
public ValueParseMapWrapper(IValueParseMap map)
{
map.ThrowIfNullArgument(nameof(map));
this.map = map;
}
