1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
|
// Author: Dwivedi, Ajay kumar
// Adwiv@Yahoo.com
using System;
using System.Xml.Serialization;
using System.Xml;
namespace System.Xml.Schema
{
/// <summary>
/// Summary description for XmlSchemaSimpleType.
/// </summary>
public class XmlSchemaSimpleType : XmlSchemaType
{
private XmlSchemaSimpleTypeContent content;
//compilation vars
internal bool islocal = true; // Assuming local means we have to specify islocal=false only in XmlSchema
private static string xmlname = "simpleType";
public XmlSchemaSimpleType()
{
}
[XmlElement("restriction",typeof(XmlSchemaSimpleTypeRestriction),Namespace="http://www.w3.org/2001/XMLSchema")]
[XmlElement("list",typeof(XmlSchemaSimpleTypeList),Namespace="http://www.w3.org/2001/XMLSchema")]
[XmlElement("union",typeof(XmlSchemaSimpleTypeUnion),Namespace="http://www.w3.org/2001/XMLSchema")]
public XmlSchemaSimpleTypeContent Content
{
get{ return content; }
set{ content = value; }
}
/// <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>
[MonoTODO]
internal int Compile(ValidationEventHandler h, XmlSchemaInfo info)
{
errorCount = 0;
if(this.islocal) // a
{
if(this.Name != null) // a.1
error(h,"Name is prohibited in a local simpletype");
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.qName = new XmlQualifiedName(this.Name,info.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:
this.finalResolved = XmlSchemaDerivationMethod.List;
break;
case XmlSchemaDerivationMethod.Union:
this.finalResolved = XmlSchemaDerivationMethod.Union;
break;
case XmlSchemaDerivationMethod.Restriction:
this.finalResolved = XmlSchemaDerivationMethod.Restriction;
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
if(info.FinalDefault == XmlSchemaDerivationMethod.All)
finalResolved = XmlSchemaDerivationMethod.All;
else
finalResolved = info.FinalDefault & (XmlSchemaDerivationMethod.Restriction | XmlSchemaDerivationMethod.List |
XmlSchemaDerivationMethod.Extension | XmlSchemaDerivationMethod.Union );
break;
}
}
XmlSchemaUtil.CompileID(Id,this,info.IDCollection,h);
if(this.Content == null) //a.3,b.2
error(h,"Content is required in a simpletype");
else if(Content is XmlSchemaSimpleTypeRestriction)
{
errorCount += ((XmlSchemaSimpleTypeRestriction)Content).Compile(h,info);
}
else if(Content is XmlSchemaSimpleTypeList)
{
errorCount += ((XmlSchemaSimpleTypeList)Content).Compile(h,info);
}
else if(Content is XmlSchemaSimpleTypeUnion)
{
errorCount += ((XmlSchemaSimpleTypeUnion)Content).Compile(h,info);
}
return errorCount;
}
[MonoTODO]
internal int Validate(ValidationEventHandler h)
{
return errorCount;
}
//<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");
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;
}
}
}
|
