schemaparser.cs

In the previous article, we presented an approach for capturing similarity between words that was co

		
		void Add_ComplexAttributes (TreeNode inner, XmlSchemaComplexType stype)
		{
			Add_Attributes (inner, stype.Attributes, stype.AnyAttribute);
		}
		
		void Add_ComplexElements (TreeNode complexNode, string ns, XmlSchemaComplexType stype)
		{

			if (stype.Particle != null)
			{
				Parse_ParticleComplexContent (complexNode, ns, stype.Particle);
			}
			else
			{
				if (stype.ContentModel is XmlSchemaSimpleContent)
					Parse_SimpleContent (complexNode, (XmlSchemaSimpleContent)stype.ContentModel);
				else if (stype.ContentModel is XmlSchemaComplexContent)
					Parse_ComplexContent (complexNode, ns, (XmlSchemaComplexContent)stype.ContentModel);
			}
		}

		void Add_Attributes (TreeNode innerNode, XmlSchemaObjectCollection atts, XmlSchemaAnyAttribute anyat)
		{
			foreach (XmlSchemaObject at in atts)
			{
				if (at is XmlSchemaAttribute)
				{						
					XmlSchemaAttribute attr=(XmlSchemaAttribute)at;
					XmlSchemaAttribute refAttr=attr;											
					
					if (!attr.RefName.IsEmpty) 
					{
						refAttr=GetRefAttribute (attr.RefName);
						if (refAttr == null) throw new Exception ("Global attribute not found: " + attr.RefName);
					}
					
					string type;
					if (!refAttr.SchemaTypeName.IsEmpty) type=GetBuiltInTypeName (refAttr.SchemaTypeName);
					else type=GetBuiltInType (refAttr.SchemaType);
		            
			        
					TreeNode node=new TreeNode(refAttr.Name) ;
                    node.ImageIndex = 4;
                    node.SelectedImageIndex = 4;
                    string desc = GetAnnotation(refAttr.Annotation);
					if (refAttr.QualifiedName.Namespace != string.Empty)
					{
						node.Text=NamespaceHandler.LoopupPrefix(_namespaces, refAttr.QualifiedName.Namespace ) + ":" + refAttr.Name ;
					}			

					NodeData data=new NodeData(at, refAttr.QualifiedName, type, desc, refAttr.DefaultValue) ;
					node.Tag=data;

					innerNode.Nodes.Add(node) ;						
						
				}
				else if (at is XmlSchemaAttributeGroupRef)
				{
					XmlSchemaAttributeGroupRef gref=(XmlSchemaAttributeGroupRef)at;
					XmlSchemaAttributeGroup grp=(XmlSchemaAttributeGroup) _schemas.Find (gref.RefName, typeof(XmlSchemaAttributeGroup));
					Add_Attributes (innerNode, grp.Attributes, grp.AnyAttribute);
				}
			}
			
			if (anyat != null)
			{
				TreeNode node=new TreeNode("any custom-attribute") ;
				innerNode.Nodes.Add(node) ;				
			}
		}
		
		void Parse_ParticleComplexContent (TreeNode complexNode, string ns, XmlSchemaParticle particle)
		{
			Parse_ParticleContent (complexNode, ns, particle, false);
		}
		
		void Parse_ParticleContent (TreeNode complexNode, string ns, XmlSchemaParticle particle, bool multiValue)
		{
			if (particle is XmlSchemaGroupRef)
				particle=GetRefGroupParticle ((XmlSchemaGroupRef)particle);

			if (particle.MaxOccurs > 1) multiValue=true;
			
			if (particle is XmlSchemaSequence) 
			{
				Parse_SequenceContent (complexNode, ns, ((XmlSchemaSequence)particle).Items, multiValue);
			}
			else if (particle is XmlSchemaChoice) 
			{
				if (((XmlSchemaChoice)particle).Items.Count == 1)
					Parse_SequenceContent (complexNode, ns, ((XmlSchemaChoice)particle).Items, multiValue);
				else
					Parse_ChoiceContent (complexNode, ns, (XmlSchemaChoice)particle, multiValue);
			}
			else if (particle is XmlSchemaAll) 
			{
				Parse_SequenceContent (complexNode, ns, ((XmlSchemaAll)particle).Items, multiValue);
			}
		}

		void Parse_SequenceContent (TreeNode complexNode, string ns, XmlSchemaObjectCollection items, bool multiValue)
		{
			foreach (XmlSchemaObject item in items)
				Add_Item (complexNode, ns, item, multiValue);
		}
		
		void Add_Item (TreeNode complexNode, string ns, XmlSchemaObject item, bool multiValue)
		{
			if (item is XmlSchemaGroupRef)
				item=GetRefGroupParticle ((XmlSchemaGroupRef)item);
					
			if (item is XmlSchemaElement)
			{
				XmlSchemaElement elem=(XmlSchemaElement) item;
				XmlSchemaElement refElem;
				if (!elem.RefName.IsEmpty) refElem=GetRefElement (elem);
				else refElem=elem;

				int num=(elem.MaxOccurs == 1 && !multiValue) ? 1 : 2;

				for (int n=0; n<num; n++)
				{
					if (BindingUse == SoapBindingUse.Literal)
						Add_Element (complexNode, ns, refElem);
					else
						Add_RefType (complexNode, ns, refElem);
				}
			}
			else if (item is XmlSchemaAny)
			{
				TreeNode node=new TreeNode( ("xml")) ;
				complexNode.Nodes.Add(node) ;					
			}
			else if (item is XmlSchemaParticle) 
			{
				Parse_ParticleContent (complexNode, ns, (XmlSchemaParticle)item, multiValue);
			}
		}
		
		void Parse_ChoiceContent (TreeNode inner, string ns, XmlSchemaChoice choice, bool multiValue)
		{
			foreach (XmlSchemaObject item in choice.Items)
				Add_Item (inner, ns, item, multiValue);
		}

		void Parse_SimpleContent (TreeNode inner, XmlSchemaSimpleContent content)
		{
			XmlSchemaSimpleContentExtension ext=content.Content as XmlSchemaSimpleContentExtension;
			XmlSchemaSimpleContentRestriction rst=content.Content as XmlSchemaSimpleContentRestriction;

			if (ext != null)
				Add_Attributes (inner, ext.Attributes, ext.AnyAttribute);
			else
				if (rst != null)
					Add_Attributes (inner, rst.Attributes, rst.AnyAttribute);
			
			XmlQualifiedName qname=GetContentBaseType (content.Content);
			TreeNode node=new TreeNode( (GetBuiltInTypeName (qname))) ;
			inner.Nodes.Add(node) ;				
		}

		string GetBuiltInTypeName (XmlQualifiedName qname)
		{
			if (qname.IsEmpty)
			{
				return "";
			}

			if (qname.Namespace == XmlSchema.Namespace)
				return qname.Name;

			XmlSchemaComplexType ct=GetComplexTypeByName (qname);
			if (ct != null)
			{
				XmlSchemaSimpleContent sc=ct.ContentModel as XmlSchemaSimpleContent;
				if (sc == null) throw new Exception ("Invalid schema");
				return GetBuiltInTypeName (GetContentBaseType (sc.Content));
			}
			
			XmlSchemaSimpleType st=(XmlSchemaSimpleType) _schemas.Find (qname, typeof(XmlSchemaSimpleType));
			if (st != null)
				return GetBuiltInType (st);

			throw new Exception ("Definition of type " + qname + " not found");
		}

		string GetBuiltInType (XmlSchemaSimpleType st)
		{
			if (st == null) return string.Empty ;

			if (st.Content is XmlSchemaSimpleTypeRestriction) 
			{
				return GetBuiltInTypeName (GetContentBaseType (st.Content));
			}
			else if (st.Content is XmlSchemaSimpleTypeList) 
			{
				string s=GetBuiltInTypeName (GetContentBaseType (st.Content));
				return s + " " + s + " ...";// fun but i dont care this kind of types
			}
			else if (st.Content is XmlSchemaSimpleTypeUnion)
			{
				
				XmlSchemaSimpleTypeUnion uni=(XmlSchemaSimpleTypeUnion) st.Content;
				string utype=null;


				if (uni.BaseTypes.Count != 0 && uni.MemberTypes.Length != 0)
					return "string";

				foreach (XmlQualifiedName mt in uni.MemberTypes)
				{
					string qn=GetBuiltInTypeName (mt);
					if (utype != null && qn != utype) return "string";
					else utype=qn;
				}
				return utype;
			}
			else
				return "string";
		}
		

		XmlQualifiedName GetContentBaseType (XmlSchemaObject obj)
		{
			if (obj is XmlSchemaSimpleContentExtension)
				return ((XmlSchemaSimpleContentExtension)obj).BaseTypeName;
			else if (obj is XmlSchemaSimpleContentRestriction)
				return ((XmlSchemaSimpleContentRestriction)obj).BaseTypeName;
			else if (obj is XmlSchemaSimpleTypeRestriction)
				return ((XmlSchemaSimpleTypeRestriction)obj).BaseTypeName;
			else if (obj is XmlSchemaSimpleTypeList)
				return ((XmlSchemaSimpleTypeList)obj).ItemTypeName;
			else
				return null;
		}
		
		const string WsdlNamespace="http://schemas.xmlsoap.org/wsdl/";
		const string SoapEncodingNamespace="http://schemas.xmlsoap.org/soap/encoding/";

		void Parse_ComplexContent (TreeNode inner, string ns, XmlSchemaComplexContent content)
		{
			XmlQualifiedName qname;

			XmlSchemaComplexContentExtension ext=content.Content as XmlSchemaComplexContentExtension;
			if (ext != null) qname=ext.BaseTypeName;
			else 
			{
				XmlSchemaComplexContentRestriction rest=(XmlSchemaComplexContentRestriction)content.Content;
				qname=rest.BaseTypeName;
				
				Add_Attributes (inner, rest.Attributes, rest.AnyAttribute);

				if (qname == arrayType) 
				{
					Parse_ArrayType (rest, out qname);
					XmlSchemaElement elem=new XmlSchemaElement ();
					elem.Name="Item";
					elem.SchemaTypeName=qname;
					
					TreeNode node=new TreeNode("arrayType" + SoapEncodingNamespace + qname.Name + "[2]") ;
					inner.Nodes.Add(node) ;
					Add_Item (inner, ns, elem, true);
					return;
				}
				else
					if (rest.Particle != null)
				{
					//?? Parse rest particle content	?					
					Parse_ParticleComplexContent(inner, ns, rest.Particle);
				}

				return;
			}
			
			
			XmlSchemaComplexType cbase=GetComplexTypeByName (qname);

			if (cbase != null)
			{
				Add_ComplexAttributes (inner, cbase);
				//Add base content first
				Add_ComplexElements (inner, ns, cbase);
			}
			
			if (ext != null) 
			{
				// Add the members of this map
				Add_Attributes (inner, ext.Attributes, ext.AnyAttribute);
				if (ext.Particle != null)
					Parse_ParticleComplexContent (inner, ns, ext.Particle);
			}
			
			
		}
		
		void Parse_ArrayType (XmlSchemaComplexContentRestriction rest, out XmlQualifiedName qtype)
		{
			XmlSchemaAttribute arrayTypeAt=GetArrayAttribute (rest.Attributes);
			XmlAttribute[] uatts=arrayTypeAt.UnhandledAttributes;
			if (uatts == null || uatts.Length == 0) throw new Exception ("arrayType attribute not specified in array declaration");
			
			XmlAttribute xat=null;
			foreach (XmlAttribute at in uatts)
				if (at.LocalName == "arrayType" && at.NamespaceURI == WsdlNamespace)
				{ xat=at; break; }
			
			if (xat == null) 
				throw new Exception ("arrayType attribute not specified in array declaration");
			
			string arrayType=xat.Value;
			string type, ns;
			int i=arrayType.LastIndexOf (":");
			if (i == -1) ns=string.Empty;
			else ns=arrayType.Substring (0,i);
			
			int j=arrayType.IndexOf ("[", i+1);
			if (j == -1) throw new Exception ("Cannot parse WSDL array type: " + arrayType);
			type=arrayType.Substring (i+1);
			type=type.Substring (0, type.Length-2);
			
			qtype=new XmlQualifiedName (type, ns);
		}
		
		XmlSchemaAttribute GetArrayAttribute (XmlSchemaObjectCollection atts)
		{
			foreach (object ob in atts)
			{
				XmlSchemaAttribute att=ob as XmlSchemaAttribute;
				if (att != null && att.RefName == arrayTypeRefName) return att;
				
				XmlSchemaAttributeGroupRef gref=ob as XmlSchemaAttributeGroupRef;
				if (gref != null)
				{
					XmlSchemaAttributeGroup grp=(XmlSchemaAttributeGroup) _schemas.Find (gref.RefName, typeof(XmlSchemaAttributeGroup));
					att=GetArrayAttribute (grp.Attributes);
					if (att != null) return att;
				}
			}
			return null;
		
		}

		void Add_Facet(TreeNode simpleNode, XmlSchemaFacet facet)
		{						
			TreeNode node=new TreeNode(facet.Value) ;
			simpleNode.Nodes.Add(node) ;

		}
		
		void Parse_AnyObject(TreeNode inner, XmlSchemaObject obj)
		{						
			XmlSchemaFacet facet=obj as XmlSchemaFacet;
			XmlSchemaAttribute attrib=obj as XmlSchemaAttribute;

			if (facet != null) 
				Add_Facet(inner, facet);		
			
			Type type=obj.GetType();
			PropertyInfo[] properties=type.GetProperties ();			

			foreach (PropertyInfo property in properties)
			{
				if (property.PropertyType.FullName.Equals(typeof(XmlSchemaObjectCollection).ToString()))
				{
					XmlSchemaObjectCollection somList=property.GetValue(obj, null) as XmlSchemaObjectCollection;

					if (somList != null)
						foreach (XmlSchemaObject somObj in somList) 
						{
							Parse_AnyObject (inner, somObj);
						}
				}				
			}	

		}

		void Parse_SimpleType (TreeNode inner, XmlSchemaSimpleType stype)
		{
			if (inner.Text == string.Empty)
				inner.Text= (GetBuiltInType (stype));

			if (stype.Content != null)			
				Parse_AnyObject (inner, stype.Content);
			

			if (inner.Tag == null)
			{
                string desc=GetAnnotation(stype.Annotation);
				NodeData data=new NodeData(stype, stype.QualifiedName, string.Empty, desc, string.Empty) ;
				inner.Tag=data;
			}
			
		}
		
		XmlSchemaParticle GetRefGroupParticle (XmlSchemaGroupRef refGroup)
		{
			XmlSchemaGroup grp=(XmlSchemaGroup) _schemas.Find (refGroup.RefName, typeof (XmlSchemaGroup));
			return grp.Particle;
		}

		XmlSchemaElement GetRefElement (XmlSchemaElement elem)
		{
			if (elem.RefName.Namespace == XmlSchema.Namespace)
			{
				if (_anyElement != null) return _anyElement;
				return _anyElement;
			}
			return (XmlSchemaElement) _schemas.Find (elem.RefName, typeof(XmlSchemaElement));
		}
		

		
		XmlSchemaAttribute GetRefAttribute (XmlQualifiedName refName)
		{
			if (refName.Namespace == XmlSchema.Namespace)
			{
				XmlSchemaAttribute at=new XmlSchemaAttribute ();
				at.Name=refName.Name;
				at.SchemaTypeName=new XmlQualifiedName ("string",XmlSchema.Namespace);
				return at;
			}
			return (XmlSchemaAttribute) _schemas.Find (refName, typeof(XmlSchemaAttribute));
		}
		
		void Add_RefType (TreeNode inner, string ns, XmlSchemaElement elem)
		{
			if (elem.SchemaTypeName.Namespace == XmlSchema.Namespace || _schemas.Find (elem.SchemaTypeName, typeof(XmlSchemaSimpleType)) != null)
				Add_Element (inner, ns, elem);
			else
			{
				TreeNode node=new TreeNode(elem.Name + ns) ;
				TreeNode node2=new TreeNode("href" + "#id" + (_queue.Count+1)) ;
				node.Nodes.Add(node2) ;
				inner.Nodes.Add(node) ;				
				_queue.Add (new Encoded (ns, elem));
			}
		}
		
		void Parse_QueuedType (TreeNode inner)
		{
			for (int n=0; n<_queue.Count; n++)
			{
				Encoded ec=(Encoded) _queue[n];
				XmlSchemaComplexType st=GetComplexTypeByName (ec.Element.SchemaTypeName);
				Parse_ComplexType (inner, st, ec.Element.SchemaTypeName, n+1);
			}
		}
		
		XmlSchemaComplexType GetComplexTypeByName (XmlQualifiedName qname)
		{
			if (qname.Name.IndexOf ("[]") != -1)
			{
				XmlSchemaComplexType stype=new XmlSchemaComplexType ();
				stype.ContentModel=new XmlSchemaComplexContent ();
				
				XmlSchemaComplexContentRestriction res=new XmlSchemaComplexContentRestriction ();
				stype.ContentModel.Content=res;
				res.BaseTypeName=arrayType;
				
				XmlSchemaAttribute att=new XmlSchemaAttribute ();
				att.RefName=arrayTypeRefName;
				res.Attributes.Add (att);
									
					
				return stype;
			}
				
			return (XmlSchemaComplexType) _schemas.Find (qname, typeof(XmlSchemaComplexType));
		}
		
		string GetQualifiedNameString (TreeNode inner, XmlQualifiedName qname)
		{
			TreeNode node=new TreeNode("xmlns q1=" + qname.Namespace);
			return "q1:" + qname.Name;
		}
				
	}
	
	
}