/// <summary>The do parse.</summary>
/// <param name="element">The element.</param>
/// <param name="parserContext">The parser context.</param>
/// <param name="builder">The builder.</param>
protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder)
{
var parser = new ObjectDefinitionParserHelper(parserContext);
var map = parser.ParseMapElement(element, builder.RawObjectDefinition);
builder.AddPropertyValue("SourceDictionary", map);
}
/// <summary>
/// Process the object element
/// </summary>
protected virtual void ProcessObjectDefinition(XmlElement element, ObjectDefinitionParserHelper helper)
{
// TODO: add event handling
try
{
ObjectDefinitionHolder bdHolder = helper.ParseObjectDefinitionElement(element);
if (bdHolder == null)
{
return;
}
bdHolder = helper.DecorateObjectDefinitionIfRequired(element, bdHolder);
if (log.IsEnabled(LogLevel.Debug))
{
log.LogDebug(string.Format(CultureInfo.InvariantCulture, "Registering object definition with id '{0}'.", bdHolder.ObjectName));
}
ObjectDefinitionReaderUtils.RegisterObjectDefinition(bdHolder, ReaderContext.Registry);
// TODO: Send registration event.
// ReaderContext.FireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
catch (ObjectDefinitionStoreException)
{
throw;
}
catch (Exception ex)
{
throw new ObjectDefinitionStoreException(
$"Failed parsing object definition '{element.OuterXml}'", ex);
}
}
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();
IObjectDefinitionDocumentReader reader = new DefaultObjectDefinitionDocumentReader();
XmlReaderContext readerContext = new XmlReaderContext(null, new XmlObjectDefinitionReader(registry));
ObjectDefinitionParserHelper helper = new ObjectDefinitionParserHelper(readerContext);
helper.InitDefaults(doc.DocumentElement);
ParserContext parserContext = new ParserContext(helper.ReaderContext, helper);
ValidationNamespaceParser parser = new ValidationNamespaceParser();
foreach (XmlElement element in doc.DocumentElement.ChildNodes)
{
if (element.NamespaceURI == "http://www.springframework.net/validation")
{
parser.ParseElement(element, parserContext);
}
}
}
/// <summary>
/// Read object definitions from the given DOM element, and register
/// them with the given object registry.
/// </summary>
/// <param name="doc">The DOM element containing object definitions, usually the
/// root (document) element.</param>
/// <param name="readerContext">The current context of the reader. Includes
/// the resource being parsed</param>
/// <returns>
/// The number of object definitions that were loaded.
/// </returns>
/// <exception cref="Spring.Objects.ObjectsException">
/// In case of parsing errors.
/// </exception>
public void RegisterObjectDefinitions(XmlDocument doc, XmlReaderContext readerContext)
{
//int objectDefinitionCounter = 0;
this.readerContext = readerContext;
if (log.IsEnabled(LogLevel.Debug))
{
log.LogDebug("Loading object definitions.");
}
XmlElement root = doc.DocumentElement;
ObjectDefinitionParserHelper parserHelper = CreateHelper(readerContext, root);
PreProcessXml(root);
ParseObjectDefinitions(root, parserHelper);
PostProcessXml(root);
if (log.IsEnabled(LogLevel.Debug))
{
log.LogDebug(
$"Found {readerContext.Registry.ObjectDefinitionCount} <{ObjectDefinitionConstants.ObjectElement}> elements defining objects.");
}
}
private void ParseDefaultElement(XmlElement element, ObjectDefinitionParserHelper helper)
{
if (element.LocalName == ObjectDefinitionConstants.ImportElement)
{
ImportObjectDefinitionResource(element);
}
else if (element.LocalName == ObjectDefinitionConstants.AliasElement)
{
ParseAlias(element, helper.ReaderContext.Registry);
}
else if (element.LocalName == ObjectDefinitionConstants.ObjectElement)
{
ProcessObjectDefinition(element, helper);
}
}
/// <summary>The do parse.</summary>
/// <param name="element">The element.</param>
/// <param name="parserContext">The parser context.</param>
/// <param name="builder">The builder.</param>
protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder)
{
var exchangeName = element.GetAttribute("name");
builder.AddConstructorArg(new TypedStringValue(exchangeName));
this.ParseBindings(element, parserContext, builder, exchangeName);
NamespaceUtils.AddConstructorArgBooleanValueIfAttributeDefined(builder, element, DURABLE_ATTRIBUTE, true);
NamespaceUtils.AddConstructorArgBooleanValueIfAttributeDefined(builder, element, AUTO_DELETE_ATTRIBUTE, false);
var argumentsElement = element.SelectChildElementByTagName(ARGUMENTS_ELEMENT);
if (argumentsElement != null)
{
var parser = new ObjectDefinitionParserHelper(parserContext);
var map = parser.ParseMapElementToTypedDictionary(argumentsElement, builder.RawObjectDefinition);
builder.AddConstructorArg(map);
}
}
/// <summary>
/// Read object definitions from the given DOM element, and register
/// them with the given object registry.
/// </summary>
/// <param name="doc">The DOM element containing object definitions, usually the
/// root (document) element.</param>
/// <param name="readerContext">The current context of the reader. Includes
/// the resource being parsed</param>
/// <returns>
/// The number of object definitions that were loaded.
/// </returns>
/// <exception cref="Spring.Objects.ObjectsException">
/// In case of parsing errors.
/// </exception>
public void RegisterObjectDefinitions(XmlDocument doc, XmlReaderContext readerContext)
{
//int objectDefinitionCounter = 0;
this.readerContext = readerContext;
#region Instrumentation
if (log.IsDebugEnabled)
{
log.Debug("Loading object definitions.");
}
#endregion
XmlElement root = doc.DocumentElement;
ObjectDefinitionParserHelper parserHelper = CreateHelper(readerContext, root);
PreProcessXml(root);
ParseObjectDefinitions(root, parserHelper);
PostProcessXml(root);
#region Instrumentation
if (log.IsDebugEnabled)
{
log.Debug(
string.Format(
"Found {0} <{1}> elements defining objects.",
readerContext.Registry.ObjectDefinitionCount,
ObjectDefinitionConstants.ObjectElement));
}
#endregion
}
/// <summary>
/// Parses object definitions starting at the given <see cref="XmlElement"/>
/// using the passed <see cref="ObjectDefinitionParserHelper"/>.
/// </summary>
/// <param name="root">The root element to start parsing from.</param>
/// <param name="helper">The <see cref="ObjectDefinitionParserHelper"/> instance to use.</param>
/// <exception cref="ObjectDefinitionStoreException">
/// in case an error happens during parsing and registering object definitions
/// </exception>
protected virtual void ParseObjectDefinitions(XmlElement root, ObjectDefinitionParserHelper helper)
{
if (helper.IsDefaultNamespace(root.NamespaceURI))
{
foreach (XmlNode node in root.ChildNodes)
{
if (node.NodeType != XmlNodeType.Element)
{
continue;
}
try
{
XmlElement element = (XmlElement)node;
if (helper.IsDefaultNamespace(element.NamespaceURI))
{
ParseDefaultElement(element, helper);
}
else
{
helper.ParseCustomElement(element);
}
}
catch (ObjectDefinitionStoreException)
{
throw;
}
catch (Exception ex)
{
helper.ReaderContext.ReportException(node, null, "Failed parsing element", ex);
}
}
}
else
{
helper.ParseCustomElement(root);
}
}
// private Stack containingComponents = new Stack();
/// <summary>
/// Initializes a new instance of the <see cref="ParserContext"/> class.
/// </summary>
/// <param name="parserHelper">The parser helper.</param>
public ParserContext(ObjectDefinitionParserHelper parserHelper)
{
this.readerContext = parserHelper.ReaderContext;
this.parserHelper = parserHelper;
}
/// <summary>
/// Creates an <see cref="ObjectDefinitionParserHelper"/> instance for the given <paramref name="readerContext"/> and <paramref name="root"/> element.
/// </summary>
/// <param name="readerContext">the <see cref="XmlReaderContext"/> to create the <see cref="ObjectDefinitionParserHelper"/> </param>
/// <param name="root">the root <see cref="XmlElement"/> to start reading from</param>
/// <returns>a new <see cref="ObjectDefinitionParserHelper"/> instance</returns>
protected virtual ObjectDefinitionParserHelper CreateHelper(XmlReaderContext readerContext, XmlElement root)
{
ObjectDefinitionParserHelper helper = new ObjectDefinitionParserHelper(readerContext, root);
return(helper);
}
/// <summary>
/// Parse an object definition and register it with the object factory..
/// </summary>
/// <param name="element">The element containing the object definition.</param>
/// <param name="helper">The helper.</param>
/// <seealso cref="Spring.Objects.Factory.Support.ObjectDefinitionReaderUtils.RegisterObjectDefinition"/>
protected virtual void RegisterObjectDefinition(XmlElement element, ObjectDefinitionParserHelper helper)
{
ProcessObjectDefinition(element, helper);
}
public ParserContext(XmlReaderContext readerContext, ObjectDefinitionParserHelper parserHelper)
{
this.readerContext = readerContext;
this.parserHelper = parserHelper;
}
/// <summary>
/// Parses object definitions starting at the given <see cref="XmlElement"/>
/// using the passed <see cref="ObjectDefinitionParserHelper"/>.
/// </summary>
/// <param name="root">The root element to start parsing from.</param>
/// <param name="helper">The <see cref="ObjectDefinitionParserHelper"/> instance to use.</param>
/// <exception cref="ObjectDefinitionStoreException">
/// in case an error happens during parsing and registering object definitions
/// </exception>
protected virtual void ParseObjectDefinitions(XmlElement root, ObjectDefinitionParserHelper helper)
{
if (helper.IsDefaultNamespace(root.NamespaceURI))
{
foreach (XmlNode node in root.ChildNodes)
{
if (node.NodeType != XmlNodeType.Element) continue;
try
{
XmlElement element = (XmlElement)node;
if (helper.IsDefaultNamespace(element.NamespaceURI))
{
ParseDefaultElement(element, helper);
}
else
{
helper.ParseCustomElement(element);
}
}
catch (ObjectDefinitionStoreException)
{
throw;
}
catch (Exception ex)
{
helper.ReaderContext.ReportException(node, null, "Failed parsing element", ex);
}
}
}
else
{
helper.ParseCustomElement(root);
}
}
public ParserContext(XmlReaderContext readerContext, ObjectDefinitionParserHelper parserHelper)
{
this.readerContext = readerContext;
this.parserHelper = parserHelper;
}
private void ParseDefaultElement(XmlElement element, ObjectDefinitionParserHelper helper)
{
if (element.LocalName == ObjectDefinitionConstants.ImportElement)
{
ImportObjectDefinitionResource(element);
}
else if (element.LocalName == ObjectDefinitionConstants.AliasElement)
{
ParseAlias(element, helper.ReaderContext.Registry);
}
else if (element.LocalName == ObjectDefinitionConstants.ObjectElement)
{
ProcessObjectDefinition(element, helper);
}
}
private object ParseReference(XmlElement element, ObjectDefinitionParserHelper parserHelper, string name)
{
// is it a generic reference to any name of any object?
string objectRef = GetAttributeValue(element, ObjectDefinitionConstants.ObjectRefAttribute);
if (StringUtils.IsNullOrEmpty(objectRef))
{
// is it a reference to the id of another object in the same XML file?
objectRef = GetAttributeValue(element, ObjectDefinitionConstants.LocalRefAttribute);
if (StringUtils.IsNullOrEmpty(objectRef))
{
// is it a reference to the id of another object in a parent context?
objectRef = GetAttributeValue(element, ObjectDefinitionConstants.ParentAttribute);
if (StringUtils.IsNullOrEmpty(objectRef))
{
throw new ObjectDefinitionStoreException(
parserHelper.ReaderContext.Resource,
name,
"Either 'object' or 'local' is required for a reference");
}
return new RuntimeObjectReference(objectRef, true);
}
}
return new RuntimeObjectReference(objectRef);
}
private bool ParseMergeAttribute(XmlElement collectionElement, ObjectDefinitionParserHelper helper)
{
string val = collectionElement.GetAttribute(ObjectDefinitionConstants.MergeAttribute);
if (ObjectDefinitionConstants.DefaultValue.Equals(val))
{
val = helper.Defaults.Merge;
}
return ObjectDefinitionConstants.TrueValue.Equals(val);
}
/// <summary>
/// Creates an <see cref="ObjectDefinitionParserHelper"/> instance for the given <paramref name="readerContext"/> and <paramref name="root"/> element.
/// </summary>
/// <param name="readerContext">the <see cref="XmlReaderContext"/> to create the <see cref="ObjectDefinitionParserHelper"/> </param>
/// <param name="root">the root <see cref="XmlElement"/> to start reading from</param>
/// <returns>a new <see cref="ObjectDefinitionParserHelper"/> instance</returns>
protected virtual ObjectDefinitionParserHelper CreateHelper(XmlReaderContext readerContext, XmlElement root)
{
ObjectDefinitionParserHelper helper = new ObjectDefinitionParserHelper(readerContext, root);
return helper;
}
/// <summary>
/// Parse an object definition and register it with the object factory..
/// </summary>
/// <param name="element">The element containing the object definition.</param>
/// <param name="helper">The helper.</param>
/// <seealso cref="Spring.Objects.Factory.Support.ObjectDefinitionReaderUtils.RegisterObjectDefinition"/>
protected virtual void RegisterObjectDefinition(XmlElement element, ObjectDefinitionParserHelper helper)
{
ProcessObjectDefinition(element, helper);
}
/// <summary>
/// Process the object element
/// </summary>
protected virtual void ProcessObjectDefinition(XmlElement element, ObjectDefinitionParserHelper helper)
{
// TODO: add event handling
try
{
ObjectDefinitionHolder bdHolder = helper.ParseObjectDefinitionElement(element);
if (bdHolder == null)
{
return;
}
bdHolder = helper.DecorateObjectDefinitionIfRequired(element, bdHolder);
#region Instrumentation
if (log.IsDebugEnabled)
{
log.Debug(string.Format(CultureInfo.InvariantCulture, "Registering object definition with id '{0}'.", bdHolder.ObjectName));
}
#endregion
ObjectDefinitionReaderUtils.RegisterObjectDefinition(bdHolder, ReaderContext.Registry);
// TODO: Send registration event.
// ReaderContext.FireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
catch (ObjectDefinitionStoreException)
{
throw;
}
catch (Exception ex)
{
throw new ObjectDefinitionStoreException(
string.Format("Failed parsing object definition '{0}'", element.OuterXml), ex);
}
}
// private static INamespaceParser GetParser(string nspace)
// {
// // finds the configuration parser for the given namespace
// try
// {
// return NamespaceParserRegistry.GetParser(nspace);
// }
// catch (Exception)
// {
// // The parser for the given namespace is not found
// return null;
// }
// }
private static object ParseIdReference(XmlElement element, ObjectDefinitionParserHelper parserHelper, string name)
{
// a generic reference to any name of any object
string objectRef = GetAttributeValue(element, ObjectDefinitionConstants.ObjectRefAttribute);
if (StringUtils.IsNullOrEmpty(objectRef))
{
// a reference to the id of another object in the same XML file
objectRef = GetAttributeValue(element, ObjectDefinitionConstants.LocalRefAttribute);
if (StringUtils.IsNullOrEmpty(objectRef))
{
throw new ObjectDefinitionStoreException(
parserHelper.ReaderContext.Resource,
name,
"Either 'object' or 'local' is required for an idref");
}
}
return objectRef;
}
/// <summary>
/// Initializes a new instance of the <see cref="ParserContext"/> class.
/// </summary>
/// <param name="parserHelper">The parser helper.</param>
/// <param name="containingObjectDefinition">The containing object definition.</param>
public ParserContext(ObjectDefinitionParserHelper parserHelper, IObjectDefinition containingObjectDefinition)
{
this.readerContext = parserHelper.ReaderContext;
this.parserHelper = parserHelper;
this.containingObjectDefinition = containingObjectDefinition;
}
// private Stack containingComponents = new Stack();
/// <summary>
/// Initializes a new instance of the <see cref="ParserContext"/> class.
/// </summary>
/// <param name="parserHelper">The parser helper.</param>
public ParserContext(ObjectDefinitionParserHelper parserHelper)
{
this.readerContext = parserHelper.ReaderContext;
this.parserHelper = parserHelper;
}
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 ParserContext(XmlReaderContext readerContext, ObjectDefinitionParserHelper parserHelper, IObjectDefinition containingObjectDefinition)
{
this.readerContext = readerContext;
this.parserHelper = parserHelper;
this.containingObjectDefinition = containingObjectDefinition;
}
/// <summary>The do parse.</summary>
/// <param name="element">The element.</param>
/// <param name="parserContext">The parser context.</param>
/// <param name="builder">The builder.</param>
protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder)
{
if (!NamespaceUtils.IsAttributeDefined(element, "name") && !NamespaceUtils.IsAttributeDefined(element, ID_ATTRIBUTE))
{
parserContext.ReaderContext.ReportFatalException(element, "Queue must have either id or name (or both)");
}
NamespaceUtils.AddConstructorArgValueIfAttributeDefined(builder, element, "name");
if (!NamespaceUtils.IsAttributeDefined(element, "name"))
{
if (this.AttributeHasIllegalOverride(element, DURABLE_ATTRIBUTE, "false")
|| this.AttributeHasIllegalOverride(element, EXCLUSIVE_ATTRIBUTE, "true")
|| this.AttributeHasIllegalOverride(element, AUTO_DELETE_ATTRIBUTE, "true"))
{
parserContext.ReaderContext.ReportFatalException(element, "Anonymous queue cannot specify durable='true', exclusive='false' or auto-delete='false'");
return;
}
}
else
{
NamespaceUtils.AddConstructorArgBooleanValueIfAttributeDefined(builder, element, DURABLE_ATTRIBUTE, false);
NamespaceUtils.AddConstructorArgBooleanValueIfAttributeDefined(builder, element, EXCLUSIVE_ATTRIBUTE, false);
NamespaceUtils.AddConstructorArgBooleanValueIfAttributeDefined(builder, element, AUTO_DELETE_ATTRIBUTE, false);
}
var queueArguments = element.GetAttribute(ARGUMENTS);
var argumentsElement = element.SelectChildElementByTagName(ARGUMENTS);
if (argumentsElement != null)
{
var parser = new ObjectDefinitionParserHelper(parserContext);
if (!string.IsNullOrWhiteSpace(queueArguments))
{
parserContext.ReaderContext.ReportFatalException(element, "Queue may have either a queue-attributes attribute or element, but not both");
}
var map = parser.ParseMapElement(argumentsElement, builder.RawObjectDefinition);
builder.AddConstructorArg(map);
}
if (!string.IsNullOrWhiteSpace(queueArguments))
{
builder.AddConstructorArgReference(queueArguments);
}
}
