private static void ParseAttributeGroup(Schema schema, string nameSpace, List <XSDAttribute> listAttributes, XMLSchema.attributeGroup attributeGroup, bool isRestriction)
{
if (attributeGroup is XMLSchema.attributeGroupRef && attributeGroup.@ref != null)
{
object o = null;
schema.AttributesByName.TryGetValue(QualifiedNameToFullName("attributeGroup", attributeGroup.@ref), out o);
if (o is XSDAttributeGroup)
{
XSDAttributeGroup xsdAttributeGroup = o as XSDAttributeGroup;
XMLSchema.attributeGroup attributeGroupInstance = xsdAttributeGroup.Tag;
foreach (XMLSchema.annotated annotated in attributeGroupInstance.Items)
{
if (annotated is XMLSchema.attribute)
{
ParseAttribute(schema, nameSpace, listAttributes, annotated as XMLSchema.attribute, isRestriction);
}
else if (annotated is XMLSchema.attributeGroup)
{
ParseAttributeGroup(schema, nameSpace, listAttributes, annotated as XMLSchema.attributeGroup, isRestriction);
}
}
}
}
else
{
}
}
public XSDAttributeGroup(string filename, string name, string nameSpace, string type, bool isReference, XMLSchema.attributeGroup attributeGroup)
{
this.filename = filename;
this.name = name;
this.nameSpace = (nameSpace == null ? "" : nameSpace);
this.type = type;
this.isReference = isReference;
this.tag = attributeGroup;
}
private void ParseSchema(string fileName, string baseUrl, XMLSchema.schema schemaDOM)
{
string basePath = Path.GetDirectoryName(fileName);
if (schemaDOM.Items != null)
{
foreach (XMLSchema.openAttrs openAttrs in schemaDOM.Items)
{
string loadedFileName = "";
string schemaLocation = "";
if (openAttrs is XMLSchema.include)
{
XMLSchema.include include = openAttrs as XMLSchema.include;
if (include.schemaLocation != null)
{
schemaLocation = include.schemaLocation;
}
}
else if (openAttrs is XMLSchema.import)
{
XMLSchema.import import = openAttrs as XMLSchema.import;
if (import.schemaLocation != null)
{
schemaLocation = import.schemaLocation;
}
}
if (!string.IsNullOrEmpty(schemaLocation))
{
schemaLocation = Uri.UnescapeDataString(schemaLocation);
loadedFileName = basePath + Path.DirectorySeparatorChar + schemaLocation.Replace('/', Path.DirectorySeparatorChar);
string url = schemaLocation.Trim();
if (url.IndexOf("http://") == 0 || url.IndexOf("https://") == 0)
{
string lf, bu;
if (LoadSchemaFromUrl(basePath, url, out lf, out bu))
{
loadedFileName = lf;
baseUrl = bu; // The baseUrl change for this file
}
}
else if (!File.Exists(loadedFileName))
{
// The relative file does not exist, so try to download it from the web with the baseUrl
url = baseUrl + "/" + schemaLocation;
string lf, bu;
if (LoadSchemaFromUrl(basePath, url, out lf, out bu))
{
loadedFileName = lf;
baseUrl = bu; // The baseUrl change for this file
}
}
}
if (!string.IsNullOrEmpty(loadedFileName))
{
ImportSchema(loadedFileName, baseUrl);
}
}
}
string nameSpace = schemaDOM.targetNamespace;
if (schemaDOM.Items1 != null)
{
foreach (XMLSchema.openAttrs openAttrs in schemaDOM.Items1)
{
if (openAttrs is XMLSchema.element)
{
XMLSchema.element element = openAttrs as XMLSchema.element;
XSDObject xsdObject = new XSDObject(fileName, element.name, nameSpace, "element", element);
this.hashtableElementsByName[xsdObject.FullName] = xsdObject;
if (this.firstElement == null)
{
this.firstElement = xsdObject;
}
elements.Add(xsdObject);
}
else if (openAttrs is XMLSchema.group)
{
XMLSchema.group group = openAttrs as XMLSchema.group;
XSDObject xsdObject = new XSDObject(fileName, group.name, nameSpace, "group", group);
this.hashtableElementsByName[xsdObject.FullName] = xsdObject;
elements.Add(xsdObject);
}
else if (openAttrs is XMLSchema.simpleType)
{
XMLSchema.simpleType simpleType = openAttrs as XMLSchema.simpleType;
XSDObject xsdObject = new XSDObject(fileName, simpleType.name, nameSpace, "simpleType", simpleType);
this.hashtableElementsByName[xsdObject.FullName] = xsdObject;
elements.Add(xsdObject);
}
else if (openAttrs is XMLSchema.complexType)
{
XMLSchema.complexType complexType = openAttrs as XMLSchema.complexType;
XSDObject xsdObject = new XSDObject(fileName, complexType.name, nameSpace, "complexType", complexType);
this.hashtableElementsByName[xsdObject.FullName] = xsdObject;
elements.Add(xsdObject);
}
else if (openAttrs is XMLSchema.attribute)
{
XMLSchema.attribute attribute = openAttrs as XMLSchema.attribute;
XSDAttribute xsdAttribute = new XSDAttribute(fileName, attribute.name, nameSpace, "attribute", attribute.@ref != null, attribute.@default, attribute.use.ToString(), attribute);
this.hashtableAttributesByName[xsdAttribute.FullName] = xsdAttribute;
}
else if (openAttrs is XMLSchema.attributeGroup)
{
XMLSchema.attributeGroup attributeGroup = openAttrs as XMLSchema.attributeGroup;
XSDAttributeGroup xsdAttributeGroup = new XSDAttributeGroup(fileName, attributeGroup.name, nameSpace, "attributeGroup", attributeGroup is XMLSchema.attributeGroupRef, attributeGroup);
this.hashtableAttributesByName[xsdAttributeGroup.FullName] = xsdAttributeGroup;
}
}
}
}
private static void ParseComplexTypeAttributes(Schema schema, string nameSpace, List <XSDAttribute> listAttributes, XMLSchema.complexType complexType, bool isRestriction)
{
if (complexType.ItemsElementName != null)
{
for (int i = 0; i < complexType.ItemsElementName.Length; i++)
{
switch (complexType.ItemsElementName[i])
{
case XMLSchema.ItemsChoiceType4.attribute:
{
XMLSchema.attribute attribute = complexType.Items[i] as XMLSchema.attribute;
ParseAttribute(schema, nameSpace, listAttributes, attribute, false);
}
break;
case XMLSchema.ItemsChoiceType4.attributeGroup:
{
XMLSchema.attributeGroup attributeGroup = complexType.Items[i] as XMLSchema.attributeGroup;
ParseAttributeGroup(schema, nameSpace, listAttributes, attributeGroup, false);
}
break;
case XMLSchema.ItemsChoiceType4.anyAttribute:
XMLSchema.wildcard wildcard = complexType.Items[i] as XMLSchema.wildcard;
XSDAttribute xsdAttribute = new XSDAttribute("", "*", wildcard.@namespace, "", false, null, null, null);
listAttributes.Add(xsdAttribute);
break;
case XMLSchema.ItemsChoiceType4.simpleContent:
case XMLSchema.ItemsChoiceType4.complexContent:
XMLSchema.annotated annotatedContent = null;
if (complexType.Items[i] is XMLSchema.complexContent)
{
XMLSchema.complexContent complexContent = complexType.Items[i] as XMLSchema.complexContent;
annotatedContent = complexContent.Item;
}
else if (complexType.Items[i] is XMLSchema.simpleContent)
{
XMLSchema.simpleContent simpleContent = complexType.Items[i] as XMLSchema.simpleContent;
annotatedContent = simpleContent.Item;
}
if (annotatedContent is XMLSchema.extensionType)
{
XMLSchema.extensionType extensionType = annotatedContent as XMLSchema.extensionType;
//XSDObject xsdExtensionType = this.schema.ElementsByName[QualifiedNameToFullName("type", extensionType.@base)] as XSDObject;
//if (xsdExtensionType != null)
XSDObject xsdExtensionType;
if (schema.ElementsByName.TryGetValue(QualifiedNameToFullName("type", extensionType.@base), out xsdExtensionType) && xsdExtensionType != null)
{
XMLSchema.annotated annotatedExtension = xsdExtensionType.Tag as XMLSchema.annotated;
if (annotatedExtension != null)
{
if (annotatedExtension is XMLSchema.complexType)
{
ParseComplexTypeAttributes(schema, [email protected], listAttributes, annotatedExtension as XMLSchema.complexType, false);
}
}
}
if (extensionType.Items != null)
{
foreach (XMLSchema.annotated annotated in extensionType.Items)
{
if (annotated is XMLSchema.attribute)
{
ParseAttribute(schema, nameSpace, listAttributes, annotated as XMLSchema.attribute, false);
}
else if (annotated is XMLSchema.attributeGroup)
{
ParseAttributeGroup(schema, nameSpace, listAttributes, annotated as XMLSchema.attributeGroup, false);
}
}
}
}
else if (annotatedContent is XMLSchema.restrictionType)
{
XMLSchema.restrictionType restrictionType = annotatedContent as XMLSchema.restrictionType;
//XSDObject xsdRestrictionType = this.schema.ElementsByName[QualifiedNameToFullName("type", restrictionType.@base)] as XSDObject;
//if (xsdRestrictionType != null)
XSDObject xsdRestrictionType;
if (schema.ElementsByName.TryGetValue(QualifiedNameToFullName("type", restrictionType.@base), out xsdRestrictionType) && xsdRestrictionType != null)
{
XMLSchema.annotated annotatedRestriction = xsdRestrictionType.Tag as XMLSchema.annotated;
if (annotatedRestriction != null)
{
if (annotatedRestriction is XMLSchema.complexType)
{
ParseComplexTypeAttributes(schema, [email protected], listAttributes, annotatedRestriction as XMLSchema.complexType, false);
}
}
}
if (restrictionType.Items1 != null)
{
foreach (XMLSchema.annotated annotated in restrictionType.Items1)
{
if (annotated is XMLSchema.attribute)
{
ParseAttribute(schema, nameSpace, listAttributes, annotated as XMLSchema.attribute, true);
}
else if (annotated is XMLSchema.attributeGroup)
{
ParseAttributeGroup(schema, nameSpace, listAttributes, annotated as XMLSchema.attributeGroup, true);
}
}
}
}
break;
}
}
}
else
{
}
}
public XSDAttributeGroup(string filename, string name, string nameSpace, string type, bool isReference, XMLSchema.attributeGroup attributeGroup)
{
this.filename = filename;
this.name = name;
this.nameSpace = (nameSpace == null ? "" : nameSpace);
this.type = type;
this.isReference = isReference;
this.tag = attributeGroup;
}