Exemple #1
0
        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
            {
            }
        }
Exemple #2
0
 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;
 }
Exemple #3
0
        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;
                    }
                }
            }
        }
Exemple #4
0
        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
            {
            }
        }
Exemple #5
0
 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;
 }