/// <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 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> /// 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="Oragon.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); } }
/// <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="Oragon.Spring.Objects.Factory.Support.ObjectDefinitionReaderUtils.RegisterObjectDefinition"/> protected virtual void RegisterObjectDefinition(XmlElement element, ObjectDefinitionParserHelper helper) { ProcessObjectDefinition(element, helper); }
/// <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; }