//
// System.Xml.Schema.XmlSchemaSimpleType.cs
//
// Author:
// Dwivedi, Ajay kumar Adwiv@Yahoo.com
// Atsushi Enomoto ginga@kit.hi-ho.ne.jp
//
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Xml.Serialization;
using System.Xml;
using Mono.Xml.Schema;
namespace System.Xml.Schema{
/// <summary>
/// Summary description for XmlSchemaSimpleType.
/// </summary>
public class XmlSchemaSimpleType : XmlSchemaType
{
const string xmlname = "simpleType";
private static XmlSchemaSimpleType schemaLocationType;
private XmlSchemaSimpleTypeContent content;
//compilation vars
internal bool islocal = true; // Assuming local means we have to specify islocal=false only in XmlSchema
private bool recursed;
private XmlSchemaDerivationMethod variety;
#if NET_2_0
// predefined simple types
internal static readonly XmlSchemaSimpleType XsAnySimpleType;
internal static readonly XmlSchemaSimpleType XsString;
internal static readonly XmlSchemaSimpleType XsBoolean;
internal static readonly XmlSchemaSimpleType XsDecimal;
internal static readonly XmlSchemaSimpleType XsFloat;
internal static readonly XmlSchemaSimpleType XsDouble;
internal static readonly XmlSchemaSimpleType XsDuration;
internal static readonly XmlSchemaSimpleType XsDateTime;
internal static readonly XmlSchemaSimpleType XsTime;
internal static readonly XmlSchemaSimpleType XsDate;
internal static readonly XmlSchemaSimpleType XsGYearMonth;
internal static readonly XmlSchemaSimpleType XsGYear;
internal static readonly XmlSchemaSimpleType XsGMonthDay;
internal static readonly XmlSchemaSimpleType XsGDay;
internal static readonly XmlSchemaSimpleType XsGMonth;
internal static readonly XmlSchemaSimpleType XsHexBinary;
internal static readonly XmlSchemaSimpleType XsBase64Binary;
internal static readonly XmlSchemaSimpleType XsAnyUri;
internal static readonly XmlSchemaSimpleType XsQName;
internal static readonly XmlSchemaSimpleType XsNotation;
internal static readonly XmlSchemaSimpleType XsNormalizedString;
internal static readonly XmlSchemaSimpleType XsToken;
internal static readonly XmlSchemaSimpleType XsLanguage;
internal static readonly XmlSchemaSimpleType XsNMToken;
internal static readonly XmlSchemaSimpleType XsNMTokens;
internal static readonly XmlSchemaSimpleType XsName;
internal static readonly XmlSchemaSimpleType XsNCName;
internal static readonly XmlSchemaSimpleType XsID;
internal static readonly XmlSchemaSimpleType XsIDRef;
internal static readonly XmlSchemaSimpleType XsIDRefs;
internal static readonly XmlSchemaSimpleType XsEntity;
internal static readonly XmlSchemaSimpleType XsEntities;
internal static readonly XmlSchemaSimpleType XsInteger;
internal static readonly XmlSchemaSimpleType XsNonPositiveInteger;
internal static readonly XmlSchemaSimpleType XsNegativeInteger;
internal static readonly XmlSchemaSimpleType XsLong;
internal static readonly XmlSchemaSimpleType XsInt;
internal static readonly XmlSchemaSimpleType XsShort;
internal static readonly XmlSchemaSimpleType XsByte;
internal static readonly XmlSchemaSimpleType XsNonNegativeInteger;
internal static readonly XmlSchemaSimpleType XsUnsignedLong;
internal static readonly XmlSchemaSimpleType XsUnsignedInt;
internal static readonly XmlSchemaSimpleType XsUnsignedShort;
internal static readonly XmlSchemaSimpleType XsUnsignedByte;
internal static readonly XmlSchemaSimpleType XsPositiveInteger;
// xdt:*
internal static readonly XmlSchemaSimpleType XdtUntypedAtomic;
internal static readonly XmlSchemaSimpleType XdtAnyAtomicType;
internal static readonly XmlSchemaSimpleType XdtYearMonthDuration;
internal static readonly XmlSchemaSimpleType XdtDayTimeDuration;
#endif
static XmlSchemaSimpleType ()
{
// This is not used in the meantime.
XmlSchemaSimpleType st = new XmlSchemaSimpleType ();
XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList ();
list.ItemTypeName = new XmlQualifiedName ("anyURI", XmlSchema.Namespace);
st.Content = list;
st.BaseXmlSchemaTypeInternal = null;
st.variety = XmlSchemaDerivationMethod.List;
schemaLocationType = st;
#if NET_2_0
// Built-In schema types
XsAnySimpleType = BuildSchemaType ("anySimpleType", null);
XsString = BuildSchemaType ("string", "anySimpleType");
XsBoolean = BuildSchemaType ("boolean", "anySimpleType");
XsDecimal = BuildSchemaType ("decimal", "anySimpleType");
XsFloat = BuildSchemaType ("float", "anySimpleType");
XsDouble = BuildSchemaType ("double", "anySimpleType");
XsDuration = BuildSchemaType ("duration", "anySimpleType");
XsDateTime = BuildSchemaType ("dateTime", "anySimpleType");
XsTime = BuildSchemaType ("time", "anySimpleType");
XsDate = BuildSchemaType ("date", "anySimpleType");
XsGYearMonth = BuildSchemaType ("gYearMonth", "anySimpleType");
XsGYear = BuildSchemaType ("gYear", "anySimpleType");
XsGMonthDay = BuildSchemaType ("gMonthDay", "anySimpleType");
XsGDay = BuildSchemaType ("gDay", "anySimpleType");
XsGMonth = BuildSchemaType ("gMonth", "anySimpleType");
XsHexBinary = BuildSchemaType ("hexBinary", "anySimpleType");
XsBase64Binary = BuildSchemaType ("base64Binary", "anySimpleType");
XsAnyUri = BuildSchemaType ("anyURI", "anySimpleType");
XsQName = BuildSchemaType ("QName", "anySimpleType");
XsNotation = BuildSchemaType ("NOTATION", "anySimpleType");
// derived types
XsNormalizedString = BuildSchemaType ("normalizedString", "string");
XsToken = BuildSchemaType ("token", "normalizedString");
XsLanguage = BuildSchemaType ("language", "token");
XsNMToken = BuildSchemaType ("NMTOKEN", "token");
XsName = BuildSchemaType ("Name", "token");
XsNCName = BuildSchemaType ("NCName", "Name");
XsID = BuildSchemaType ("ID", "NCName");
XsIDRef = BuildSchemaType ("IDREF", "NCName");
XsEntity = BuildSchemaType ("ENTITY", "NCName");
XsInteger = BuildSchemaType ("integer", "decimal");
XsNonPositiveInteger = BuildSchemaType ("nonPositiveInteger", "integer");
XsNegativeInteger = BuildSchemaType ("negativeInteger", "nonPositiveInteger");
XsLong = BuildSchemaType ("long", "integer");
XsInt = BuildSchemaType ("int", "long");
XsShort = BuildSchemaType ("short", "int");
XsByte = BuildSchemaType ("byte", "short");
XsNonNegativeInteger = BuildSchemaType ("nonNegativeInteger", "integer");
XsUnsignedLong = BuildSchemaType ("unsignedLong", "nonNegativeInteger");
XsUnsignedInt = BuildSchemaType ("unsignedInt", "unsignedLong");
XsUnsignedShort = BuildSchemaType ("unsignedShort", "unsignedInt");
XsUnsignedByte = BuildSchemaType ("unsignedByte", "unsignedShort");
XsPositiveInteger = BuildSchemaType ("positiveInteger", "nonNegativeInteger");
// xdt:*
XdtAnyAtomicType = BuildSchemaType ("anyAtomicType", "anySimpleType", true, false);
XdtUntypedAtomic = BuildSchemaType ("untypedAtomic", "anyAtomicType", true, true);
XdtDayTimeDuration = BuildSchemaType ("dayTimeDuration", "duration", true, false);
XdtYearMonthDuration = BuildSchemaType ("yearMonthDuration", "duration", true, false);
// NMTOKENS, IDREFS, ENTITIES - lists
XsIDRefs = new XmlSchemaSimpleType ();
XmlSchemaSimpleTypeList sl = new XmlSchemaSimpleTypeList ();
sl.ItemType = XsIDRef;
XsIDRefs.Content = sl;
XsEntities = new XmlSchemaSimpleType ();
sl = new XmlSchemaSimpleTypeList ();
sl.ItemType = XsEntity;
XsEntities.Content = sl;
XsNMTokens = new XmlSchemaSimpleType ();
sl = new XmlSchemaSimpleTypeList ();
sl.ItemType = XsNMToken;
XsNMTokens.Content = sl;
#endif
}
#if NET_2_0
private static XmlSchemaSimpleType BuildSchemaType (string name, string baseName)
{
return BuildSchemaType (name, baseName, false, false);
}
private static XmlSchemaSimpleType BuildSchemaType (string name, string baseName, bool xdt, bool baseXdt)
{
string ns = xdt ? "http://www.w3.org/2003/11/xpath-datatypes" : XmlSchema.Namespace;
string ns2 = baseXdt ? "http://www.w3.org/2003/11/xpath-datatypes" : XmlSchema.Namespace;
XmlSchemaSimpleType st = new XmlSchemaSimpleType ();
st.QNameInternal = new XmlQualifiedName (name, ns);
if (baseName != null)
st.BaseXmlSchemaTypeInternal = XmlSchemaType. GetBuiltInSimpleType (new XmlQualifiedName (baseName, ns2));
st.DatatypeInternal = XmlSchemaDatatype.FromName (st.QualifiedName);
return st;
}
#endif
internal static XsdAnySimpleType AnySimpleType {
get { return XsdAnySimpleType.Instance; }
}
internal static XmlSchemaSimpleType SchemaLocationType {
get { return schemaLocationType; }
}
public XmlSchemaSimpleType ()
{
}
[XmlElement("restriction",typeof(XmlSchemaSimpleTypeRestriction))]
[XmlElement("list",typeof(XmlSchemaSimpleTypeList))]
[XmlElement("union",typeof(XmlSchemaSimpleTypeUnion))]
public XmlSchemaSimpleTypeContent Content
{
get{ return content; }
set{ content = value; }
}
internal XmlSchemaDerivationMethod Variety
{
get{ return variety; }
}
internal override void SetParent (XmlSchemaObject parent)
{
base.SetParent (parent);
if (Content != null)
Content.SetParent (this);
}
/// <remarks>
/// For a simple Type:
/// 1. Content must be present
/// 2. id if present, must have be a valid ID
/// a) If the simpletype is local
/// 1- are from <xs:complexType name="simpleType"> and <xs:complexType name="localSimpleType">
/// 1. name is prohibited
/// 2. final is prohibited
/// b) If the simpletype is toplevel
/// 1- are from <xs:complexType name="simpleType"> and <xs:complexType name="topLevelSimpleType">
/// 1. name is required, type must be NCName
/// 2. Content is required
/// 3. final can have values : #all | (list | union | restriction)
/// 4. If final is set, finalResolved is same as final (but within the values of b.3)
/// 5. If final is not set, the finalDefault of the schema (ie. only #all and restriction)
/// 6. Base type is:
/// 4.1 If restriction is chosen,the base type of restriction or elements
/// 4.2 otherwise simple ur-type
/// </remarks>
internal override int Compile(ValidationEventHandler h, XmlSchema schema)
{
// If this is already compiled this time, simply skip.
if (CompilationId == schema.CompilationId)
return 0;
errorCount = 0;
if(this.islocal) // a
{
if(this.Name != null) // a.1
error(h,"Name is prohibited in a local simpletype");
else
this.QNameInternal = new XmlQualifiedName(this.Name, AncestorSchema.TargetNamespace);
if(this.Final != XmlSchemaDerivationMethod.None) //a.2
error(h,"Final is prohibited in a local simpletype");
}
else //b
{
if(this.Name == null) //b.1
error(h,"Name is required in top level simpletype");
else if(!XmlSchemaUtil.CheckNCName(this.Name)) // b.1.2
error(h,"name attribute of a simpleType must be NCName");
else
this.QNameInternal = new XmlQualifiedName(this.Name, AncestorSchema.TargetNamespace);
//NOTE: Although the FinalResolved can be Empty, it is not a valid value for Final
//DEVIATION: If an error occurs, the finaldefault is always consulted. This deviates
// from the way MS implementation works.
switch(this.Final) //b.3, b.4
{
case XmlSchemaDerivationMethod.All:
this.finalResolved = XmlSchemaDerivationMethod.All;
break;
case XmlSchemaDerivationMethod.List:
case XmlSchemaDerivationMethod.Union:
case XmlSchemaDerivationMethod.Restriction:
this.finalResolved = Final;
break;
default:
error(h,"The value of final attribute is not valid for simpleType");
goto case XmlSchemaDerivationMethod.None;
// use assignment from finaldefault on schema.
case XmlSchemaDerivationMethod.None: // b.5
XmlSchemaDerivationMethod flags =
(XmlSchemaDerivationMethod.Restriction | XmlSchemaDerivationMethod.List |
XmlSchemaDerivationMethod.Extension | XmlSchemaDerivationMethod.Union );
switch (schema.FinalDefault) {
case XmlSchemaDerivationMethod.All:
finalResolved = XmlSchemaDerivationMethod.All;
break;
case XmlSchemaDerivationMethod.None:
finalResolved = XmlSchemaDerivationMethod.Empty;
break;
default:
finalResolved = schema.FinalDefault & flags;
break;
}
break;
}
}
XmlSchemaUtil.CompileID(Id,this,schema.IDCollection,h);
if (Content != null)
Content.OwnerType = this;
if(this.Content == null) //a.3,b.2
error(h,"Content is required in a simpletype");
else if(Content is XmlSchemaSimpleTypeRestriction)
{
this.resolvedDerivedBy = XmlSchemaDerivationMethod.Restriction;
errorCount += ((XmlSchemaSimpleTypeRestriction)Content).Compile(h,schema);
}
else if(Content is XmlSchemaSimpleTypeList)
{
this.resolvedDerivedBy = XmlSchemaDerivationMethod.List;
errorCount += ((XmlSchemaSimpleTypeList)Content).Compile(h,schema);
}
else if(Content is XmlSchemaSimpleTypeUnion)
{
this.resolvedDerivedBy = XmlSchemaDerivationMethod.Union;
errorCount += ((XmlSchemaSimpleTypeUnion)Content).Compile(h,schema);
}
this.CompilationId = schema.CompilationId;
return errorCount;
}
internal void CollectBaseType (ValidationEventHandler h, XmlSchema schema)
{
if (Content is XmlSchemaSimpleTypeRestriction) {
object o = ((XmlSchemaSimpleTypeRestriction) Content).GetActualType (h, schema, false);
BaseXmlSchemaTypeInternal = o as XmlSchemaSimpleType;
if (BaseXmlSchemaTypeInternal != null)
DatatypeInternal = BaseXmlSchemaTypeInternal.Datatype;
else
DatatypeInternal = o as XmlSchemaDatatype;
}
// otherwise, actualBaseSchemaType is null
else
DatatypeInternal = XmlSchemaSimpleType.AnySimpleType;
}
internal override int Validate(ValidationEventHandler h, XmlSchema schema)
{
// 3.14.6 Properties Correct.
//
// 1. Post Compilation Properties
// {name}, {target namespace} => QNameInternal. Already Compile()d.
// {base type definition} => baseSchemaTypeInternal
// {final} => finalResolved. Already Compile()d.
// {variety} => resolvedDerivedBy. Already Compile()d.
//
// 2. Should be checked by "recursed" field.
if(IsValidated (schema.ValidationId))
return errorCount;
if (recursed) {
error (h, "Circular type reference was found.");
return errorCount;
}
recursed = true;
CollectBaseType (h, schema);
if (content != null)
errorCount += content.Validate (h, schema);
/*
// BaseSchemaType property
BaseXmlSchemaTypeInternal = content.ActualBaseSchemaType as XmlSchemaType;
if (this.BaseXmlSchemaTypeInternal == null)
this.DatatypeInternal = content.ActualBaseSchemaType as XmlSchemaDatatype;
*/
// Datatype property
XmlSchemaSimpleType simple = BaseXmlSchemaType as XmlSchemaSimpleType;
if (simple != null)
this.DatatypeInternal = simple.Datatype;
// else
// DatatypeInternal = BaseSchemaType as XmlSchemaDatatype;
// 3.
XmlSchemaSimpleType baseSType = BaseXmlSchemaType as XmlSchemaSimpleType;
if (baseSType != null) {
if ((baseSType.FinalResolved & this.resolvedDerivedBy) != 0)
error (h, "Specified derivation is prohibited by the base simple type.");
}
// {variety}
if (this.resolvedDerivedBy == XmlSchemaDerivationMethod.Restriction &&
baseSType != null)
this.variety = baseSType.Variety;
else
this.variety = this.resolvedDerivedBy;
// 3.14.6 Derivation Valid (Restriction, Simple)
XmlSchemaSimpleTypeRestriction r = Content as XmlSchemaSimpleTypeRestriction;
object baseType = BaseXmlSchemaType != null ? (object) BaseXmlSchemaType : Datatype;
if (r != null)
ValidateDerivationValid (baseType, r.Facets, h, schema);
// TODO: describe which validation term this belongs to.
XmlSchemaSimpleTypeList l = Content as XmlSchemaSimpleTypeList;
if (l != null) {
XmlSchemaSimpleType itemSimpleType = l.ValidatedListItemType as XmlSchemaSimpleType;
if (itemSimpleType != null && itemSimpleType.Content is XmlSchemaSimpleTypeList)
error (h, "List type must not be derived from another list type.");
}
recursed = false;
ValidationId = schema.ValidationId;
return errorCount;
}
// 3.14.6 Derivation Valid (RestrictionSimple)
internal void ValidateDerivationValid (object baseType, XmlSchemaObjectCollection facets,
ValidationEventHandler h, XmlSchema schema)
{
// TODO
XmlSchemaSimpleType baseSimpleType = baseType as XmlSchemaSimpleType;
switch (this.Variety) {
// 1. atomic type
case XmlSchemaDerivationMethod.Restriction:
// 1.1
if (baseSimpleType != null && baseSimpleType.resolvedDerivedBy != XmlSchemaDerivationMethod.Restriction)
error (h, "Base schema type is not either atomic type or primitive type.");
// 1.2
if (baseSimpleType != null &&
(baseSimpleType.FinalResolved & XmlSchemaDerivationMethod.Restriction) != 0)
error (h, "Derivation by restriction is prohibited by the base simple type.");
// TODO: 1.3 facet restriction valid.
break;
case XmlSchemaDerivationMethod.List:
/*
XmlSchemaSimpleTypeList thisList = Content as XmlSchemaSimpleTypeList;
// 2.1 item list type not allowed
if (baseSimpleType != null && baseSimpleType.resolvedDerivedBy == XmlSchemaDerivationMethod.List)
error (h, "Base list schema type is not allowed.");
XmlSchemaSimpleTypeUnion baseUnion = baseSimpleType.Content as XmlSchemaSimpleTypeUnion;
if (baseUnion != null) {
bool errorFound = false;
foreach (object memberType in baseUnion.ValidatedTypes) {
XmlSchemaSimpleType memberST = memberType as XmlSchemaSimpleType;
if (memberST != null && memberST.resolvedDerivedBy == XmlSchemaDerivationMethod.List)
errorFound = true;
}
if (errorFound)
error (h, "Base union schema type should not contain list types.");
}
*/
// 2.2 facets limited
if (facets != null)
foreach (XmlSchemaFacet facet in facets) {
if (facet is XmlSchemaLengthFacet ||
facet is XmlSchemaMaxLengthFacet ||
facet is XmlSchemaMinLengthFacet ||
facet is XmlSchemaEnumerationFacet ||
facet is XmlSchemaPatternFacet)
continue;
else
error (h, "Not allowed facet was found on this simple type which derives list type.");
}
break;
case XmlSchemaDerivationMethod.Union:
// 3.1
// 3.2
if (facets != null)
foreach (XmlSchemaFacet facet in facets) {
if (facet is XmlSchemaEnumerationFacet ||
facet is XmlSchemaPatternFacet)
continue;
else
error (h, "Not allowed facet was found on this simple type which derives list type.");
}
break;
}
}
// 3.14.6 Type Derivation OK (Simple)
internal bool ValidateTypeDerivationOK (object baseType,
ValidationEventHandler h, XmlSchema schema, bool raiseError)
{
// 1
// Note that anyType should also be allowed as anySimpleType.
if (this == baseType || baseType == XmlSchemaSimpleType.AnySimpleType ||
baseType == XmlSchemaComplexType.AnyType)
return true;
// 2.1
XmlSchemaSimpleType baseSimpleType = baseType as XmlSchemaSimpleType;
if (baseSimpleType != null &&
(baseSimpleType.FinalResolved & resolvedDerivedBy) != 0) {
if (raiseError)
error (h, "Specified derivation is prohibited by the base type.");
return false;
}
// 2.2.1
if (BaseXmlSchemaType == baseType || Datatype == baseType)
return true;
// 2.2.2
XmlSchemaSimpleType thisBaseSimpleType = BaseXmlSchemaType as XmlSchemaSimpleType;
if (thisBaseSimpleType != null) {
if (thisBaseSimpleType.ValidateTypeDerivationOK (baseType, h, schema, false))
return true;
}
// 2.2.3
switch (Variety) {
case XmlSchemaDerivationMethod.Union:
case XmlSchemaDerivationMethod.List:
if (baseType == XmlSchemaSimpleType.AnySimpleType)
return true;
break;
}
// 2.2.4 validly derived from one of the union member type.
if (baseSimpleType != null && baseSimpleType.Variety == XmlSchemaDerivationMethod.Union) {
foreach (object memberType in ((XmlSchemaSimpleTypeUnion) baseSimpleType.Content).ValidatedTypes)
if (this.ValidateTypeDerivationOK (memberType, h, schema, false))
return true;
}
if (raiseError)
error(h, "Invalid simple type derivation was found.");
return false;
}
internal string Normalize (string s, XmlNameTable nt, XmlNamespaceManager nsmgr)
{
return Content.Normalize (s, nt, nsmgr);
}
//<simpleType
// final = (#all | (list | union | restriction))
// id = ID
// name = NCName
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (restriction | list | union))
//</simpleType>
internal static XmlSchemaSimpleType Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaSimpleType stype = new XmlSchemaSimpleType();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaGroup.Read, name="+reader.Name,null);
reader.Skip();
return null;
}
stype.LineNumber = reader.LineNumber;
stype.LinePosition = reader.LinePosition;
stype.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "final")
{
Exception innerex;
stype.Final = XmlSchemaUtil.ReadDerivationAttribute(reader, out innerex, "final",
XmlSchemaUtil.FinalAllowed);
if(innerex != null)
error(h, "some invalid values not a valid value for final", innerex);
}
else if(reader.Name == "id")
{
stype.Id = reader.Value;
}
else if(reader.Name == "name")
{
stype.Name = reader.Value;
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for simpleType",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,stype);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return stype;
// Content: (annotation?, (restriction | list | union))
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaSimpleType.Read, name="+reader.Name,null);
break;
}
if(level <= 1 && reader.LocalName == "annotation")
{
level = 2; //Only one annotation
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader,h);
if(annotation != null)
stype.Annotation = annotation;
continue;
}
if(level <= 2)
{
if(reader.LocalName == "restriction")
{
level = 3;
XmlSchemaSimpleTypeRestriction restriction = XmlSchemaSimpleTypeRestriction.Read(reader,h);
if(restriction != null)
stype.content = restriction;
continue;
}
if(reader.LocalName == "list")
{
level = 3;
XmlSchemaSimpleTypeList list = XmlSchemaSimpleTypeList.Read(reader,h);
if(list != null)
stype.content = list;
continue;
}
if(reader.LocalName == "union")
{
level = 3;
XmlSchemaSimpleTypeUnion union = XmlSchemaSimpleTypeUnion.Read(reader,h);
if(union != null)
stype.content = union;
continue;
}
}
reader.RaiseInvalidElementError();
}
return stype;
}
}
}
|