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
|
// Author: Dwivedi, Ajay kumar
// Adwiv@Yahoo.com
using System;
using System.Xml.Serialization;
using System.Xml;
namespace System.Xml.Schema
{
/// <summary>
/// Summary description for XmlSchemaSimpleContent.
/// </summary>
public class XmlSchemaSimpleContent : XmlSchemaContentModel
{
private XmlSchemaContent content;
private static string xmlname = "simpleContent";
public XmlSchemaSimpleContent()
{
}
[XmlElement("restriction",typeof(XmlSchemaSimpleContentRestriction),Namespace="http://www.w3.org/2001/XMLSchema")]
[XmlElement("extension",typeof(XmlSchemaSimpleContentExtension),Namespace="http://www.w3.org/2001/XMLSchema")]
public override XmlSchemaContent Content
{
get{ return content; }
set{ content = value; }
}
///<remarks>
/// 1. Content must be present and one of restriction or extention
///</remarks>
[MonoTODO]
internal int Compile(ValidationEventHandler h, XmlSchemaInfo info)
{
if(Content == null)
{
error(h, "Content must be present in a simpleContent");
}
else
{
if(Content is XmlSchemaSimpleContentRestriction)
{
XmlSchemaSimpleContentRestriction xscr = (XmlSchemaSimpleContentRestriction) Content;
errorCount += xscr.Compile(h,info);
}
else if(Content is XmlSchemaSimpleContentExtension)
{
XmlSchemaSimpleContentExtension xsce = (XmlSchemaSimpleContentExtension) Content;
errorCount += xsce.Compile(h,info);
}
else
error(h,"simpleContent can't have any value other than restriction or extention");
}
XmlSchemaUtil.CompileID(Id,this,info.IDCollection,h);
return errorCount;
}
[MonoTODO]
internal int Validate(ValidationEventHandler h)
{
return errorCount;
}
//<simpleContent
// id = ID
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (restriction | extension))
//</simpleContent>
internal static XmlSchemaSimpleContent Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaSimpleContent simple = new XmlSchemaSimpleContent();
reader.MoveToElement();
if(reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h,"Should not happen :1: XmlSchemaComplexContent.Read, name="+reader.Name,null);
reader.SkipToEnd();
return null;
}
simple.LineNumber = reader.LineNumber;
simple.LinePosition = reader.LinePosition;
simple.SourceUri = reader.BaseURI;
while(reader.MoveToNextAttribute())
{
if(reader.Name == "id")
{
simple.Id = reader.Value;
}
else if((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h,reader.Name + " is not a valid attribute for simpleContent",null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader,simple);
}
}
reader.MoveToElement();
if(reader.IsEmptyElement)
return simple;
//Content: (annotation?, (restriction | extension))
int level = 1;
while(reader.ReadNextElement())
{
if(reader.NodeType == XmlNodeType.EndElement)
{
if(reader.LocalName != xmlname)
error(h,"Should not happen :2: XmlSchemaSimpleContent.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)
simple.Annotation = annotation;
continue;
}
if(level <=2)
{
if(reader.LocalName == "restriction")
{
level = 3;
XmlSchemaSimpleContentRestriction restriction = XmlSchemaSimpleContentRestriction.Read(reader,h);
if(restriction != null)
simple.content = restriction;
continue;
}
if(reader.LocalName == "extension")
{
level = 3;
XmlSchemaSimpleContentExtension extension = XmlSchemaSimpleContentExtension.Read(reader,h);
if(extension != null)
simple.content = extension;
continue;
}
}
reader.RaiseInvalidElementError();
}
return simple;
}
}
}
|
