/// <summary> /// Copies the <see cref='QualifiedNameCollection'/> values to a one-dimensional <see cref='Array'/> instance at the /// specified index. /// </summary> /// <param name='array'>The one-dimensional <see cref='Array'/> that is the destination of the values copied from <see cref='QualifiedNameCollection'/>.</param> /// <param name='index'>The index in <paramref name='array'/> where copying begins.</param> /// <exception cref='ArgumentException'> /// <para><paramref name='array'/> is multidimensional.</para> /// <para>-or-</para> /// <para>The number of elements in the <see cref='QualifiedNameCollection'/> is greater than /// the available space between <paramref name='index'/> and the end of /// <paramref name='array'/>.</para> /// </exception> /// <exception cref='ArgumentNullException'><paramref name='array'/> is <see langword='null'/>. </exception> /// <exception cref='ArgumentOutOfRangeException'><paramref name='index'/> is less than <paramref name='array'/>'s lowbound. </exception> /// <seealso cref='Array'/> public void CopyTo(QualifiedName[] array, int index) { List.CopyTo(array, index); }
/// <summary> /// Copies the elements of an array to the end of the <see cref='QualifiedNameCollection'/>. /// </summary> /// <param name='val'> /// An array of type <see cref='QualifiedName'/> containing the objects to add to the collection. /// </param> /// <seealso cref='QualifiedNameCollection.Add'/> public void AddRange(QualifiedName[] val) { for (int i = 0; i < val.Length; i++) { this.Add(val[i]); } }
/// <summary> /// Gets a value indicating whether the /// <see cref='QualifiedNameCollection'/> contains the specified <see cref='QualifiedName'/>. /// </summary> /// <param name='val'>The <see cref='QualifiedName'/> to locate.</param> /// <returns> /// <see langword='true'/> if the <see cref='QualifiedName'/> is contained in the collection; /// otherwise, <see langword='false'/>. /// </returns> /// <seealso cref='QualifiedNameCollection.IndexOf'/> public bool Contains(QualifiedName val) { return List.Contains(val); }
XmlSchemaElement FindElement(XmlSchemaGroupRef groupRef, QualifiedName name) { XmlSchemaElement matchedElement = null; XmlSchemaGroup group = FindGroup(groupRef.RefName.Name); if (group != null) { XmlSchemaSequence sequence = group.Particle as XmlSchemaSequence; XmlSchemaChoice choice = group.Particle as XmlSchemaChoice; if (sequence != null) { matchedElement = FindElement(sequence.Items, name); } else if (choice != null) { matchedElement = FindElement(choice.Items, name); } } return matchedElement; }
/// <summary> /// Adds a <see cref='QualifiedName'/> with the specified value to the /// <see cref='QualifiedNameCollection'/>. /// </summary> /// <param name='val'>The <see cref='QualifiedName'/> to add.</param> /// <returns>The index at which the new element was inserted.</returns> public int Add(QualifiedName val) { return List.Add(val); }
/// <summary> /// Removes a specific <see cref='QualifiedName'/> from the <see cref='QualifiedNameCollection'/>. /// </summary> /// <param name='val'>The <see cref='QualifiedName'/> to remove from the <see cref='QualifiedNameCollection'/>.</param> /// <exception cref='ArgumentException'><paramref name='val'/> is not found in the Collection.</exception> public void Remove(QualifiedName val) { List.Remove(val); }
/// <summary> /// Gets the parent element path based on the index position. This /// method does not compact the path so it will include all elements /// including those in another namespace in the path. /// </summary> static XmlElementPath GetFullParentElementPath(string xml, QualifiedNameCollection namespaces) { XmlElementPath path = new XmlElementPath(); IDictionary<string, string> namespacesInScope = null; using (StringReader reader = new StringReader(xml)) { using (XmlTextReader xmlReader = new XmlTextReader(reader)) { try { xmlReader.XmlResolver = null; // prevent XmlTextReader from loading external DTDs while (xmlReader.Read()) { switch (xmlReader.NodeType) { case XmlNodeType.Element: if (!xmlReader.IsEmptyElement) { QualifiedName elementName = new QualifiedName(xmlReader.LocalName, xmlReader.NamespaceURI, xmlReader.Prefix); path.Elements.Add(elementName); } break; case XmlNodeType.EndElement: path.Elements.RemoveLast(); break; } } } catch (XmlException) { namespacesInScope = xmlReader.GetNamespacesInScope(XmlNamespaceScope.All); } } } // Add namespaces in scope for the last element read. if (namespacesInScope != null) { foreach (KeyValuePair<string, string> ns in namespacesInScope) { namespaces.Add(new QualifiedName(String.Empty, ns.Value, ns.Key)); } } return path; }
XmlSchemaElement FindChildElement(XmlSchemaComplexType complexType, QualifiedName name) { XmlSchemaElement matchedElement = null; XmlSchemaSequence sequence = complexType.Particle as XmlSchemaSequence; XmlSchemaChoice choice = complexType.Particle as XmlSchemaChoice; XmlSchemaGroupRef groupRef = complexType.Particle as XmlSchemaGroupRef; XmlSchemaAll all = complexType.Particle as XmlSchemaAll; XmlSchemaComplexContent complexContent = complexType.ContentModel as XmlSchemaComplexContent; if (sequence != null) { matchedElement = FindElement(sequence.Items, name); } else if (choice != null) { matchedElement = FindElement(choice.Items, name); } else if (complexContent != null) { XmlSchemaComplexContentExtension extension = complexContent.Content as XmlSchemaComplexContentExtension; XmlSchemaComplexContentRestriction restriction = complexContent.Content as XmlSchemaComplexContentRestriction; if (extension != null) { matchedElement = FindChildElement(extension, name); } else if (restriction != null) { matchedElement = FindChildElement(restriction, name); } } else if (groupRef != null) { matchedElement = FindElement(groupRef, name); } else if (all != null) { matchedElement = FindElement(all.Items, name); } return matchedElement; }
/// <summary> /// Finds the named child element contained in the extension element. /// </summary> XmlSchemaElement FindChildElement(XmlSchemaComplexContentExtension extension, QualifiedName name) { XmlSchemaElement matchedElement = null; XmlSchemaComplexType complexType = FindNamedType(schema, extension.BaseTypeName); if (complexType != null) { matchedElement = FindChildElement(complexType, name); if (matchedElement == null) { XmlSchemaSequence sequence = extension.Particle as XmlSchemaSequence; XmlSchemaChoice choice = extension.Particle as XmlSchemaChoice; XmlSchemaGroupRef groupRef = extension.Particle as XmlSchemaGroupRef; if (sequence != null) { matchedElement = FindElement(sequence.Items, name); } else if (choice != null) { matchedElement = FindElement(choice.Items, name); } else if (groupRef != null) { matchedElement = FindElement(groupRef, name); } } } return matchedElement; }
/// <summary> /// Finds an element in the schema. /// </summary> /// <remarks> /// Only looks at the elements that are defined in the /// root of the schema so it will not find any elements /// that are defined inside any complex types. /// </remarks> public XmlSchemaElement FindElement(QualifiedName name) { foreach (XmlSchemaElement element in schema.Elements.Values) { if (name.Equals(element.QualifiedName)) { return element; } } return null; }
/// <summary> /// Finds an element that matches the specified <paramref name="name"/> /// from the children of the given <paramref name="element"/>. /// </summary> XmlSchemaElement FindChildElement(XmlSchemaElement element, QualifiedName name) { XmlSchemaElement matchedElement = null; XmlSchemaComplexType complexType = GetElementAsComplexType(element); if (complexType != null) { matchedElement = FindChildElement(complexType, name); } return matchedElement; }
/// <summary> /// Finds the complex type with the specified name. /// </summary> public XmlSchemaComplexType FindComplexType(QualifiedName name) { XmlQualifiedName qualifiedName = new XmlQualifiedName(name.Name, name.Namespace); return FindNamedType(schema, qualifiedName); }
/// <summary> /// Looks for the substitution group element of the specified name. /// </summary> XmlSchemaElement FindSubstitutionGroupElement(XmlQualifiedName group, QualifiedName name) { XmlSchemaElement matchedElement = null; foreach (XmlSchemaElement element in schema.Elements.Values) { if (element.SubstitutionGroup == group) { if (element.Name != null) { if (element.Name == name.Name) { matchedElement = element; break; } } } } return matchedElement; }
/// <summary> /// Returns a name and its prefix. /// </summary> static QualifiedName GetQualifiedName(string name) { if (name.Length == 0) { return null; } QualifiedName qualifiedName = new QualifiedName(); int prefixIndex = name.IndexOf(':'); if (prefixIndex > 0) { qualifiedName.Prefix = name.Substring(0, prefixIndex); qualifiedName.Name = name.Substring(prefixIndex + 1); } else { qualifiedName.Name = name; } return qualifiedName; }
/// <summary> /// Returns the index of a <see cref='QualifiedName'/> in /// the <see cref='QualifiedNameCollection'/>. /// </summary> /// <param name='val'>The <see cref='QualifiedName'/> to locate.</param> /// <returns> /// The index of the <see cref='QualifiedName'/> of <paramref name='val'/> in the /// <see cref='QualifiedNameCollection'/>, if found; otherwise, -1. /// </returns> /// <seealso cref='QualifiedNameCollection.Contains'/> public int IndexOf(QualifiedName val) { return List.IndexOf(val); }
/// <summary> /// Finds the named child element contained in the restriction element. /// </summary> XmlSchemaElement FindChildElement(XmlSchemaComplexContentRestriction restriction, QualifiedName name) { XmlSchemaElement matchedElement = null; XmlSchemaSequence sequence = restriction.Particle as XmlSchemaSequence; XmlSchemaGroupRef groupRef = restriction.Particle as XmlSchemaGroupRef; if (sequence != null) { matchedElement = FindElement(sequence.Items, name); } else if (groupRef != null) { matchedElement = FindElement(groupRef, name); } return matchedElement; }
/// <summary> /// Inserts a <see cref='QualifiedName'/> into the <see cref='QualifiedNameCollection'/> at the specified index. /// </summary> /// <param name='index'>The zero-based index where <paramref name='val'/> should be inserted.</param> /// <param name='val'>The <see cref='QualifiedName'/> to insert.</param> /// <seealso cref='QualifiedNameCollection.Add'/> public void Insert(int index, QualifiedName val) { List.Insert(index, val); }
/// <summary> /// Finds the element in the collection of schema objects. /// </summary> XmlSchemaElement FindElement(XmlSchemaObjectCollection items, QualifiedName name) { XmlSchemaElement matchedElement = null; foreach (XmlSchemaObject schemaObject in items) { XmlSchemaElement element = schemaObject as XmlSchemaElement; XmlSchemaSequence sequence = schemaObject as XmlSchemaSequence; XmlSchemaChoice choice = schemaObject as XmlSchemaChoice; XmlSchemaGroupRef groupRef = schemaObject as XmlSchemaGroupRef; if (element != null) { if (element.Name != null) { if (name.Name == element.Name) { matchedElement = element; } } else if (element.RefName != null) { if (name.Name == element.RefName.Name) { matchedElement = FindElement(element.RefName); } else { // Abstract element? XmlSchemaElement abstractElement = FindElement(element.RefName); if (abstractElement != null && abstractElement.IsAbstract) { matchedElement = FindSubstitutionGroupElement(abstractElement.QualifiedName, name); } } } } else if (sequence != null) { matchedElement = FindElement(sequence.Items, name); } else if (choice != null) { matchedElement = FindElement(choice.Items, name); } else if (groupRef != null) { matchedElement = FindElement(groupRef, name); } // Did we find a match? if (matchedElement != null) { break; } } return matchedElement; }
/// <summary> /// Initializes a new instance of <see cref='QualifiedNameCollection'/> containing any array of <see cref='QualifiedName'/> objects. /// </summary> /// <param name='val'> /// A array of <see cref='QualifiedName'/> objects with which to intialize the collection /// </param> public QualifiedNameCollection(QualifiedName[] val) { this.AddRange(val); }
/// <summary> /// Returns the qualified name as a string. If the name has a /// prefix then it returns "prefix:element" otherwise it returns /// just the element name. /// </summary> static string GetElementToString(QualifiedName name) { if (name.Prefix.Length > 0) { return name.Prefix + ":" + name.Name; } return name.Name; }