You've already forked linux-packaging-mono
342 lines
13 KiB
C#
342 lines
13 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="XmlSchemaElement.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
// <owner current="true" primary="true">Microsoft</owner>
|
|
//------------------------------------------------------------------------------
|
|
|
|
using System.ComponentModel;
|
|
using System.Xml.Serialization;
|
|
using System.Diagnostics;
|
|
|
|
namespace System.Xml.Schema {
|
|
|
|
|
|
/// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
public class XmlSchemaElement : XmlSchemaParticle {
|
|
bool isAbstract;
|
|
bool hasAbstractAttribute;
|
|
bool isNillable;
|
|
bool hasNillableAttribute;
|
|
bool isLocalTypeDerivationChecked;
|
|
|
|
XmlSchemaDerivationMethod block = XmlSchemaDerivationMethod.None;
|
|
XmlSchemaDerivationMethod final = XmlSchemaDerivationMethod.None;
|
|
XmlSchemaForm form = XmlSchemaForm.None;
|
|
string defaultValue;
|
|
string fixedValue;
|
|
string name;
|
|
|
|
XmlQualifiedName refName = XmlQualifiedName.Empty;
|
|
XmlQualifiedName substitutionGroup = XmlQualifiedName.Empty;
|
|
XmlQualifiedName typeName = XmlQualifiedName.Empty;
|
|
XmlSchemaType type = null;
|
|
|
|
XmlQualifiedName qualifiedName = XmlQualifiedName.Empty;
|
|
XmlSchemaType elementType;
|
|
XmlSchemaDerivationMethod blockResolved;
|
|
XmlSchemaDerivationMethod finalResolved;
|
|
XmlSchemaObjectCollection constraints;
|
|
SchemaElementDecl elementDecl;
|
|
|
|
|
|
/// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.IsAbstract"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[XmlAttribute("abstract"), DefaultValue(false)]
|
|
public bool IsAbstract {
|
|
get { return isAbstract; }
|
|
set {
|
|
isAbstract = value;
|
|
hasAbstractAttribute = true;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.Block"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[XmlAttribute("block"), DefaultValue(XmlSchemaDerivationMethod.None)]
|
|
public XmlSchemaDerivationMethod Block {
|
|
get { return block; }
|
|
set { block = value; }
|
|
}
|
|
|
|
/// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.DefaultValue"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[XmlAttribute("default")]
|
|
[DefaultValue(null)]
|
|
public string DefaultValue {
|
|
get { return defaultValue; }
|
|
set { defaultValue = value; }
|
|
}
|
|
|
|
/// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.Final"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[XmlAttribute("final"), DefaultValue(XmlSchemaDerivationMethod.None)]
|
|
public XmlSchemaDerivationMethod Final {
|
|
get { return final; }
|
|
set { final = value; }
|
|
}
|
|
|
|
/// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.FixedValue"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[XmlAttribute("fixed")]
|
|
[DefaultValue(null)]
|
|
public string FixedValue {
|
|
get { return fixedValue; }
|
|
set { fixedValue = value; }
|
|
}
|
|
|
|
/// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.Form"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[XmlAttribute("form"), DefaultValue(XmlSchemaForm.None)]
|
|
public XmlSchemaForm Form {
|
|
get { return form; }
|
|
set { form = value; }
|
|
}
|
|
|
|
/// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.Name"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[XmlAttribute("name"), DefaultValue("")]
|
|
public string Name {
|
|
get { return name; }
|
|
set { name = value; }
|
|
}
|
|
|
|
/// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.IsNillable"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[XmlAttribute("nillable"), DefaultValue(false)]
|
|
public bool IsNillable {
|
|
get { return isNillable; }
|
|
set { isNillable = value; hasNillableAttribute = true; }
|
|
}
|
|
|
|
[XmlIgnore]
|
|
internal bool HasNillableAttribute {
|
|
get { return hasNillableAttribute; }
|
|
}
|
|
|
|
[XmlIgnore]
|
|
internal bool HasAbstractAttribute {
|
|
get { return hasAbstractAttribute; }
|
|
}
|
|
/// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.RefName"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[XmlAttribute("ref")]
|
|
public XmlQualifiedName RefName {
|
|
get { return refName; }
|
|
set { refName = (value == null ? XmlQualifiedName.Empty : value); }
|
|
}
|
|
|
|
/// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.SubstitutionGroup"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[XmlAttribute("substitutionGroup")]
|
|
public XmlQualifiedName SubstitutionGroup {
|
|
get { return substitutionGroup; }
|
|
set { substitutionGroup = (value == null ? XmlQualifiedName.Empty : value); }
|
|
}
|
|
|
|
/// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.SchemaTypeName"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[XmlAttribute("type")]
|
|
public XmlQualifiedName SchemaTypeName {
|
|
get { return typeName; }
|
|
set { typeName = (value == null ? XmlQualifiedName.Empty : value); }
|
|
}
|
|
|
|
/// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.SchemaType"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[XmlElement("complexType", typeof(XmlSchemaComplexType)),
|
|
XmlElement("simpleType", typeof(XmlSchemaSimpleType))]
|
|
public XmlSchemaType SchemaType {
|
|
get { return type; }
|
|
set { type = value; }
|
|
}
|
|
|
|
/// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.Constraints"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[XmlElement("key", typeof(XmlSchemaKey)),
|
|
XmlElement("keyref", typeof(XmlSchemaKeyref)),
|
|
XmlElement("unique", typeof(XmlSchemaUnique))]
|
|
public XmlSchemaObjectCollection Constraints {
|
|
get {
|
|
if (constraints == null) {
|
|
constraints = new XmlSchemaObjectCollection();
|
|
}
|
|
return constraints;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.QualifiedName"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[XmlIgnore]
|
|
public XmlQualifiedName QualifiedName {
|
|
get { return qualifiedName; }
|
|
}
|
|
|
|
/// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.ElementType"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[XmlIgnore]
|
|
[Obsolete("This property has been deprecated. Please use ElementSchemaType property that returns a strongly typed element type. http://go.microsoft.com/fwlink/?linkid=14202")]
|
|
public object ElementType {
|
|
get {
|
|
if (elementType == null)
|
|
return null;
|
|
|
|
if (elementType.QualifiedName.Namespace == XmlReservedNs.NsXs) {
|
|
return elementType.Datatype; //returns XmlSchemaDatatype;
|
|
}
|
|
return elementType;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.ElementType"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[XmlIgnore]
|
|
public XmlSchemaType ElementSchemaType {
|
|
get { return elementType; }
|
|
}
|
|
|
|
/// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.BlockResolved"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[XmlIgnore]
|
|
public XmlSchemaDerivationMethod BlockResolved {
|
|
get { return blockResolved; }
|
|
}
|
|
|
|
/// <include file='doc\XmlSchemaElement.uex' path='docs/doc[@for="XmlSchemaElement.FinalResolved"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
[XmlIgnore]
|
|
public XmlSchemaDerivationMethod FinalResolved {
|
|
get { return finalResolved; }
|
|
}
|
|
|
|
internal XmlReader Validate(XmlReader reader, XmlResolver resolver, XmlSchemaSet schemaSet , ValidationEventHandler valEventHandler) {
|
|
if (schemaSet != null) {
|
|
XmlReaderSettings readerSettings = new XmlReaderSettings();
|
|
readerSettings.ValidationType = ValidationType.Schema;
|
|
readerSettings.Schemas = schemaSet;
|
|
readerSettings.ValidationEventHandler += valEventHandler;
|
|
return new XsdValidatingReader(reader, resolver, readerSettings, this);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
internal void SetQualifiedName(XmlQualifiedName value) {
|
|
qualifiedName = value;
|
|
}
|
|
|
|
internal void SetElementType(XmlSchemaType value) {
|
|
elementType = value;
|
|
}
|
|
|
|
internal void SetBlockResolved(XmlSchemaDerivationMethod value) {
|
|
blockResolved = value;
|
|
}
|
|
|
|
internal void SetFinalResolved(XmlSchemaDerivationMethod value) {
|
|
finalResolved = value;
|
|
}
|
|
|
|
[XmlIgnore]
|
|
internal bool HasDefault {
|
|
get { return defaultValue != null && defaultValue.Length > 0; }
|
|
}
|
|
|
|
internal bool HasConstraints {
|
|
get { return constraints != null && constraints.Count > 0; }
|
|
}
|
|
|
|
internal bool IsLocalTypeDerivationChecked {
|
|
get {
|
|
return isLocalTypeDerivationChecked;
|
|
}
|
|
set {
|
|
isLocalTypeDerivationChecked = value;
|
|
}
|
|
}
|
|
|
|
internal SchemaElementDecl ElementDecl {
|
|
get { return elementDecl; }
|
|
set { elementDecl = value; }
|
|
}
|
|
|
|
[XmlIgnore]
|
|
internal override string NameAttribute {
|
|
get { return Name; }
|
|
set { Name = value; }
|
|
}
|
|
|
|
[XmlIgnore]
|
|
internal override string NameString {
|
|
get {
|
|
return qualifiedName.ToString();
|
|
}
|
|
}
|
|
|
|
internal override XmlSchemaObject Clone() {
|
|
System.Diagnostics.Debug.Assert(false, "Should never call Clone() on XmlSchemaElement. Call Clone(XmlSchema) instead.");
|
|
return Clone(null);
|
|
}
|
|
|
|
internal XmlSchemaObject Clone(XmlSchema parentSchema) {
|
|
XmlSchemaElement newElem = (XmlSchemaElement)MemberwiseClone();
|
|
|
|
//Deep clone the QNames as these will be updated on chameleon includes
|
|
newElem.refName = this.refName.Clone();
|
|
newElem.substitutionGroup = this.substitutionGroup.Clone();
|
|
newElem.typeName = this.typeName.Clone();
|
|
newElem.qualifiedName = this.qualifiedName.Clone();
|
|
// If this element has a complex type which is anonymous (declared in place with the element)
|
|
// it needs to be cloned as well, since it may contain named elements and such. And these names
|
|
// will need to be cloned since they may change their namespace on chameleon includes
|
|
XmlSchemaComplexType complexType = this.type as XmlSchemaComplexType;
|
|
if (complexType != null && complexType.QualifiedName.IsEmpty) {
|
|
newElem.type = (XmlSchemaType)complexType.Clone(parentSchema);
|
|
}
|
|
|
|
//Clear compiled tables
|
|
newElem.constraints = null;
|
|
return newElem;
|
|
}
|
|
}
|
|
}
|
|
|