public SchemaDocumentation(XmlSchemaAnnotation annotation)
{
this.annotation = annotation;
if (annotation != null) {
ReadDocumentationFromAnnotation(annotation.Items);
}
}
private static string ProcessAnnotation(XmlSchemaAnnotation schemaAnnotation)
{
StringBuilder result = new StringBuilder();
if (schemaAnnotation == null)
return result.ToString();
foreach (XmlSchemaObject schemaObject in schemaAnnotation.Items)
{
if (schemaObject is XmlSchemaAppInfo)
result.Append(ProcessAppInfo((XmlSchemaAppInfo)schemaObject));
else if (schemaObject is XmlSchemaDocumentation)
result.Append(ProcessDocumentation((XmlSchemaDocumentation)schemaObject));
else
result.AppendLine(string.Format("Unsupported annotation type: {0}", schemaObject));
}
return result.ToString();
}
static WebServiceEnumData ImportEnum(string typeName, string typeNamespace, XmlQualifiedName typeQualifiedName, XmlSchemaSimpleTypeRestriction restriction, XmlSchemaAnnotation annotation) {
// CheckIfEnum has already checked if baseType of restriction is string
XmlQualifiedName baseTypeName = ImportActualType(annotation, new XmlQualifiedName("int", XmlSchema.Namespace), typeQualifiedName);
Type baseEnumType = _nameToType[baseTypeName];
bool isULong = (baseEnumType == typeof(ulong));
List<string> enumNames = new List<string>();
List<long> enumValues = new List<long>();
foreach (XmlSchemaFacet facet in restriction.Facets) {
XmlSchemaEnumerationFacet enumFacet = facet as XmlSchemaEnumerationFacet;
Debug.Assert(enumFacet != null);
Debug.Assert(enumFacet.Value != null);
string valueInnerText = GetInnerText(typeQualifiedName, ImportAnnotation(enumFacet.Annotation, EnumerationValueAnnotationName));
long value;
if (valueInnerText == null) {
// ASP .NET AJAX doesn't honor the Flags nature of Flags enums
// If it were to, we would assign Math.Pow(2, nameValues.Count) for Flags enums instead.
value = enumNames.Count;
}
else {
if (isULong) {
value = (long)ulong.Parse(valueInnerText, NumberFormatInfo.InvariantInfo);
}
else {
value = long.Parse(valueInnerText, NumberFormatInfo.InvariantInfo);
}
}
enumNames.Add(enumFacet.Value);
enumValues.Add(value);
}
return new WebServiceEnumData(typeName, typeNamespace, enumNames.ToArray(), enumValues.ToArray(), isULong);
}
void Write5_XmlSchemaAnnotation(XmlSchemaAnnotation o) {
if ((object)o == null) return;
WriteStartElement("annotation");
WriteAttribute(@"id", @"", ((System.String)o.@Id));
WriteAttributes((XmlAttribute[])o.@UnhandledAttributes, o);
System.Xml.Schema.XmlSchemaObjectCollection a = (System.Xml.Schema.XmlSchemaObjectCollection)o.@Items;
if (a != null) {
for (int ia = 0; ia < a.Count; ia++) {
XmlSchemaObject ai = (XmlSchemaObject)a[ia];
if (ai is XmlSchemaAppInfo) {
Write7_XmlSchemaAppInfo((XmlSchemaAppInfo)ai);
}
else if (ai is XmlSchemaDocumentation) {
Write6_XmlSchemaDocumentation((XmlSchemaDocumentation)ai);
}
}
}
WriteEndElement();
}
//<extension
// base = QName
// id = ID
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, ((group | all | choice | sequence)?, ((attribute | attributeGroup)*, anyAttribute?)))
//</extension>
internal static XmlSchemaComplexContentExtension Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaComplexContentExtension extension = new XmlSchemaComplexContentExtension();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaComplexContentExtension.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
extension.LineNumber = reader.LineNumber;
extension.LinePosition = reader.LinePosition;
extension.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "base")
{
Exception innerex;
extension.baseTypeName = XmlSchemaUtil.ReadQNameAttribute(reader, out innerex);
if (innerex != null)
{
error(h, reader.Value + " is not a valid value for base attribute", innerex);
}
}
else if (reader.Name == "id")
{
extension.Id = reader.Value;
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for extension", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, extension);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(extension);
}
//Content: 1. annotation?,
// (2.(group | all | choice | sequence)?, (3.(attribute | attributeGroup)*, 4.anyAttribute?)))
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaComplexContentExtension.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)
{
extension.Annotation = annotation;
}
continue;
}
if (level <= 2)
{
if (reader.LocalName == "group")
{
level = 3;
XmlSchemaGroupRef group = XmlSchemaGroupRef.Read(reader, h);
if (group != null)
{
extension.particle = group;
}
continue;
}
if (reader.LocalName == "all")
{
level = 3;
XmlSchemaAll all = XmlSchemaAll.Read(reader, h);
if (all != null)
{
extension.particle = all;
}
continue;
}
if (reader.LocalName == "choice")
{
level = 3;
XmlSchemaChoice choice = XmlSchemaChoice.Read(reader, h);
if (choice != null)
{
extension.particle = choice;
}
continue;
}
if (reader.LocalName == "sequence")
{
level = 3;
XmlSchemaSequence sequence = XmlSchemaSequence.Read(reader, h);
if (sequence != null)
{
extension.particle = sequence;
}
continue;
}
}
if (level <= 3)
{
if (reader.LocalName == "attribute")
{
level = 3;
XmlSchemaAttribute attr = XmlSchemaAttribute.Read(reader, h);
if (attr != null)
{
extension.Attributes.Add(attr);
}
continue;
}
if (reader.LocalName == "attributeGroup")
{
level = 3;
XmlSchemaAttributeGroupRef attr = XmlSchemaAttributeGroupRef.Read(reader, h);
if (attr != null)
{
extension.attributes.Add(attr);
}
continue;
}
}
if (level <= 4 && reader.LocalName == "anyAttribute")
{
level = 5;
XmlSchemaAnyAttribute anyattr = XmlSchemaAnyAttribute.Read(reader, h);
if (anyattr != null)
{
extension.AnyAttribute = anyattr;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(extension);
}
//<attributeGroup
// id = ID
// ref = QName
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?)
//</attributeGroup>
internal static XmlSchemaAttributeGroupRef Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaAttributeGroupRef attrgrp = new XmlSchemaAttributeGroupRef();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaAttributeGroupRef.Read, name=" + reader.Name, null);
reader.SkipToEnd();
return(null);
}
attrgrp.LineNumber = reader.LineNumber;
attrgrp.LinePosition = reader.LinePosition;
attrgrp.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
attrgrp.Id = reader.Value;
}
else if (reader.Name == "ref")
{
Exception innerex;
attrgrp.refName = XmlSchemaUtil.ReadQNameAttribute(reader, out innerex);
if (innerex != null)
{
error(h, reader.Value + " is not a valid value for ref attribute", innerex);
}
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for attributeGroup in this context", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, attrgrp);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(attrgrp);
}
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaAttributeGroupRef.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)
{
attrgrp.Annotation = annotation;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(attrgrp);
}
static XmlSchemaAnnotation GetSchemaAnnotation(params XmlNode[] nodes)
{
if (nodes == null || nodes.Length == 0)
return null;
bool hasAnnotation = false;
for (int i = 0; i < nodes.Length; i++)
if (nodes[i] != null)
{
hasAnnotation = true;
break;
}
if (!hasAnnotation)
return null;
XmlSchemaAnnotation annotation = new XmlSchemaAnnotation();
XmlSchemaAppInfo appInfo = new XmlSchemaAppInfo();
annotation.Items.Add(appInfo);
appInfo.Markup = nodes;
return annotation;
}
internal static XmlSchemaComplexContentExtension Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaComplexContentExtension xmlSchemaComplexContentExtension = new XmlSchemaComplexContentExtension();
reader.MoveToElement();
if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "extension")
{
XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaComplexContentExtension.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
xmlSchemaComplexContentExtension.LineNumber = reader.LineNumber;
xmlSchemaComplexContentExtension.LinePosition = reader.LinePosition;
xmlSchemaComplexContentExtension.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "base")
{
Exception ex;
xmlSchemaComplexContentExtension.baseTypeName = XmlSchemaUtil.ReadQNameAttribute(reader, out ex);
if (ex != null)
{
XmlSchemaObject.error(h, reader.Value + " is not a valid value for base attribute", ex);
}
}
else if (reader.Name == "id")
{
xmlSchemaComplexContentExtension.Id = reader.Value;
}
else if ((reader.NamespaceURI == string.Empty && reader.Name != "xmlns") || reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema")
{
XmlSchemaObject.error(h, reader.Name + " is not a valid attribute for extension", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaComplexContentExtension);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(xmlSchemaComplexContentExtension);
}
int num = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != "extension")
{
XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaComplexContentExtension.Read, name=" + reader.Name, null);
}
break;
}
if (num <= 1 && reader.LocalName == "annotation")
{
num = 2;
XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h);
if (xmlSchemaAnnotation != null)
{
xmlSchemaComplexContentExtension.Annotation = xmlSchemaAnnotation;
}
}
else
{
if (num <= 2)
{
if (reader.LocalName == "group")
{
num = 3;
XmlSchemaGroupRef xmlSchemaGroupRef = XmlSchemaGroupRef.Read(reader, h);
if (xmlSchemaGroupRef != null)
{
xmlSchemaComplexContentExtension.particle = xmlSchemaGroupRef;
}
continue;
}
if (reader.LocalName == "all")
{
num = 3;
XmlSchemaAll xmlSchemaAll = XmlSchemaAll.Read(reader, h);
if (xmlSchemaAll != null)
{
xmlSchemaComplexContentExtension.particle = xmlSchemaAll;
}
continue;
}
if (reader.LocalName == "choice")
{
num = 3;
XmlSchemaChoice xmlSchemaChoice = XmlSchemaChoice.Read(reader, h);
if (xmlSchemaChoice != null)
{
xmlSchemaComplexContentExtension.particle = xmlSchemaChoice;
}
continue;
}
if (reader.LocalName == "sequence")
{
num = 3;
XmlSchemaSequence xmlSchemaSequence = XmlSchemaSequence.Read(reader, h);
if (xmlSchemaSequence != null)
{
xmlSchemaComplexContentExtension.particle = xmlSchemaSequence;
}
continue;
}
}
if (num <= 3)
{
if (reader.LocalName == "attribute")
{
num = 3;
XmlSchemaAttribute xmlSchemaAttribute = XmlSchemaAttribute.Read(reader, h);
if (xmlSchemaAttribute != null)
{
xmlSchemaComplexContentExtension.Attributes.Add(xmlSchemaAttribute);
}
continue;
}
if (reader.LocalName == "attributeGroup")
{
num = 3;
XmlSchemaAttributeGroupRef xmlSchemaAttributeGroupRef = XmlSchemaAttributeGroupRef.Read(reader, h);
if (xmlSchemaAttributeGroupRef != null)
{
xmlSchemaComplexContentExtension.attributes.Add(xmlSchemaAttributeGroupRef);
}
continue;
}
}
if (num <= 4 && reader.LocalName == "anyAttribute")
{
num = 5;
XmlSchemaAnyAttribute xmlSchemaAnyAttribute = XmlSchemaAnyAttribute.Read(reader, h);
if (xmlSchemaAnyAttribute != null)
{
xmlSchemaComplexContentExtension.AnyAttribute = xmlSchemaAnyAttribute;
}
}
else
{
reader.RaiseInvalidElementError();
}
}
}
return(xmlSchemaComplexContentExtension);
}
static string GetDocumentation(XmlSchemaAnnotation annotation)
{
return new SchemaDocumentation(annotation).ToString();
}
/// <summary>
/// Adds an element completion data to the collection if it does not
/// already exist.
/// </summary>
void AddElement(XmlCompletionDataCollection data, string name, string prefix, XmlSchemaAnnotation annotation)
{
// Get any annotation documentation.
string documentation = GetDocumentation(annotation);
AddElement(data, name, prefix, documentation);
}
/// <summary>
/// Adds an attribute value to the completion data collection.
/// </summary>
void AddAttributeValue(XmlCompletionDataCollection data, string valueText, XmlSchemaAnnotation annotation)
{
string documentation = GetDocumentation(annotation);
XmlCompletionData completionData = new XmlCompletionData(valueText, documentation, XmlCompletionData.DataType.XmlAttributeValue);
data.Add(completionData);
}
// <group
// id = ID
// ref = QName
// minOccurs = ? : 1
// maxOccurs = ? : 1>
// Content: (annotation?)
// </group>
internal static XmlSchemaGroupRef Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaGroupRef groupref = new XmlSchemaGroupRef();
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);
}
groupref.LineNumber = reader.LineNumber;
groupref.LinePosition = reader.LinePosition;
groupref.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
groupref.Id = reader.Value;
}
else if (reader.Name == "ref")
{
Exception innerex;
groupref.refName = XmlSchemaUtil.ReadQNameAttribute(reader, out innerex);
if (innerex != null)
{
error(h, reader.Value + " is not a valid value for ref attribute", innerex);
}
}
else if (reader.Name == "maxOccurs")
{
try
{
groupref.MaxOccursString = reader.Value;
}
catch (Exception e)
{
error(h, reader.Value + " is an invalid value for maxOccurs", e);
}
}
else if (reader.Name == "minOccurs")
{
try
{
groupref.MinOccursString = reader.Value;
}
catch (Exception e)
{
error(h, reader.Value + " is an invalid value for minOccurs", e);
}
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for group", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, groupref);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(groupref);
}
// Content: (annotation?)
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaGroupRef.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)
{
groupref.Annotation = annotation;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(groupref);
}
private void setAnnotation( AbstractDef def,
XmlSchemaAnnotation annotation )
{
if ( annotation != null ) {
string desc = string.Empty;
foreach ( XmlSchemaObject o in annotation.Items ) {
XmlSchemaDocumentation description = o as XmlSchemaDocumentation;
if ( description != null ) {
foreach ( XmlNode node in description.Markup ) {
desc += node.OuterXml;
}
}
else {
XmlSchemaAppInfo appinfo = o as XmlSchemaAppInfo;
if ( o != null ) {
def.SetFlags( appinfo.Markup[0].InnerText );
}
}
}
def.Desc = desc;
}
}
/// <summary>
/// Get the description from an xml schema object.
/// </summary>
/// <param name="annotation">The xml schema object.</param>
/// <returns>The description of the object.</returns>
private static string GetDescription(XmlSchemaAnnotation annotation)
{
StringBuilder documentation = new StringBuilder();
// retrieve the documentation nodes
foreach (XmlSchemaObject obj in annotation.Items)
{
XmlSchemaDocumentation doc = obj as XmlSchemaDocumentation;
if (doc != null)
{
foreach (XmlNode node in doc.Markup)
{
if (node is XmlText)
{
documentation.Append(((XmlText)node).OuterXml);
}
else if (node is XmlElement)
{
documentation.Append(((XmlElement)node).OuterXml);
}
}
}
}
documentation.Replace("\t", String.Empty);
documentation.Replace(String.Concat(Environment.NewLine, Environment.NewLine), "<br/><br/>");
documentation.Replace(Environment.NewLine, " ");
return htmlPrefix.Replace(documentation.ToString(), String.Empty);
}
public virtual void Check (ConformanceCheckContext ctx, XmlSchemaAnnotation value) {}
//<selector
// id = ID
// xpath = a subset of XPath expression, see below
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?)
//</selector>
internal static XmlSchemaXPath Read(XmlSchemaReader reader, ValidationEventHandler h, string name)
{
XmlSchemaXPath path = new XmlSchemaXPath();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != name)
{
error(h, "Should not happen :1: XmlSchemaComplexContentRestriction.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
path.LineNumber = reader.LineNumber;
path.LinePosition = reader.LinePosition;
path.SourceUri = reader.BaseURI;
XmlNamespaceManager currentMgr = XmlSchemaUtil.GetParserContext(reader.Reader).NamespaceManager;
if (currentMgr != null)
{
path.nsmgr = new XmlNamespaceManager(reader.NameTable);
IEnumerator e = currentMgr.GetEnumerator();
while (e.MoveNext())
{
string prefix = e.Current as string;
switch (prefix)
{
case "xml":
case "xmlns":
continue;
default:
path.nsmgr.AddNamespace(prefix, currentMgr.LookupNamespace(prefix, false));
break;
}
}
}
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
path.Id = reader.Value;
}
else if (reader.Name == "xpath")
{
path.xpath = reader.Value;
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for " + name, null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, path);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(path);
}
// Content: (annotation?)
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != name)
{
error(h, "Should not happen :2: XmlSchemaXPath.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)
{
path.Annotation = annotation;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(path);
}
private static void ReadContent(XmlSchema schema, XmlSchemaReader reader, ValidationEventHandler h)
{
reader.MoveToElement();
if (reader.LocalName != "schema" && reader.NamespaceURI != XmlSchema.Namespace && reader.NodeType != XmlNodeType.Element)
{
error(h, "UNREACHABLE CODE REACHED: Method: Schema.ReadContent, " + reader.LocalName + ", " + reader.NamespaceURI, null);
}
//(include | import | redefine | annotation)*,
//((simpleType | complexType | group | attributeGroup | element | attribute | notation | annotation)*
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchema.Read, name=" + reader.Name, null);
}
break;
}
if (level <= 1)
{
if (reader.LocalName == "include")
{
XmlSchemaInclude include = XmlSchemaInclude.Read(reader, h);
if (include != null)
{
schema.includes.Add(include);
}
continue;
}
if (reader.LocalName == "import")
{
XmlSchemaImport import = XmlSchemaImport.Read(reader, h);
if (import != null)
{
schema.includes.Add(import);
}
continue;
}
if (reader.LocalName == "redefine")
{
XmlSchemaRedefine redefine = XmlSchemaRedefine.Read(reader, h);
if (redefine != null)
{
schema.includes.Add(redefine);
}
continue;
}
if (reader.LocalName == "annotation")
{
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h);
if (annotation != null)
{
schema.items.Add(annotation);
}
continue;
}
}
if (level <= 2)
{
level = 2;
if (reader.LocalName == "simpleType")
{
XmlSchemaSimpleType stype = XmlSchemaSimpleType.Read(reader, h);
if (stype != null)
{
schema.items.Add(stype);
}
continue;
}
if (reader.LocalName == "complexType")
{
XmlSchemaComplexType ctype = XmlSchemaComplexType.Read(reader, h);
if (ctype != null)
{
schema.items.Add(ctype);
}
continue;
}
if (reader.LocalName == "group")
{
XmlSchemaGroup group = XmlSchemaGroup.Read(reader, h);
if (group != null)
{
schema.items.Add(group);
}
continue;
}
if (reader.LocalName == "attributeGroup")
{
XmlSchemaAttributeGroup attributeGroup = XmlSchemaAttributeGroup.Read(reader, h);
if (attributeGroup != null)
{
schema.items.Add(attributeGroup);
}
continue;
}
if (reader.LocalName == "element")
{
XmlSchemaElement element = XmlSchemaElement.Read(reader, h);
if (element != null)
{
schema.items.Add(element);
}
continue;
}
if (reader.LocalName == "attribute")
{
XmlSchemaAttribute attr = XmlSchemaAttribute.Read(reader, h);
if (attr != null)
{
schema.items.Add(attr);
}
continue;
}
if (reader.LocalName == "notation")
{
XmlSchemaNotation notation = XmlSchemaNotation.Read(reader, h);
if (notation != null)
{
schema.items.Add(notation);
}
continue;
}
if (reader.LocalName == "annotation")
{
XmlSchemaAnnotation annotation = XmlSchemaAnnotation.Read(reader, h);
if (annotation != null)
{
schema.items.Add(annotation);
}
continue;
}
}
reader.RaiseInvalidElementError();
}
}
/// <summary>
/// Gets the documentation from the annotation element.
/// </summary>
/// <remarks>
/// All documentation elements are added. All text nodes inside
/// the documentation element are added.
/// </remarks>
string GetDocumentation(XmlSchemaAnnotation annotation)
{
string documentation = String.Empty;
if (annotation != null) {
StringBuilder documentationBuilder = new StringBuilder();
foreach (XmlSchemaObject schemaObject in annotation.Items) {
XmlSchemaDocumentation schemaDocumentation = schemaObject as XmlSchemaDocumentation;
if (schemaDocumentation != null) {
foreach (XmlNode node in schemaDocumentation.Markup) {
XmlText textNode = node as XmlText;
if (textNode != null) {
if (textNode.Data != null) {
if (textNode.Data.Length > 0) {
documentationBuilder.Append(textNode.Data);
}
}
}
}
}
}
documentation = documentationBuilder.ToString();
}
return documentation;
}
private void HandleAnnotations (XmlSchemaAnnotation an, bool nested)
{
foreach (XmlSchemaObject content in an.Items) {
XmlSchemaAppInfo ai = content as XmlSchemaAppInfo;
if (ai != null) {
foreach (XmlNode n in ai.Markup) {
XmlElement el = n as XmlElement;
if (el != null && el.LocalName == "Relationship" && el.NamespaceURI == XmlConstants.MsdataNamespace)
HandleRelationshipAnnotation (el, nested);
}
}
}
}
//<all
// id = ID
// maxOccurs = 1 : 1
// minOccurs = (0 | 1) : 1
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, element*)
//</all>
internal static XmlSchemaAll Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaAll all = new XmlSchemaAll();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaAll.Read, name=" + reader.Name, null);
reader.SkipToEnd();
return(null);
}
all.LineNumber = reader.LineNumber;
all.LinePosition = reader.LinePosition;
all.SourceUri = reader.BaseURI;
//Read Attributes
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
all.Id = reader.Value;
}
else if (reader.Name == "maxOccurs")
{
try
{
all.MaxOccursString = reader.Value;
}
catch (Exception e)
{
error(h, reader.Value + " is an invalid value for maxOccurs", e);
}
}
else if (reader.Name == "minOccurs")
{
try
{
all.MinOccursString = reader.Value;
}
catch (Exception e)
{
error(h, reader.Value + " is an invalid value for minOccurs", e);
}
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for all", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, all);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(all);
}
//Content: (annotation?, element*)
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaAll.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)
{
all.Annotation = annotation;
}
continue;
}
if (level <= 2 && reader.LocalName == "element")
{
level = 2;
XmlSchemaElement element = XmlSchemaElement.Read(reader, h);
if (element != null)
{
all.items.Add(element);
}
continue;
}
reader.RaiseInvalidElementError();
}
return(all);
}
//<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);
}
//<choice
// id = ID
// maxOccurs = (nonNegativeInteger | unbounded) : 1
// minOccurs = nonNegativeInteger : 1
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (element | group | choice | sequence | any)*)
//</choice>
internal static XmlSchemaChoice Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaChoice choice = new XmlSchemaChoice();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaChoice.Read, name=" + reader.Name, null);
reader.SkipToEnd();
return(null);
}
choice.LineNumber = reader.LineNumber;
choice.LinePosition = reader.LinePosition;
choice.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
choice.Id = reader.Value;
}
else if (reader.Name == "maxOccurs")
{
try
{
choice.MaxOccursString = reader.Value;
}
catch (Exception e)
{
error(h, reader.Value + " is an invalid value for maxOccurs", e);
}
}
else if (reader.Name == "minOccurs")
{
try
{
choice.MinOccursString = reader.Value;
}
catch (Exception e)
{
error(h, reader.Value + " is an invalid value for minOccurs", e);
}
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for choice", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, choice);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(choice);
}
// Content: (annotation?, (element | group | choice | sequence | any)*)
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaChoice.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)
{
choice.Annotation = annotation;
}
continue;
}
if (level <= 2)
{
if (reader.LocalName == "element")
{
level = 2;
XmlSchemaElement element = XmlSchemaElement.Read(reader, h);
if (element != null)
{
choice.items.Add(element);
}
continue;
}
if (reader.LocalName == "group")
{
level = 2;
XmlSchemaGroupRef group = XmlSchemaGroupRef.Read(reader, h);
if (group != null)
{
choice.items.Add(group);
}
continue;
}
if (reader.LocalName == "choice")
{
level = 2;
XmlSchemaChoice ch = XmlSchemaChoice.Read(reader, h);
if (ch != null)
{
choice.items.Add(ch);
}
continue;
}
if (reader.LocalName == "sequence")
{
level = 2;
XmlSchemaSequence sequence = XmlSchemaSequence.Read(reader, h);
if (sequence != null)
{
choice.items.Add(sequence);
}
continue;
}
if (reader.LocalName == "any")
{
level = 2;
XmlSchemaAny any = XmlSchemaAny.Read(reader, h);
if (any != null)
{
choice.items.Add(any);
}
continue;
}
}
reader.RaiseInvalidElementError();
}
return(choice);
}
internal override void AddAnnotation(XmlSchemaAnnotation annotation)
{
this.annotation = annotation;
}
internal static XmlSchemaTotalDigitsFacet Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaTotalDigitsFacet xmlSchemaTotalDigitsFacet = new XmlSchemaTotalDigitsFacet();
reader.MoveToElement();
if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "totalDigits")
{
XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaTotalDigitsFacet.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
xmlSchemaTotalDigitsFacet.LineNumber = reader.LineNumber;
xmlSchemaTotalDigitsFacet.LinePosition = reader.LinePosition;
xmlSchemaTotalDigitsFacet.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
xmlSchemaTotalDigitsFacet.Id = reader.Value;
}
else if (reader.Name == "fixed")
{
Exception ex;
xmlSchemaTotalDigitsFacet.IsFixed = XmlSchemaUtil.ReadBoolAttribute(reader, out ex);
if (ex != null)
{
XmlSchemaObject.error(h, reader.Value + " is not a valid value for fixed attribute", ex);
}
}
else if (reader.Name == "value")
{
xmlSchemaTotalDigitsFacet.Value = reader.Value;
}
else if ((reader.NamespaceURI == string.Empty && reader.Name != "xmlns") || reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema")
{
XmlSchemaObject.error(h, reader.Name + " is not a valid attribute for totalDigits", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaTotalDigitsFacet);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(xmlSchemaTotalDigitsFacet);
}
int num = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != "totalDigits")
{
XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaTotalDigitsFacet.Read, name=" + reader.Name, null);
}
break;
}
if (num <= 1 && reader.LocalName == "annotation")
{
num = 2;
XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h);
if (xmlSchemaAnnotation != null)
{
xmlSchemaTotalDigitsFacet.Annotation = xmlSchemaAnnotation;
}
}
else
{
reader.RaiseInvalidElementError();
}
}
return(xmlSchemaTotalDigitsFacet);
}
internal static XmlSchemaGroupRef Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaGroupRef xmlSchemaGroupRef = new XmlSchemaGroupRef();
reader.MoveToElement();
if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "group")
{
XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaGroup.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
xmlSchemaGroupRef.LineNumber = reader.LineNumber;
xmlSchemaGroupRef.LinePosition = reader.LinePosition;
xmlSchemaGroupRef.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
xmlSchemaGroupRef.Id = reader.Value;
}
else if (reader.Name == "ref")
{
Exception ex;
xmlSchemaGroupRef.refName = XmlSchemaUtil.ReadQNameAttribute(reader, out ex);
if (ex != null)
{
XmlSchemaObject.error(h, reader.Value + " is not a valid value for ref attribute", ex);
}
}
else if (reader.Name == "maxOccurs")
{
try
{
xmlSchemaGroupRef.MaxOccursString = reader.Value;
}
catch (Exception innerException)
{
XmlSchemaObject.error(h, reader.Value + " is an invalid value for maxOccurs", innerException);
}
}
else if (reader.Name == "minOccurs")
{
try
{
xmlSchemaGroupRef.MinOccursString = reader.Value;
}
catch (Exception innerException2)
{
XmlSchemaObject.error(h, reader.Value + " is an invalid value for minOccurs", innerException2);
}
}
else if ((reader.NamespaceURI == string.Empty && reader.Name != "xmlns") || reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema")
{
XmlSchemaObject.error(h, reader.Name + " is not a valid attribute for group", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaGroupRef);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(xmlSchemaGroupRef);
}
int num = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != "group")
{
XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaGroupRef.Read, name=" + reader.Name, null);
}
break;
}
if (num <= 1 && reader.LocalName == "annotation")
{
num = 2;
XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h);
if (xmlSchemaAnnotation != null)
{
xmlSchemaGroupRef.Annotation = xmlSchemaAnnotation;
}
}
else
{
reader.RaiseInvalidElementError();
}
}
return(xmlSchemaGroupRef);
}
//<list
// id = ID
// itemType = QName
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (simpleType?))
//</list>
internal static XmlSchemaSimpleTypeList Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaSimpleTypeList list = new XmlSchemaSimpleTypeList();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaSimpleTypeList.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
list.LineNumber = reader.LineNumber;
list.LinePosition = reader.LinePosition;
list.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
list.Id = reader.Value;
}
else if (reader.Name == "itemType")
{
Exception innerex;
list.ItemTypeName = XmlSchemaUtil.ReadQNameAttribute(reader, out innerex);
if (innerex != null)
{
error(h, reader.Value + " is not a valid value for itemType attribute", innerex);
}
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for list", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, list);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(list);
}
// Content: annotation?, simpleType?
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaSimpleTypeList.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)
{
list.Annotation = annotation;
}
continue;
}
if (level <= 2 && reader.LocalName == "simpleType")
{
level = 3;
XmlSchemaSimpleType stype = XmlSchemaSimpleType.Read(reader, h);
if (stype != null)
{
list.itemType = stype;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(list);
}
//<union
// id = ID
// memberTypes = List of QName
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (simpleType*))
//</union>
internal static XmlSchemaSimpleTypeUnion Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaSimpleTypeUnion union = new XmlSchemaSimpleTypeUnion();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaSimpleTypeUnion.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
union.LineNumber = reader.LineNumber;
union.LinePosition = reader.LinePosition;
union.SourceUri = reader.BaseURI;
//Read Attributes
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
union.Id = reader.Value;
}
else if (reader.Name == "memberTypes")
{
Exception innerEx;
string[] names = XmlSchemaUtil.SplitList(reader.Value);
union.memberTypes = new XmlQualifiedName[names.Length];
for (int i = 0; i < names.Length; i++)
{
union.memberTypes[i] = XmlSchemaUtil.ToQName(reader, names[i], out innerEx);
if (innerEx != null)
{
error(h, "'" + names[i] + "' is not a valid memberType", innerEx);
}
}
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for union", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, union);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(union);
}
// Content: annotation?, simpleType*
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaSimpleTypeUnion.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)
{
union.Annotation = annotation;
}
continue;
}
if (level <= 2 && reader.LocalName == "simpleType")
{
level = 2;
XmlSchemaSimpleType stype = XmlSchemaSimpleType.Read(reader, h);
if (stype != null)
{
union.baseTypes.Add(stype);
}
continue;
}
reader.RaiseInvalidElementError();
}
return(union);
}
internal virtual void AddAnnotation(XmlSchemaAnnotation annotation) {}
private void PreprocessAnnotation(XmlSchemaAnnotation annotation)
{
this.ValidateIdAttribute(annotation);
for (int i = 0; i < annotation.Items.Count; i++)
{
annotation.Items[i].Parent = annotation;
}
}
private void HandleRelations(XmlSchemaAnnotation ann, bool fNested) {
foreach (object __items in ann.Items)
if (__items is XmlSchemaAppInfo) {
XmlNode[] relations = ((XmlSchemaAppInfo) __items).Markup;
for (int i = 0; i<relations.Length; i++)
if (FEqualIdentity(relations[i], Keywords.MSD_RELATION, Keywords.MSDNS))
HandleRelation((XmlElement)relations[i], fNested);
}
}
internal static XmlSchemaKeyref Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaKeyref xmlSchemaKeyref = new XmlSchemaKeyref();
reader.MoveToElement();
if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "keyref")
{
XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaKeyref.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
xmlSchemaKeyref.LineNumber = reader.LineNumber;
xmlSchemaKeyref.LinePosition = reader.LinePosition;
xmlSchemaKeyref.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
xmlSchemaKeyref.Id = reader.Value;
}
else if (reader.Name == "name")
{
xmlSchemaKeyref.Name = reader.Value;
}
else if (reader.Name == "refer")
{
Exception ex;
xmlSchemaKeyref.refer = XmlSchemaUtil.ReadQNameAttribute(reader, out ex);
if (ex != null)
{
XmlSchemaObject.error(h, reader.Value + " is not a valid value for refer attribute", ex);
}
}
else if ((reader.NamespaceURI == string.Empty && reader.Name != "xmlns") || reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema")
{
XmlSchemaObject.error(h, reader.Name + " is not a valid attribute for keyref", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaKeyref);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(xmlSchemaKeyref);
}
int num = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != "keyref")
{
XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaKeyref.Read, name=" + reader.Name, null);
}
break;
}
if (num <= 1 && reader.LocalName == "annotation")
{
num = 2;
XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h);
if (xmlSchemaAnnotation != null)
{
xmlSchemaKeyref.Annotation = xmlSchemaAnnotation;
}
}
else if (num <= 2 && reader.LocalName == "selector")
{
num = 3;
XmlSchemaXPath xmlSchemaXPath = XmlSchemaXPath.Read(reader, h, "selector");
if (xmlSchemaXPath != null)
{
xmlSchemaKeyref.Selector = xmlSchemaXPath;
}
}
else if (num <= 3 && reader.LocalName == "field")
{
num = 3;
if (xmlSchemaKeyref.Selector == null)
{
XmlSchemaObject.error(h, "selector must be defined before field declarations", null);
}
XmlSchemaXPath xmlSchemaXPath2 = XmlSchemaXPath.Read(reader, h, "field");
if (xmlSchemaXPath2 != null)
{
xmlSchemaKeyref.Fields.Add(xmlSchemaXPath2);
}
}
else
{
reader.RaiseInvalidElementError();
}
}
return(xmlSchemaKeyref);
}
/// <summary>
/// Creates the an xml schema for a complex type. This method automatically takes care of
/// any base classes that must be added.
/// <para />
/// This method already adds the <see cref="XmlSchemaComplexType" /> to the <see cref="XmlSchemaSet" />.
/// </summary>
/// <param name="type">The type to create the complex schema for.</param>
/// <param name="schema">The schema.</param>
/// <param name="schemaSet">The schema set.</param>
/// <param name="serializationManager">The serialization manager.</param>
/// <param name="generateFlatSchema">A value indicating whether the schema should be generated as flat schema.</param>
/// <returns>The complex schema for the specified type.</returns>
private static XmlSchemaComplexType CreateSchemaComplexType(Type type, XmlSchema schema, XmlSchemaSet schemaSet, ISerializationManager serializationManager, bool generateFlatSchema)
{
// Determine name, which is complex in generic types
string typeName = GetTypeNameForSchema(type);
// First, add the type, otherwise we might get into a stackoverflow when using generic base types
// <xs:complexType>
var modelBaseType = new XmlSchemaComplexType();
modelBaseType.Name = typeName;
modelBaseType.IsMixed = false;
schema.Items.Add(modelBaseType);
var propertiesSequence = GetPropertiesSequence(type, schema, schemaSet, serializationManager);
// If flat, don't generate base classes, just the type itself
if (generateFlatSchema)
{
modelBaseType.Particle = propertiesSequence;
return modelBaseType;
}
if (type.IsGenericType)
{
var genericComplexType = new XmlSchemaComplexType();
genericComplexType.Name = typeName;
// <xs:annotation>
var annotation = new XmlSchemaAnnotation();
// <xs:appinfo>
var appInfo = new XmlSchemaAppInfo();
//<GenericType xmlns="http://schemas.microsoft.com/2003/10/Serialization/" Name="DataContractBaseOf{0}{#}" Namespace="http://schemas.datacontract.org/2004/07/STC">
// <GenericParameter Name="ProfileDateRange2" Namespace="http://schemas.datacontract.org/2004/07/STC.Meter.ProfileData"/>
//</GenericType>
var genericTypeElement = new XElement("GenericType");
genericTypeElement.Add(new XAttribute("Name", string.Format("{0}Of{{0}}{{#}}", typeName)));
genericTypeElement.Add(new XAttribute("Namespace", GetTypeNamespaceForSchema(type)));
foreach (var genericArgument in type.GetGenericArgumentsEx())
{
var genericArgumentQualifiedName = AddTypeToSchemaSet(genericArgument, schemaSet, serializationManager);
var genericArgumentElement = new XElement("GenericParameter");
genericArgumentElement.Add(new XAttribute("Name", genericArgumentQualifiedName.Name));
genericArgumentElement.Add(new XAttribute("Namespace", genericArgumentQualifiedName.Namespace));
genericTypeElement.Add(genericArgumentElement);
}
var conversionDoc = new XmlDocument();
appInfo.Markup = new XmlNode[] { conversionDoc.CreateTextNode(genericTypeElement.ToString()) };
annotation.Items.Add(appInfo);
}
var baseTypeQualifiedName = AddTypeToSchemaSet(type.BaseType, schemaSet, serializationManager);
if (baseTypeQualifiedName != null)
{
// <xs:extensions base="address">
var complexContentExtension = new XmlSchemaComplexContentExtension();
complexContentExtension.BaseTypeName = baseTypeQualifiedName;
complexContentExtension.Particle = propertiesSequence;
// <xs:complexContent>
var complexContent = new XmlSchemaComplexContent();
complexContent.Content = complexContentExtension;
modelBaseType.ContentModel = complexContent;
}
return modelBaseType;
}
static string GetMarkup(XmlSchemaAnnotation ann, string filter, string language)
{
StringBuilder sb = new StringBuilder();
foreach (XmlSchemaObject o in ann.Items) {
// for xs:documentation nodes
if (o is XmlSchemaDocumentation) {
XmlSchemaDocumentation d = (XmlSchemaDocumentation)o;
if (string.IsNullOrEmpty(language) || d.Language == language)
{
XmlNode[] ma = d.Markup;
if (ma != null)
{
// if we only have the xs:documentation node (no markup)...
foreach (XmlNode n in ma)
{
if (!string.IsNullOrEmpty(filter))
{
if (string.Compare(filter, n.LocalName, StringComparison.InvariantCultureIgnoreCase) == 0)
{
sb.Append(n.InnerText);
}
}
else
{
sb.Append(n.InnerText);
}
}
}
}
}
}
return sb.ToString();
}
private void PreprocessAnnotation(XmlSchemaAnnotation annotation) {
ValidateIdAttribute(annotation);
foreach (XmlSchemaObject obj in annotation.Items) {
obj.Parent = annotation; //Can be documentation or appInfo
}
}
/// <summary>
/// Adds an attribute value to the completion data collection.
/// </summary>
static void AddAttributeValue(XmlCompletionItemCollection completionItems, string valueText, XmlSchemaAnnotation annotation)
{
string documentation = GetDocumentation(annotation);
XmlCompletionItem item = new XmlCompletionItem(valueText, documentation, XmlCompletionItemType.XmlAttributeValue);
completionItems.Add(item);
}
//<restriction
//base = QName
//id = ID
//{any attributes with non-schema namespace . . .}>
//Content: (annotation?, (simpleType?, (minExclusive | minInclusive | maxExclusive | maxInclusive | totalDigits | fractionDigits | length | minLength | maxLength | enumeration | whiteSpace | pattern)*)?, ((attribute | attributeGroup)*, anyAttribute?))
//</restriction>
internal static XmlSchemaSimpleContentRestriction Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaSimpleContentRestriction restriction = new XmlSchemaSimpleContentRestriction();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaComplexContentRestriction.Read, name=" + reader.Name, null);
reader.SkipToEnd();
return(null);
}
restriction.LineNumber = reader.LineNumber;
restriction.LinePosition = reader.LinePosition;
restriction.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "base")
{
Exception innerex;
restriction.baseTypeName = XmlSchemaUtil.ReadQNameAttribute(reader, out innerex);
if (innerex != null)
{
error(h, reader.Value + " is not a valid value for base attribute", innerex);
}
}
else if (reader.Name == "id")
{
restriction.Id = reader.Value;
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for restriction", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, restriction);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(restriction);
}
//Content: 1.annotation?,
// 2.simpleType?,
// 3.(minExclusive |...| enumeration | whiteSpace | pattern)*,
// 4.(attribute | attributeGroup)*,
// 5.anyAttribute?
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaSimpleContentRestriction.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)
{
restriction.Annotation = annotation;
}
continue;
}
if (level <= 2 && reader.LocalName == "simpleType")
{
level = 3;
XmlSchemaSimpleType stype = XmlSchemaSimpleType.Read(reader, h);
if (stype != null)
{
restriction.baseType = stype;
}
continue;
}
if (level <= 3)
{
if (reader.LocalName == "minExclusive")
{
level = 3;
XmlSchemaMinExclusiveFacet minex = XmlSchemaMinExclusiveFacet.Read(reader, h);
if (minex != null)
{
restriction.facets.Add(minex);
}
continue;
}
else if (reader.LocalName == "minInclusive")
{
level = 3;
XmlSchemaMinInclusiveFacet mini = XmlSchemaMinInclusiveFacet.Read(reader, h);
if (mini != null)
{
restriction.facets.Add(mini);
}
continue;
}
else if (reader.LocalName == "maxExclusive")
{
level = 3;
XmlSchemaMaxExclusiveFacet maxex = XmlSchemaMaxExclusiveFacet.Read(reader, h);
if (maxex != null)
{
restriction.facets.Add(maxex);
}
continue;
}
else if (reader.LocalName == "maxInclusive")
{
level = 3;
XmlSchemaMaxInclusiveFacet maxi = XmlSchemaMaxInclusiveFacet.Read(reader, h);
if (maxi != null)
{
restriction.facets.Add(maxi);
}
continue;
}
else if (reader.LocalName == "totalDigits")
{
level = 3;
XmlSchemaTotalDigitsFacet total = XmlSchemaTotalDigitsFacet.Read(reader, h);
if (total != null)
{
restriction.facets.Add(total);
}
continue;
}
else if (reader.LocalName == "fractionDigits")
{
level = 3;
XmlSchemaFractionDigitsFacet fraction = XmlSchemaFractionDigitsFacet.Read(reader, h);
if (fraction != null)
{
restriction.facets.Add(fraction);
}
continue;
}
else if (reader.LocalName == "length")
{
level = 3;
XmlSchemaLengthFacet length = XmlSchemaLengthFacet.Read(reader, h);
if (length != null)
{
restriction.facets.Add(length);
}
continue;
}
else if (reader.LocalName == "minLength")
{
level = 3;
XmlSchemaMinLengthFacet minlen = XmlSchemaMinLengthFacet.Read(reader, h);
if (minlen != null)
{
restriction.facets.Add(minlen);
}
continue;
}
else if (reader.LocalName == "maxLength")
{
level = 3;
XmlSchemaMaxLengthFacet maxlen = XmlSchemaMaxLengthFacet.Read(reader, h);
if (maxlen != null)
{
restriction.facets.Add(maxlen);
}
continue;
}
else if (reader.LocalName == "enumeration")
{
level = 3;
XmlSchemaEnumerationFacet enumeration = XmlSchemaEnumerationFacet.Read(reader, h);
if (enumeration != null)
{
restriction.facets.Add(enumeration);
}
continue;
}
else if (reader.LocalName == "whiteSpace")
{
level = 3;
XmlSchemaWhiteSpaceFacet ws = XmlSchemaWhiteSpaceFacet.Read(reader, h);
if (ws != null)
{
restriction.facets.Add(ws);
}
continue;
}
else if (reader.LocalName == "pattern")
{
level = 3;
XmlSchemaPatternFacet pattern = XmlSchemaPatternFacet.Read(reader, h);
if (pattern != null)
{
restriction.facets.Add(pattern);
}
continue;
}
}
if (level <= 4)
{
if (reader.LocalName == "attribute")
{
level = 4;
XmlSchemaAttribute attr = XmlSchemaAttribute.Read(reader, h);
if (attr != null)
{
restriction.Attributes.Add(attr);
}
continue;
}
if (reader.LocalName == "attributeGroup")
{
level = 4;
XmlSchemaAttributeGroupRef attr = XmlSchemaAttributeGroupRef.Read(reader, h);
if (attr != null)
{
restriction.attributes.Add(attr);
}
continue;
}
}
if (level <= 5 && reader.LocalName == "anyAttribute")
{
level = 6;
XmlSchemaAnyAttribute anyattr = XmlSchemaAnyAttribute.Read(reader, h);
if (anyattr != null)
{
restriction.AnyAttribute = anyattr;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(restriction);
}
/// <summary>
/// Adds an element completion data to the collection if it does not
/// already exist.
/// </summary>
static void AddElement(XmlCompletionItemCollection completionItems, string name, string prefix, XmlSchemaAnnotation annotation)
{
string documentation = GetDocumentation(annotation);
AddElement(completionItems, name, prefix, documentation);
}
private void HandleAnnotations (XmlSchemaAnnotation an, bool nested)
{
foreach (XmlSchemaObject content in an.Items) {
XmlSchemaAppInfo ai = content as XmlSchemaAppInfo;
if (ai != null) {
foreach (XmlNode n in ai.Markup) {
XmlElement el = n as XmlElement;
// #325464 debugging
//Console.WriteLine ("Name: " + el.LocalName + " NS: " + el.NamespaceURI + " Const: " + XmlConstants.MsdataNamespace);
if (el != null && el.LocalName == "Relationship" && el.NamespaceURI == XmlConstants.MsdataNamespace)
HandleRelationshipAnnotation (el, nested);
#if NET_2_0
if (el != null && el.LocalName == "DataSource" && el.NamespaceURI == XmlConstants.MsdatasourceNamespace)
HandleDataSourceAnnotation (el, nested);
#endif
}
}
}
}
internal static XmlSchemaSimpleContentRestriction Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaSimpleContentRestriction xmlSchemaSimpleContentRestriction = new XmlSchemaSimpleContentRestriction();
reader.MoveToElement();
if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "restriction")
{
XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaComplexContentRestriction.Read, name=" + reader.Name, null);
reader.SkipToEnd();
return(null);
}
xmlSchemaSimpleContentRestriction.LineNumber = reader.LineNumber;
xmlSchemaSimpleContentRestriction.LinePosition = reader.LinePosition;
xmlSchemaSimpleContentRestriction.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "base")
{
Exception ex;
xmlSchemaSimpleContentRestriction.baseTypeName = XmlSchemaUtil.ReadQNameAttribute(reader, out ex);
if (ex != null)
{
XmlSchemaObject.error(h, reader.Value + " is not a valid value for base attribute", ex);
}
}
else if (reader.Name == "id")
{
xmlSchemaSimpleContentRestriction.Id = reader.Value;
}
else if ((reader.NamespaceURI == string.Empty && reader.Name != "xmlns") || reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema")
{
XmlSchemaObject.error(h, reader.Name + " is not a valid attribute for restriction", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaSimpleContentRestriction);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(xmlSchemaSimpleContentRestriction);
}
int num = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != "restriction")
{
XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaSimpleContentRestriction.Read, name=" + reader.Name, null);
}
break;
}
if (num <= 1 && reader.LocalName == "annotation")
{
num = 2;
XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h);
if (xmlSchemaAnnotation != null)
{
xmlSchemaSimpleContentRestriction.Annotation = xmlSchemaAnnotation;
}
}
else if (num <= 2 && reader.LocalName == "simpleType")
{
num = 3;
XmlSchemaSimpleType xmlSchemaSimpleType = XmlSchemaSimpleType.Read(reader, h);
if (xmlSchemaSimpleType != null)
{
xmlSchemaSimpleContentRestriction.baseType = xmlSchemaSimpleType;
}
}
else
{
if (num <= 3)
{
if (reader.LocalName == "minExclusive")
{
num = 3;
XmlSchemaMinExclusiveFacet xmlSchemaMinExclusiveFacet = XmlSchemaMinExclusiveFacet.Read(reader, h);
if (xmlSchemaMinExclusiveFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaMinExclusiveFacet);
}
continue;
}
if (reader.LocalName == "minInclusive")
{
num = 3;
XmlSchemaMinInclusiveFacet xmlSchemaMinInclusiveFacet = XmlSchemaMinInclusiveFacet.Read(reader, h);
if (xmlSchemaMinInclusiveFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaMinInclusiveFacet);
}
continue;
}
if (reader.LocalName == "maxExclusive")
{
num = 3;
XmlSchemaMaxExclusiveFacet xmlSchemaMaxExclusiveFacet = XmlSchemaMaxExclusiveFacet.Read(reader, h);
if (xmlSchemaMaxExclusiveFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaMaxExclusiveFacet);
}
continue;
}
if (reader.LocalName == "maxInclusive")
{
num = 3;
XmlSchemaMaxInclusiveFacet xmlSchemaMaxInclusiveFacet = XmlSchemaMaxInclusiveFacet.Read(reader, h);
if (xmlSchemaMaxInclusiveFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaMaxInclusiveFacet);
}
continue;
}
if (reader.LocalName == "totalDigits")
{
num = 3;
XmlSchemaTotalDigitsFacet xmlSchemaTotalDigitsFacet = XmlSchemaTotalDigitsFacet.Read(reader, h);
if (xmlSchemaTotalDigitsFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaTotalDigitsFacet);
}
continue;
}
if (reader.LocalName == "fractionDigits")
{
num = 3;
XmlSchemaFractionDigitsFacet xmlSchemaFractionDigitsFacet = XmlSchemaFractionDigitsFacet.Read(reader, h);
if (xmlSchemaFractionDigitsFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaFractionDigitsFacet);
}
continue;
}
if (reader.LocalName == "length")
{
num = 3;
XmlSchemaLengthFacet xmlSchemaLengthFacet = XmlSchemaLengthFacet.Read(reader, h);
if (xmlSchemaLengthFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaLengthFacet);
}
continue;
}
if (reader.LocalName == "minLength")
{
num = 3;
XmlSchemaMinLengthFacet xmlSchemaMinLengthFacet = XmlSchemaMinLengthFacet.Read(reader, h);
if (xmlSchemaMinLengthFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaMinLengthFacet);
}
continue;
}
if (reader.LocalName == "maxLength")
{
num = 3;
XmlSchemaMaxLengthFacet xmlSchemaMaxLengthFacet = XmlSchemaMaxLengthFacet.Read(reader, h);
if (xmlSchemaMaxLengthFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaMaxLengthFacet);
}
continue;
}
if (reader.LocalName == "enumeration")
{
num = 3;
XmlSchemaEnumerationFacet xmlSchemaEnumerationFacet = XmlSchemaEnumerationFacet.Read(reader, h);
if (xmlSchemaEnumerationFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaEnumerationFacet);
}
continue;
}
if (reader.LocalName == "whiteSpace")
{
num = 3;
XmlSchemaWhiteSpaceFacet xmlSchemaWhiteSpaceFacet = XmlSchemaWhiteSpaceFacet.Read(reader, h);
if (xmlSchemaWhiteSpaceFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaWhiteSpaceFacet);
}
continue;
}
if (reader.LocalName == "pattern")
{
num = 3;
XmlSchemaPatternFacet xmlSchemaPatternFacet = XmlSchemaPatternFacet.Read(reader, h);
if (xmlSchemaPatternFacet != null)
{
xmlSchemaSimpleContentRestriction.facets.Add(xmlSchemaPatternFacet);
}
continue;
}
}
if (num <= 4)
{
if (reader.LocalName == "attribute")
{
num = 4;
XmlSchemaAttribute xmlSchemaAttribute = XmlSchemaAttribute.Read(reader, h);
if (xmlSchemaAttribute != null)
{
xmlSchemaSimpleContentRestriction.Attributes.Add(xmlSchemaAttribute);
}
continue;
}
if (reader.LocalName == "attributeGroup")
{
num = 4;
XmlSchemaAttributeGroupRef xmlSchemaAttributeGroupRef = XmlSchemaAttributeGroupRef.Read(reader, h);
if (xmlSchemaAttributeGroupRef != null)
{
xmlSchemaSimpleContentRestriction.attributes.Add(xmlSchemaAttributeGroupRef);
}
continue;
}
}
if (num <= 5 && reader.LocalName == "anyAttribute")
{
num = 6;
XmlSchemaAnyAttribute xmlSchemaAnyAttribute = XmlSchemaAnyAttribute.Read(reader, h);
if (xmlSchemaAnyAttribute != null)
{
xmlSchemaSimpleContentRestriction.AnyAttribute = xmlSchemaAnyAttribute;
}
}
else
{
reader.RaiseInvalidElementError();
}
}
}
return(xmlSchemaSimpleContentRestriction);
}
/// <summary>
/// Creates a new instance of the <see cref="NAntSchemaGenerator" />
/// class.
/// </summary>
/// <param name="tasks">Tasks for which a schema should be generated.</param>
/// <param name="dataTypes">Data Types for which a schema should be generated.</param>
/// <param name="targetNS">The namespace to use.
/// <example> http://tempuri.org/nant.xsd </example>
/// </param>
public NAntSchemaGenerator(Type[] tasks, Type[] dataTypes, string targetNS)
{
//setup namespace stuff
if (targetNS != null) {
_nantSchema.TargetNamespace = targetNS;
_nantSchema.Namespaces.Add("nant", _nantSchema.TargetNamespace);
}
// add XSD namespace so that all xsd elements are prefix'd
_nantSchema.Namespaces.Add("xs", XmlSchema.Namespace);
_nantSchema.ElementFormDefault = XmlSchemaForm.Qualified;
// initialize stuff
_nantComplexTypes = new HybridDictionary(tasks.Length + dataTypes.Length);
XmlSchemaAnnotation schemaAnnotation = new XmlSchemaAnnotation();
XmlSchemaDocumentation schemaDocumentation = new XmlSchemaDocumentation();
string doc = String.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("String_SchemaGenerated"), DateTime.Now);
schemaDocumentation.Markup = TextToNodeArray(doc);
schemaAnnotation.Items.Add(schemaDocumentation);
_nantSchema.Items.Add(schemaAnnotation);
// create temp list of taskcontainer Complex Types
ArrayList taskContainerComplexTypes = new ArrayList(4);
XmlSchemaComplexType containerCT = FindOrCreateComplexType(typeof(TaskContainer));
if (containerCT.Particle == null) {
// just create empty sequence to which elements will
// be added later
containerCT.Particle = CreateXsdSequence(0, Decimal.MaxValue);
}
taskContainerComplexTypes.Add(containerCT);
// create temp list of task Complex Types
ArrayList dataTypeComplexTypes = new ArrayList(dataTypes.Length);
foreach (Type t in dataTypes) {
dataTypeComplexTypes.Add(FindOrCreateComplexType(t));
}
foreach (Type t in tasks) {
XmlSchemaComplexType taskCT = FindOrCreateComplexType(t);
// allow any tasks...
if (t.IsSubclassOf(typeof(TaskContainer))) {
taskContainerComplexTypes.Add(taskCT);
}
}
Compile();
// update the taskcontainerCTs to allow any other task and the
// list of tasks generated
foreach(XmlSchemaComplexType ct in taskContainerComplexTypes) {
XmlSchemaSequence seq = ct.Particle as XmlSchemaSequence;
if (seq != null) {
seq.Items.Add(CreateTaskListComplexType(tasks).Particle);
} else {
logger.Error("Unable to fixup complextype with children. Particle is not XmlSchemaSequence");
}
}
Compile();
// create target ComplexType
_targetCT = CreateTaskListComplexType(tasks, dataTypes, false);
_targetCT.Name = "Target";
// This is a response to Bug#: 3058913. If not considered neccessary, remove line below.
_targetCT.IsMixed = true;
// name attribute
_targetCT.Attributes.Add(CreateXsdAttribute("name", true));
// depends attribute
_targetCT.Attributes.Add(CreateXsdAttribute("depends", false));
// description attribute
_targetCT.Attributes.Add(CreateXsdAttribute("description", false));
// if attribute
_targetCT.Attributes.Add(CreateXsdAttribute("if", false));
// unless attribute
_targetCT.Attributes.Add(CreateXsdAttribute("unless", false));
_nantSchema.Items.Add(_targetCT);
Compile();
// Generate project Element and ComplexType
XmlSchemaElement projectElement = new XmlSchemaElement();
projectElement.Name = "project";
XmlSchemaComplexType projectCT = CreateTaskListComplexType(tasks, dataTypes, true);
projectElement.SchemaType = projectCT;
//name attribute
projectCT.Attributes.Add(CreateXsdAttribute("name", true));
//default attribute
projectCT.Attributes.Add(CreateXsdAttribute("default", false));
//basedir attribute
projectCT.Attributes.Add(CreateXsdAttribute("basedir", false));
_nantSchema.Items.Add(projectElement);
Compile();
}
private void PreprocessAnnotation(XmlSchemaAnnotation annotation) {
ValidateIdAttribute(annotation);
for (int i = 0; i < annotation.Items.Count; ++i) {
annotation.Items[i].Parent = annotation; //Can be documentation or appInfo
}
}
internal override void AddAnnotation(XmlSchemaAnnotation annotation)
{
this.items.Add(annotation);
}
private void AddXmlnsAnnotation(XmlSchemaComplexType type, string xmlnsMemberName)
{
XmlSchemaAnnotation annotation = new XmlSchemaAnnotation();
XmlSchemaAppInfo item = new XmlSchemaAppInfo();
XmlDocument document = new XmlDocument();
XmlElement element = document.CreateElement("keepNamespaceDeclarations");
if (xmlnsMemberName != null)
{
element.InsertBefore(document.CreateTextNode(xmlnsMemberName), null);
}
item.Markup = new XmlNode[] { element };
annotation.Items.Add(item);
type.Annotation = annotation;
}
void AddXmlnsAnnotation(XmlSchemaComplexType type, string xmlnsMemberName) {
XmlSchemaAnnotation annotation = new XmlSchemaAnnotation();
XmlSchemaAppInfo appinfo = new XmlSchemaAppInfo();
XmlDocument d = new XmlDocument();
XmlElement e = d.CreateElement("keepNamespaceDeclarations");
if (xmlnsMemberName != null)
e.InsertBefore(d.CreateTextNode(xmlnsMemberName), null);
appinfo.Markup = new XmlNode[] {e};
annotation.Items.Add(appinfo);
type.Annotation = annotation;
}
internal static XmlSchemaAttribute Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaAttribute xmlSchemaAttribute = new XmlSchemaAttribute();
reader.MoveToElement();
if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "attribute")
{
XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaAttribute.Read, name=" + reader.Name, null);
reader.SkipToEnd();
return(null);
}
xmlSchemaAttribute.LineNumber = reader.LineNumber;
xmlSchemaAttribute.LinePosition = reader.LinePosition;
xmlSchemaAttribute.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "default")
{
xmlSchemaAttribute.defaultValue = reader.Value;
}
else if (reader.Name == "fixed")
{
xmlSchemaAttribute.fixedValue = reader.Value;
}
else if (reader.Name == "form")
{
Exception ex;
xmlSchemaAttribute.form = XmlSchemaUtil.ReadFormAttribute(reader, out ex);
if (ex != null)
{
XmlSchemaObject.error(h, reader.Value + " is not a valid value for form attribute", ex);
}
}
else if (reader.Name == "id")
{
xmlSchemaAttribute.Id = reader.Value;
}
else if (reader.Name == "name")
{
xmlSchemaAttribute.name = reader.Value;
}
else if (reader.Name == "ref")
{
Exception ex2;
xmlSchemaAttribute.refName = XmlSchemaUtil.ReadQNameAttribute(reader, out ex2);
if (ex2 != null)
{
XmlSchemaObject.error(h, reader.Value + " is not a valid value for ref attribute", ex2);
}
}
else if (reader.Name == "type")
{
Exception ex3;
xmlSchemaAttribute.schemaTypeName = XmlSchemaUtil.ReadQNameAttribute(reader, out ex3);
if (ex3 != null)
{
XmlSchemaObject.error(h, reader.Value + " is not a valid value for type attribute", ex3);
}
}
else if (reader.Name == "use")
{
Exception ex4;
xmlSchemaAttribute.use = XmlSchemaUtil.ReadUseAttribute(reader, out ex4);
if (ex4 != null)
{
XmlSchemaObject.error(h, reader.Value + " is not a valid value for use attribute", ex4);
}
}
else if ((reader.NamespaceURI == string.Empty && reader.Name != "xmlns") || reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema")
{
XmlSchemaObject.error(h, reader.Name + " is not a valid attribute for attribute", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaAttribute);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(xmlSchemaAttribute);
}
int num = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != "attribute")
{
XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaAttribute.Read, name=" + reader.Name, null);
}
break;
}
if (num <= 1 && reader.LocalName == "annotation")
{
num = 2;
XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h);
if (xmlSchemaAnnotation != null)
{
xmlSchemaAttribute.Annotation = xmlSchemaAnnotation;
}
}
else if (num <= 2 && reader.LocalName == "simpleType")
{
num = 3;
XmlSchemaSimpleType xmlSchemaSimpleType = XmlSchemaSimpleType.Read(reader, h);
if (xmlSchemaSimpleType != null)
{
xmlSchemaAttribute.schemaType = xmlSchemaSimpleType;
}
}
else
{
reader.RaiseInvalidElementError();
}
}
return(xmlSchemaAttribute);
}
/*
* internal new void error(ValidationEventHandler handle, string message)
* {
* errorCount++;
* ValidationHandler.RaiseValidationError(handle, this, message);
* }
*/
//<key
// id = ID
// name = NCName
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (selector, field+))
//</key>
internal static XmlSchemaKey Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaKey key = new XmlSchemaKey();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaKey.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
key.LineNumber = reader.LineNumber;
key.LinePosition = reader.LinePosition;
key.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
key.Id = reader.Value;
}
else if (reader.Name == "name")
{
key.Name = reader.Value;
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for key", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, key);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(key);
}
// Content: annotation?, selector, field+
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaKey.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)
{
key.Annotation = annotation;
}
continue;
}
if (level <= 2 && reader.LocalName == "selector")
{
level = 3;
XmlSchemaXPath selector = XmlSchemaXPath.Read(reader, h, "selector");
if (selector != null)
{
key.Selector = selector;
}
continue;
}
if (level <= 3 && reader.LocalName == "field")
{
level = 3;
if (key.Selector == null)
{
error(h, "selector must be defined before field declarations", null);
}
XmlSchemaXPath field = XmlSchemaXPath.Read(reader, h, "field");
if (field != null)
{
key.Fields.Add(field);
}
continue;
}
reader.RaiseInvalidElementError();
}
return(key);
}
private void SetContainer(State state, object container) {
switch (state) {
case State.Root:
break;
case State.Schema:
break;
case State.Annotation:
this.annotation = (XmlSchemaAnnotation)container;
break;
case State.Include:
this.include = (XmlSchemaInclude)container;
break;
case State.Import:
this.import = (XmlSchemaImport)container;
break;
case State.Element:
this.element = (XmlSchemaElement)container;
break;
case State.Attribute:
this.attribute = (XmlSchemaAttribute)container;
break;
case State.AttributeGroup:
this.attributeGroup = (XmlSchemaAttributeGroup)container;
break;
case State.AttributeGroupRef:
this.attributeGroupRef = (XmlSchemaAttributeGroupRef)container;
break;
case State.AnyAttribute:
this.anyAttribute = (XmlSchemaAnyAttribute)container;
break;
case State.Group:
this.group = (XmlSchemaGroup)container;
break;
case State.GroupRef:
this.groupRef = (XmlSchemaGroupRef)container;
break;
case State.All:
this.all = (XmlSchemaAll)container;
break;
case State.Choice:
this.choice = (XmlSchemaChoice)container;
break;
case State.Sequence:
this.sequence = (XmlSchemaSequence)container;
break;
case State.Any:
this.anyElement = (XmlSchemaAny)container;
break;
case State.Notation:
this.notation = (XmlSchemaNotation)container;
break;
case State.SimpleType:
this.simpleType = (XmlSchemaSimpleType)container;
break;
case State.ComplexType:
this.complexType = (XmlSchemaComplexType)container;
break;
case State.ComplexContent:
this.complexContent = (XmlSchemaComplexContent)container;
break;
case State.ComplexContentExtension:
this.complexContentExtension = (XmlSchemaComplexContentExtension)container;
break;
case State.ComplexContentRestriction:
this.complexContentRestriction = (XmlSchemaComplexContentRestriction)container;
break;
case State.SimpleContent:
this.simpleContent = (XmlSchemaSimpleContent)container;
break;
case State.SimpleContentExtension:
this.simpleContentExtension = (XmlSchemaSimpleContentExtension)container;
break;
case State.SimpleContentRestriction:
this.simpleContentRestriction = (XmlSchemaSimpleContentRestriction)container;
break;
case State.SimpleTypeUnion:
this.simpleTypeUnion = (XmlSchemaSimpleTypeUnion)container;
break;
case State.SimpleTypeList:
this.simpleTypeList = (XmlSchemaSimpleTypeList)container;
break;
case State.SimpleTypeRestriction:
this.simpleTypeRestriction = (XmlSchemaSimpleTypeRestriction)container;
break;
case State.Unique:
case State.Key:
case State.KeyRef:
this.identityConstraint = (XmlSchemaIdentityConstraint)container;
break;
case State.Selector:
case State.Field:
this.xpath = (XmlSchemaXPath)container;
break;
case State.MinExclusive:
case State.MinInclusive:
case State.MaxExclusive:
case State.MaxInclusive:
case State.TotalDigits:
case State.FractionDigits:
case State.Length:
case State.MinLength:
case State.MaxLength:
case State.Enumeration:
case State.Pattern:
case State.WhiteSpace:
this.facet = (XmlSchemaFacet)container;
break;
case State.AppInfo:
this.appInfo = (XmlSchemaAppInfo)container;
break;
case State.Documentation:
this.documentation = (XmlSchemaDocumentation)container;
break;
case State.Redefine:
this.redefine = (XmlSchemaRedefine)container;
break;
default:
Debug.Assert(false, "State is " + state);
break;
}
}
internal static XmlSchemaGroup Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaGroup xmlSchemaGroup = new XmlSchemaGroup();
reader.MoveToElement();
if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "group")
{
XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaGroup.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
xmlSchemaGroup.LineNumber = reader.LineNumber;
xmlSchemaGroup.LinePosition = reader.LinePosition;
xmlSchemaGroup.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
xmlSchemaGroup.Id = reader.Value;
}
else if (reader.Name == "name")
{
xmlSchemaGroup.name = reader.Value;
}
else if ((reader.NamespaceURI == string.Empty && reader.Name != "xmlns") || reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema")
{
XmlSchemaObject.error(h, reader.Name + " is not a valid attribute for group", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaGroup);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(xmlSchemaGroup);
}
int num = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != "group")
{
XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaGroup.Read, name=" + reader.Name, null);
}
break;
}
if (num <= 1 && reader.LocalName == "annotation")
{
num = 2;
XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h);
if (xmlSchemaAnnotation != null)
{
xmlSchemaGroup.Annotation = xmlSchemaAnnotation;
}
}
else
{
if (num <= 2)
{
if (reader.LocalName == "all")
{
num = 3;
XmlSchemaAll xmlSchemaAll = XmlSchemaAll.Read(reader, h);
if (xmlSchemaAll != null)
{
xmlSchemaGroup.Particle = xmlSchemaAll;
}
continue;
}
if (reader.LocalName == "choice")
{
num = 3;
XmlSchemaChoice xmlSchemaChoice = XmlSchemaChoice.Read(reader, h);
if (xmlSchemaChoice != null)
{
xmlSchemaGroup.Particle = xmlSchemaChoice;
}
continue;
}
if (reader.LocalName == "sequence")
{
num = 3;
XmlSchemaSequence xmlSchemaSequence = XmlSchemaSequence.Read(reader, h);
if (xmlSchemaSequence != null)
{
xmlSchemaGroup.Particle = xmlSchemaSequence;
}
continue;
}
}
reader.RaiseInvalidElementError();
}
}
return(xmlSchemaGroup);
}
internal virtual void AddAnnotation(XmlSchemaAnnotation annotation)
{
}
//<any
// id = ID
// maxOccurs = (nonNegativeInteger | unbounded) : 1
// minOccurs = nonNegativeInteger : 1
// namespace = ((##any | ##other) | List of (anyURI | (##targetNamespace | ##local)) ) : ##any
// processContents = (lax | skip | strict) : strict
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?)
//</any>
internal static XmlSchemaAny Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaAny any = new XmlSchemaAny();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaAny.Read, name=" + reader.Name, null);
reader.SkipToEnd();
return(null);
}
any.LineNumber = reader.LineNumber;
any.LinePosition = reader.LinePosition;
any.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
any.Id = reader.Value;
}
else if (reader.Name == "maxOccurs")
{
try
{
any.MaxOccursString = reader.Value;
}
catch (Exception e)
{
error(h, reader.Value + " is an invalid value for maxOccurs", e);
}
}
else if (reader.Name == "minOccurs")
{
try
{
any.MinOccursString = reader.Value;
}
catch (Exception e)
{
error(h, reader.Value + " is an invalid value for minOccurs", e);
}
}
else if (reader.Name == "namespace")
{
any.nameSpace = reader.Value;
}
else if (reader.Name == "processContents")
{
Exception innerex;
any.processing = XmlSchemaUtil.ReadProcessingAttribute(reader, out innerex);
if (innerex != null)
{
error(h, reader.Value + " is not a valid value for processContents", innerex);
}
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for any", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, any);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(any);
}
// Content: (annotation?)
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaAny.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)
{
any.Annotation = annotation;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(any);
}
//From the Errata
//<group
// id = ID
// name = NCName
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (all | choice | sequence)?)
//</group>
internal static XmlSchemaGroup Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaGroup group = new XmlSchemaGroup();
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);
}
group.LineNumber = reader.LineNumber;
group.LinePosition = reader.LinePosition;
group.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
group.Id = reader.Value;
}
else if (reader.Name == "name")
{
group.name = reader.Value;
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for group", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, group);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(group);
}
// Content: (annotation?, (all | choice | sequence)?)
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaGroup.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)
{
group.Annotation = annotation;
}
continue;
}
if (level <= 2)
{
if (reader.LocalName == "all")
{
level = 3;
XmlSchemaAll all = XmlSchemaAll.Read(reader, h);
if (all != null)
{
group.Particle = all;
}
continue;
}
if (reader.LocalName == "choice")
{
level = 3;
XmlSchemaChoice choice = XmlSchemaChoice.Read(reader, h);
if (choice != null)
{
group.Particle = choice;
}
continue;
}
if (reader.LocalName == "sequence")
{
level = 3;
XmlSchemaSequence sequence = XmlSchemaSequence.Read(reader, h);
if (sequence != null)
{
group.Particle = sequence;
}
continue;
}
}
reader.RaiseInvalidElementError();
}
return(group);
}
///<summary>Generate XML schema for the given types
///</summary>
///<param name="ns">Default namespace</param>
///<param name="types">Types to include into schema</param>
///<param name="root">Root element</param>
///<param name="interfaces">Interface types</param>
///<returns>Built schema</returns>
public static XmlSchema BuildSchema(string ns, Type[] types, Type root, Type[] interfaces)
{
XmlSchema xmlSchema = new XmlSchema();
xmlSchema.Namespaces.Add("xsd", "http://www.w3.org/2001/XMLSchema");
xmlSchema.Namespaces.Add("xsi", "http://www.w3.org/2001/XMLSchema-instance");
xmlSchema.ElementFormDefault = XmlSchemaForm.Qualified;
xmlSchema.AttributeFormDefault = XmlSchemaForm.Unqualified;
xmlSchema.Namespaces.Add("ns", ns);
xmlSchema.TargetNamespace = ns;
// Comment
XmlSchemaAnnotation annotation = new XmlSchemaAnnotation();
XmlSchemaDocumentation documentation = new XmlSchemaDocumentation();
XmlDocument helperDocument = new XmlDocument();
string comment = String.Format(" XML schema for {0} , generated at {1} ", ns, DateTime.Now.ToString());
documentation.Markup = new XmlNode[1] { helperDocument.CreateComment(comment) };
annotation.Items.Add(documentation);
xmlSchema.Items.Add(annotation);
// Create group "action" to refer to any action
var ints = new Dictionary<Type, XmlSchemaGroup>();
if (interfaces != null)
{
foreach (var intf in interfaces)
{
var action = new XmlSchemaGroup();
action.Name = getXmlTypeName(intf);
action.Particle = new XmlSchemaChoice();
xmlSchema.Items.Add(action);
ints.Add(intf, action);
}
}
Dictionary<Type, XmlSchemaType> xmlTypes = new Dictionary<Type, XmlSchemaType>();
foreach (var type in types)
{
// If it does not have our XML header - skip it
var na = (CustomAttributeHelper.First<XsTypeAttribute>(type));
if (na == null)
continue;
// Check if it is complex or simple
XmlSchemaComplexType ct = new XmlSchemaComplexType();
ct.Name = getXmlTypeName(type);
XmlSchemaObjectCollection attr = createComplexType(type, ct, ns, ints);
// Add the new element as an option to the "action" group
foreach (var i in ints)
{
bool isAction = (type.FindInterfaces((tp, nu) => tp == i.Key, null).Length != 0);
if (isAction)
{
foreach (var tp in CustomAttributeHelper.All<XsTypeAttribute>(type))
{
if (!string.IsNullOrEmpty(tp.Name))
i.Value.Particle.Items.Add(new XmlSchemaElement
{
Name = tp.Name,
MinOccurs = 0,
SchemaTypeName = new XmlQualifiedName(ct.Name, ns)
});
}
}
}
// Work with attributes
foreach (var o in generateAttributes(xmlSchema, type, xmlTypes, ns))
attr.Add(o);
if (na.AnyAttribute)
{
ct.AnyAttribute = new XmlSchemaAnyAttribute
{
ProcessContents = XmlSchemaContentProcessing.Skip
};
}
// Add type to the list
xmlTypes.Add(type, ct);
xmlSchema.Items.Add(ct);
if (root.IsAssignableFrom(type))
{
// Add all variations of Script names as element
foreach (var o in CustomAttributeHelper.All<XsTypeAttribute>(root))
{
xmlSchema.Items.Add(new XmlSchemaElement
{
Name = o.Name,
SchemaTypeName = new XmlQualifiedName(xmlTypes[typeof(Script)].Name, ns)
});
}
}
}
return xmlSchema;
}
internal override void AddAnnotation(XmlSchemaAnnotation annotation)
{
_items.Add(annotation);
}
internal static XmlSchemaInclude Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaInclude xmlSchemaInclude = new XmlSchemaInclude();
reader.MoveToElement();
if (reader.NamespaceURI != "http://www.w3.org/2001/XMLSchema" || reader.LocalName != "include")
{
XmlSchemaObject.error(h, "Should not happen :1: XmlSchemaInclude.Read, name=" + reader.Name, null);
reader.SkipToEnd();
return(null);
}
xmlSchemaInclude.LineNumber = reader.LineNumber;
xmlSchemaInclude.LinePosition = reader.LinePosition;
xmlSchemaInclude.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
xmlSchemaInclude.Id = reader.Value;
}
else if (reader.Name == "schemaLocation")
{
xmlSchemaInclude.SchemaLocation = reader.Value;
}
else if ((reader.NamespaceURI == string.Empty && reader.Name != "xmlns") || reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema")
{
XmlSchemaObject.error(h, reader.Name + " is not a valid attribute for include", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, xmlSchemaInclude);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(xmlSchemaInclude);
}
int num = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != "include")
{
XmlSchemaObject.error(h, "Should not happen :2: XmlSchemaInclude.Read, name=" + reader.Name, null);
}
break;
}
if (num <= 1 && reader.LocalName == "annotation")
{
num = 2;
XmlSchemaAnnotation xmlSchemaAnnotation = XmlSchemaAnnotation.Read(reader, h);
if (xmlSchemaAnnotation != null)
{
xmlSchemaInclude.Annotation = xmlSchemaAnnotation;
}
}
else
{
reader.RaiseInvalidElementError();
}
}
return(xmlSchemaInclude);
}
//<attributeGroup
// id = ID
// name = NCName
// ref = QName // Not present in this class.
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, ((attribute | attributeGroup)*, anyAttribute?))
//</attributeGroup>
internal static XmlSchemaAttributeGroup Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaAttributeGroup attrgrp = new XmlSchemaAttributeGroup();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaAttributeGroup.Read, name=" + reader.Name, null);
reader.SkipToEnd();
return(null);
}
attrgrp.LineNumber = reader.LineNumber;
attrgrp.LinePosition = reader.LinePosition;
attrgrp.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
attrgrp.Id = reader.Value;
}
else if (reader.Name == "name")
{
attrgrp.name = reader.Value;
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for attributeGroup in this context", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, attrgrp);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(attrgrp);
}
//Content: 1.annotation?, 2.(attribute | attributeGroup)*, 3.anyAttribute?
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaAttributeGroup.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)
{
attrgrp.Annotation = annotation;
}
continue;
}
if (level <= 2)
{
if (reader.LocalName == "attribute")
{
level = 2;
XmlSchemaAttribute attr = XmlSchemaAttribute.Read(reader, h);
if (attr != null)
{
attrgrp.Attributes.Add(attr);
}
continue;
}
if (reader.LocalName == "attributeGroup")
{
level = 2;
XmlSchemaAttributeGroupRef attr = XmlSchemaAttributeGroupRef.Read(reader, h);
if (attr != null)
{
attrgrp.attributes.Add(attr);
}
continue;
}
}
if (level <= 3 && reader.LocalName == "anyAttribute")
{
level = 4;
XmlSchemaAnyAttribute anyattr = XmlSchemaAnyAttribute.Read(reader, h);
if (anyattr != null)
{
attrgrp.AnyAttribute = anyattr;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(attrgrp);
}
//<import
// id = ID
// namespace = anyURI
// schemaLocation = anyURI
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?)
//</import>
internal static XmlSchemaImport Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaImport import = new XmlSchemaImport();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != "import")
{
error(h, "Should not happen :1: XmlSchemaImport.Read, name=" + reader.Name, null);
reader.SkipToEnd();
return(null);
}
import.LineNumber = reader.LineNumber;
import.LinePosition = reader.LinePosition;
import.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
import.Id = reader.Value;
}
else if (reader.Name == "namespace")
{
import.nameSpace = reader.Value;
}
else if (reader.Name == "schemaLocation")
{
import.SchemaLocation = reader.Value;
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for import", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, import);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(import);
}
// Content: (annotation?)
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaImport.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)
{
import.Annotation = annotation;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(import);
}
internal override void AddAnnotation(XmlSchemaAnnotation annotation)
{
_annotation = annotation;
}
//<attribute
// default = string
// fixed = string
// form = (qualified | unqualified)
// id = ID
// name = NCName
// ref = QName
// type = QName
// use = (optional | prohibited | required) : optional
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?, (simpleType?))
//</attribute>
internal static XmlSchemaAttribute Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaAttribute attribute = new XmlSchemaAttribute();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaAttribute.Read, name=" + reader.Name, null);
reader.SkipToEnd();
return(null);
}
attribute.LineNumber = reader.LineNumber;
attribute.LinePosition = reader.LinePosition;
attribute.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "default")
{
attribute.defaultValue = reader.Value;
}
else if (reader.Name == "fixed")
{
attribute.fixedValue = reader.Value;
}
else if (reader.Name == "form")
{
Exception innerex;
attribute.form = XmlSchemaUtil.ReadFormAttribute(reader, out innerex);
if (innerex != null)
{
error(h, reader.Value + " is not a valid value for form attribute", innerex);
}
}
else if (reader.Name == "id")
{
attribute.Id = reader.Value;
}
else if (reader.Name == "name")
{
attribute.name = reader.Value;
}
else if (reader.Name == "ref")
{
Exception innerex;
attribute.refName = XmlSchemaUtil.ReadQNameAttribute(reader, out innerex);
if (innerex != null)
{
error(h, reader.Value + " is not a valid value for ref attribute", innerex);
}
}
else if (reader.Name == "type")
{
Exception innerex;
attribute.schemaTypeName = XmlSchemaUtil.ReadQNameAttribute(reader, out innerex);
if (innerex != null)
{
error(h, reader.Value + " is not a valid value for type attribute", innerex);
}
}
else if (reader.Name == "use")
{
Exception innerex;
attribute.use = XmlSchemaUtil.ReadUseAttribute(reader, out innerex);
if (innerex != null)
{
error(h, reader.Value + " is not a valid value for use attribute", innerex);
}
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for attribute", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, attribute);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(attribute);
}
// Content: (annotation?, (simpleType?))
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaAttribute.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)
{
attribute.Annotation = annotation;
}
continue;
}
if (level <= 2 && reader.LocalName == "simpleType")
{
level = 3;
XmlSchemaSimpleType stype = XmlSchemaSimpleType.Read(reader, h);
if (stype != null)
{
attribute.schemaType = stype;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(attribute);
}
//<fractionDigits
// fixed = boolean : false
// id = ID
// value = nonNegativeInteger
// {any attributes with non-schema namespace . . .}>
// Content: (annotation?)
//</fractionDigits>
internal static XmlSchemaFractionDigitsFacet Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaFractionDigitsFacet fraction = new XmlSchemaFractionDigitsFacet();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaFractionDigitsFacet.Read, name=" + reader.Name, null);
reader.Skip();
return(null);
}
fraction.LineNumber = reader.LineNumber;
fraction.LinePosition = reader.LinePosition;
fraction.SourceUri = reader.BaseURI;
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
fraction.Id = reader.Value;
}
else if (reader.Name == "fixed")
{
Exception innerex;
fraction.IsFixed = XmlSchemaUtil.ReadBoolAttribute(reader, out innerex);
if (innerex != null)
{
error(h, reader.Value + " is not a valid value for fixed attribute", innerex);
}
}
else if (reader.Name == "value")
{
fraction.Value = reader.Value;
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for " + xmlname, null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, fraction);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(fraction);
}
// Content: (annotation?)
int level = 1;
while (reader.ReadNextElement())
{
if (reader.NodeType == XmlNodeType.EndElement)
{
if (reader.LocalName != xmlname)
{
error(h, "Should not happen :2: XmlSchemaFractionDigitsFacet.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)
{
fraction.Annotation = annotation;
}
continue;
}
reader.RaiseInvalidElementError();
}
return(fraction);
}
//<annotation
// id = ID
// {any attributes with non-schema namespace . . .}>
// Content: (appinfo | documentation)*
//</annotation>
internal static XmlSchemaAnnotation Read(XmlSchemaReader reader, ValidationEventHandler h)
{
XmlSchemaAnnotation annotation = new XmlSchemaAnnotation();
reader.MoveToElement();
if (reader.NamespaceURI != XmlSchema.Namespace || reader.LocalName != xmlname)
{
error(h, "Should not happen :1: XmlSchemaAnnotation.Read, name=" + reader.Name, null);
reader.SkipToEnd();
return(null);
}
annotation.LineNumber = reader.LineNumber;
annotation.LinePosition = reader.LinePosition;
annotation.SourceUri = reader.BaseURI;
//Read Attributes
while (reader.MoveToNextAttribute())
{
if (reader.Name == "id")
{
annotation.Id = reader.Value;
}
else if ((reader.NamespaceURI == "" && reader.Name != "xmlns") || reader.NamespaceURI == XmlSchema.Namespace)
{
error(h, reader.Name + " is not a valid attribute for annotation", null);
}
else
{
XmlSchemaUtil.ReadUnhandledAttribute(reader, annotation);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
return(annotation);
}
//Content: (appinfo | documentation)*
bool skip = false;
string expectedEnd = null;
while (!reader.EOF)
{
if (skip)
{
skip = false;
}
else
{
reader.ReadNextElement();
}
if (reader.NodeType == XmlNodeType.EndElement)
{
bool end = true;
string expected = xmlname;
if (expectedEnd != null)
{
expected = expectedEnd;
expectedEnd = null;
end = false;
}
if (reader.LocalName != expected)
{
error(h, "Should not happen :2: XmlSchemaAnnotation.Read, name=" + reader.Name + ",expected=" + expected, null);
}
if (end)
{
break;
}
else
{
continue;
}
}
if (reader.LocalName == "appinfo")
{
XmlSchemaAppInfo appinfo = XmlSchemaAppInfo.Read(reader, h, out skip);
if (appinfo != null)
{
annotation.items.Add(appinfo);
}
continue;
}
if (reader.LocalName == "documentation")
{
XmlSchemaDocumentation documentation = XmlSchemaDocumentation.Read(reader, h, out skip);
if (documentation != null)
{
annotation.items.Add(documentation);
}
continue;
}
reader.RaiseInvalidElementError();
}
return(annotation);
}
