public object LoadValue(XmlReaderContext context)
{
var type = DecodeTypeName(context.LoadFromAttribute("Type"));
var value = context.LoadFromAttribute();
return(Enum.Parse(type, value));
}
public static Parameter Load(XmlReaderContext context)
{
var type = DecodeTypeName(context.LoadFromAttribute("Type"));
if (type == null)
{
throw new NotSupportedException();
}
var name = context.CurrentName;
IXmlPersister persister = null;
if (type.IsEnum)
{
Persisters.TryGetValue(typeof(Enum), out persister);
}
else if (type.IsArray)
{
Persisters.TryGetValue(typeof(Array), out persister);
}
else
{
Persisters.TryGetValue(type, out persister);
}
if (persister != null)
{
return(new Parameter(name, type, persister.LoadValue(context)));
}
else
{
return(new Parameter(name, type, null));
}
}
protected override PointF LoadCore(XmlReaderContext context)
{
var x = XmlConvert.ToSingle(context.LoadFromAttribute("X"));
var y = XmlConvert.ToSingle(context.LoadFromAttribute("Y"));
return(new PointF(x, y));
}
public void WhenConfigFileIsNotValid()
{
// const string xml = @"<?xml version='1.0' encoding='UTF-8' ?>
//<objects xmlns='http://www.springframework.net' xmlns:v='http://www.springframework.net/validation'>
// <v:required test='#this'>
// <v:message id='error.airportCode.required' providers='summary'/>
// <v:action type='Spring.Validation.Actions.ExpressionAction, Spring.Core' when='true'/>
// </v:required>
//</objects>
//";
XmlDocument doc = GetValidatedXmlResource("_WhenConfigFileIsNotValid.xml");
MockObjectDefinitionRegistry registry = new MockObjectDefinitionRegistry();
XmlReaderContext readerContext = new XmlReaderContext(null, new XmlObjectDefinitionReader(registry));
ObjectDefinitionParserHelper helper = new ObjectDefinitionParserHelper(readerContext);
helper.InitDefaults(doc.DocumentElement);
ParserContext parserContext = new ParserContext(helper);
ValidationNamespaceParser parser = new ValidationNamespaceParser();
foreach (XmlElement element in doc.DocumentElement.ChildNodes)
{
if (element.NamespaceURI == "http://www.springframework.net/validation")
{
parser.ParseElement(element, parserContext);
}
}
}
protected override SizeF LoadCore(XmlReaderContext context)
{
var w = XmlConvert.ToSingle(context.LoadFromAttribute("Width"));
var h = XmlConvert.ToSingle(context.LoadFromAttribute("Height"));
return(new SizeF(w, h));
}
public Section Load()
{
var doc = new XmlDocument();
doc.Load(_stream);
var context = new XmlReaderContext(doc);
return(SectionPersister.Load(context));
}
public object LoadValue(XmlReaderContext context)
{
var type = DecodeTypeName(context.LoadFromAttribute("Type"));
var etype = type.GetElementType();
var sranks = context.LoadFromAttribute("Array").Split(';');
var lengths = new int[sranks.Length];
bool empty = true;
for (int i = 0; i < lengths.Length; ++i)
{
lengths[i] = int.Parse(sranks[i], System.Globalization.NumberStyles.None);
if (lengths[i] > 0)
{
empty = false;
}
}
Array res;
if (lengths.Length == 1)
{
res = Array.CreateInstance(etype, lengths[0]);
}
else
{
res = Array.CreateInstance(etype, lengths);
}
if (empty)
{
return(res);
}
var values = new int[lengths.Length];
bool inc = true;
context.Push();
try
{
if (!empty)
{
while (inc)
{
var p = ParameterPersister.Load(context);
res.SetValue(p.Value, values);
inc = Increment(values, lengths);
if (inc)
{
context.Next();
}
}
}
}
finally
{
context.Pop();
}
return(res);
}
protected override RectangleF LoadCore(XmlReaderContext context)
{
var x = XmlConvert.ToSingle(context.LoadFromAttribute("X"));
var y = XmlConvert.ToSingle(context.LoadFromAttribute("Y"));
var w = XmlConvert.ToSingle(context.LoadFromAttribute("Width"));
var h = XmlConvert.ToSingle(context.LoadFromAttribute("Height"));
return(new RectangleF(x, y, w, h));
}
protected override string LoadCore(XmlReaderContext context)
{
return(context.LoadFromAttribute());
}
protected override Guid LoadCore(XmlReaderContext context)
{
return(XmlConvert.ToGuid(context.LoadFromAttribute()));
}
protected override TimeSpan LoadCore(XmlReaderContext context)
{
return(XmlConvert.ToTimeSpan(context.LoadFromAttribute()));
}
public object LoadValue(XmlReaderContext context)
{
return(LoadCore(context));
}
protected override double LoadCore(XmlReaderContext context)
{
return(XmlConvert.ToDouble(context.LoadFromAttribute()));
}
protected override float LoadCore(XmlReaderContext context)
{
return(XmlConvert.ToSingle(context.LoadFromAttribute()));
}
protected override ulong LoadCore(XmlReaderContext context)
{
return(XmlConvert.ToUInt64(context.LoadFromAttribute()));
}
protected override int LoadCore(XmlReaderContext context)
{
return(XmlConvert.ToInt32(context.LoadFromAttribute()));
}
protected override char LoadCore(XmlReaderContext context)
{
return(XmlConvert.ToChar(context.LoadFromAttribute()));
}
protected override bool LoadCore(XmlReaderContext context)
{
return(XmlConvert.ToBoolean(context.LoadFromAttribute()));
}
protected override decimal LoadCore(XmlReaderContext context)
{
return(XmlConvert.ToDecimal(context.LoadFromAttribute()));
}
protected abstract T LoadCore(XmlReaderContext context);
protected override DateTime LoadCore(XmlReaderContext context)
{
return(XmlConvert.ToDateTime(context.LoadFromAttribute(), XmlDateTimeSerializationMode.Utc));
}
protected override DateTimeOffset LoadCore(XmlReaderContext context)
{
return(XmlConvert.ToDateTimeOffset(context.LoadFromAttribute()));
}
public void WhenConfigFileIsValid()
{
XmlDocument doc = GetValidatedXmlResource("_WhenConfigFileIsValid.xml");
MockObjectDefinitionRegistry registry = new MockObjectDefinitionRegistry();
XmlReaderContext readerContext = new XmlReaderContext(null, new XmlObjectDefinitionReader(registry));
ObjectDefinitionParserHelper helper = new ObjectDefinitionParserHelper(readerContext);
helper.InitDefaults(doc.DocumentElement);
ParserContext parserContext = new ParserContext(helper);
ValidationNamespaceParser parser = new ValidationNamespaceParser();
foreach (XmlElement element in doc.DocumentElement.ChildNodes)
{
if (element.NamespaceURI == "http://www.springframework.net/validation")
{
parser.ParseElement(element, parserContext);
}
}
IList <IObjectDefinition> defs = registry.GetObjectDefinitions();
Assert.AreEqual(9, defs.Count);
IObjectDefinition def = registry.GetObjectDefinition("destinationAirportValidator");
Assert.IsTrue(def.IsSingleton);
Assert.IsTrue(def.IsLazyInit);
Assert.IsTrue(typeof(IValidator).IsAssignableFrom(def.ObjectType));
PropertyValue fastValidateProperty = def.PropertyValues.GetPropertyValue("FastValidate");
Assert.IsNotNull(fastValidateProperty);
Assert.AreEqual("true", fastValidateProperty.Value);
PropertyValue validatorsProperty = def.PropertyValues.GetPropertyValue("Validators");
Assert.IsNotNull(validatorsProperty);
object validatorsObject = validatorsProperty.Value;
Assert.AreEqual(typeof(ManagedList), validatorsObject.GetType());
ManagedList validators = (ManagedList)validatorsObject;
Assert.AreEqual(4, validators.Count);
def = (IObjectDefinition)validators[3];
Assert.IsTrue(def.IsSingleton);
Assert.IsTrue(def.IsLazyInit);
Assert.AreEqual(typeof(RegularExpressionValidator), def.ObjectType);
Assert.AreEqual("[A-Z]*", def.PropertyValues.GetPropertyValue("Expression").Value);
def = registry.GetObjectDefinition("simpleAirportValidator");
Assert.IsTrue(def.IsSingleton);
Assert.IsTrue(def.IsLazyInit);
Assert.IsTrue(typeof(IValidator).IsAssignableFrom(def.ObjectType));
PropertyValue actionsProperty = def.PropertyValues.GetPropertyValue("Actions");
Assert.IsNotNull(actionsProperty);
object actionsObject = actionsProperty.Value;
Assert.AreEqual(typeof(ManagedList), actionsObject.GetType());
ManagedList actions = (ManagedList)actionsObject;
Assert.AreEqual(1, actions.Count);
IObjectDefinition exceptionActionDefinition = (IObjectDefinition)actions[0];
Assert.AreEqual(typeof(ExceptionAction), exceptionActionDefinition.ObjectType);
Assert.AreEqual("'new System.InvalidOperationException(\"invalid\")' []", exceptionActionDefinition.ConstructorArgumentValues.GenericArgumentValues[0].ToString());
//
def = registry.GetObjectDefinition("airportCodeValidator");
Assert.IsTrue(def.IsSingleton);
Assert.IsTrue(def.IsLazyInit);
Assert.IsTrue(typeof(IValidator).IsAssignableFrom(def.ObjectType));
actionsProperty = def.PropertyValues.GetPropertyValue("Actions");
Assert.IsNotNull(actionsProperty);
actionsObject = actionsProperty.Value;
Assert.AreEqual(typeof(ManagedList), actionsObject.GetType());
actions = (ManagedList)actionsObject;
Assert.AreEqual(4, actions.Count);
IObjectDefinition messageDefinition = (IObjectDefinition)actions[1];
Assert.AreEqual(typeof(ErrorMessageAction), messageDefinition.ObjectType);
IObjectDefinition actionDefinition = (IObjectDefinition)actions[2];
Assert.AreEqual(typeof(ExpressionAction), actionDefinition.ObjectType);
Assert.AreEqual("#now = DateTime.Now", actionDefinition.PropertyValues.GetPropertyValue("Valid").Value);
def = registry.GetObjectDefinition("regex");
Assert.IsTrue(def.IsSingleton);
Assert.IsTrue(def.IsLazyInit);
Assert.IsTrue(typeof(IValidator).IsAssignableFrom(def.ObjectType));
PropertyValue expressionProperty = def.PropertyValues.GetPropertyValue("Expression");
Assert.IsNotNull(expressionProperty);
Assert.AreEqual("RegExp", expressionProperty.Value);
}
public static Section Load(XmlReaderContext context)
{
var name = context.CurrentName;
var res = new Section(name);
bool empty = context.Node.ChildNodes.Count == 0;
if (empty)
{
return(res);
}
var style = context.LoadFromAttribute("Style");
bool noSections = style == "NoSections";
bool noParameters = !noSections && style == "NoParameters";
if (noParameters || context.TryPush("Sections"))
{
try
{
foreach (XmlNode subsectionNode in context.Node.ChildNodes)
{
context.Push(subsectionNode.Name);
try
{
res.AddSection(SectionPersister.Load(context));
}
finally
{
context.Pop();
}
}
}
finally
{
if (!noParameters)
{
context.Pop();
}
}
}
if (noSections || context.TryPush("Parameters"))
{
try
{
foreach (XmlNode parameterNode in context.Node.ChildNodes)
{
context.Push(parameterNode.Name);
try
{
res.AddParameter(ParameterPersister.Load(context));
}
catch (Exception exc)
{
if (exc.IsCritical())
{
throw;
}
}
finally
{
context.Pop();
}
}
}
finally
{
if (!noSections)
{
context.Pop();
}
}
}
return(res);
}
