private void EnqueueReachableTypes(RealSchemaType rsType)
 {
     XMLNamespace xNS = rsType.XNS;
     if ((rsType.Type.BaseType != null) && ((rsType.Type.BaseType != s_valueType) || (rsType.Type.BaseType != s_objectType)))
     {
         this.AddType(rsType.Type.BaseType, this.GetNamespace(rsType.Type.BaseType));
     }
     if ((rsType.Type.IsInterface || s_marshalByRefType.IsAssignableFrom(rsType.Type)) || s_delegateType.IsAssignableFrom(rsType.Type))
     {
         FieldInfo[] instanceFields = rsType.GetInstanceFields();
         for (int i = 0; i < instanceFields.Length; i++)
         {
             if (instanceFields[i].FieldType != null)
             {
                 this.AddType(instanceFields[i].FieldType, xNS);
             }
         }
         Type[] introducedInterfaces = rsType.GetIntroducedInterfaces();
         if (introducedInterfaces.Length > 0)
         {
             for (int j = 0; j < introducedInterfaces.Length; j++)
             {
                 this.AddType(introducedInterfaces[j], xNS);
             }
         }
         this.ProcessMethods(rsType);
     }
     else
     {
         FieldInfo[] infoArray2 = rsType.GetInstanceFields();
         for (int k = 0; k < infoArray2.Length; k++)
         {
             if (infoArray2[k].FieldType != null)
             {
                 this.AddType(infoArray2[k].FieldType, xNS);
             }
         }
     }
 }
Exemplo n.º 2
0
        // Adds types reachable from the given type
        private void EnqueueReachableTypes(RealSchemaType rsType)
        {
            Util.Log("WsdlGenerator.EnqueueReachableTypes "+rsType.Name+" "+rsType.XNS.Name);           
            // Get the XML namespace object
            XMLNamespace xns = rsType.XNS;

            // Process base type
            if (rsType.Type.BaseType != null)
            {
                if (rsType.Type.BaseType != s_valueType || rsType.Type.BaseType != s_objectType)
                    AddType(rsType.Type.BaseType, GetNamespace(rsType.Type.BaseType));
            }

            // Check if this is a suds type
            bool bSUDSType = rsType.Type.IsInterface ||
                             s_marshalByRefType.IsAssignableFrom(rsType.Type) ||
                             s_delegateType.IsAssignableFrom(rsType.Type);
            if (bSUDSType)
            {
                Util.Log("WsdlGenerator.EnqueueReachableTypes suds type "+rsType.Name+" "+rsType.XNS.Name);           
                // Process fields
                FieldInfo[] fields = rsType.GetInstanceFields();
                for (int i=0;i<fields.Length;i++)
                {
                    if (fields[i].FieldType == null)
                        continue;
                    AddType(fields[i].FieldType, xns);
                }

                // Process implemented interfaces
                Type[] interfaces = rsType.GetIntroducedInterfaces();
                if (interfaces.Length > 0)
                {
                    for (int i=0;i<interfaces.Length;i++)
                    {
                        Util.Log("WsdlGenerator.EnqueueReachableTypes Interfaces "+interfaces[i].Name+" "+xns.Name);                        
                        AddType(interfaces[i], xns);
                    }
                }

                ProcessMethods(rsType);

            }
            else
            {
                // Process fields
                FieldInfo[] fields = rsType.GetInstanceFields();
                for (int i=0;i<fields.Length;i++)
                {
                    if (fields[i].FieldType == null)
                        continue;
                    AddType(fields[i].FieldType, xns);
                }
            }

            return;
        }
Exemplo n.º 3
0
		// Adds types reachable from the given type
		private void EnqueueReachableTypes(RealSchemaType rsType)
		{
			Util.Log("SdlGenerator.EnqueueReachableTypes ");            
			// Get the XML namespace object
			XMLNamespace xns = rsType.XNS;

			// Process base type
			if (rsType.Type.BaseType != null)
				AddType(rsType.Type.BaseType, xns);

			// Check if this is a suds type
			bool bSUDSType = rsType.Type.IsInterface ||
							 s_marshalByRefType.IsAssignableFrom(rsType.Type) ||
							 s_delegateType.IsAssignableFrom(rsType.Type);
			if (bSUDSType)
			{
				// Process implemented interfaces
				Type[] interfaces = rsType.GetIntroducedInterfaces();
				if (interfaces.Length > 0)
				{
					for (int i=0;i<interfaces.Length;i++)
					{
						Util.Log("SdlGenerator.EnqueueReachableTypes Interfaces "+interfaces[i].Name+" "+xns.Name);                     
						AddType(interfaces[i], xns);
					}
				}

				// Process methods
				MethodInfo[] methods = rsType.GetIntroducedMethods();
				if (methods.Length > 0)
				{
					String methodNSString = null;
					XMLNamespace methodXNS = null;  

					if (xns.IsInteropType)
					{
						methodNSString = xns.Name;
						methodXNS = xns;
					}
					else
					{
						StringBuilder sb = new StringBuilder();
						sb.Append(xns.Name);
						sb.Append('.');
						sb.Append(rsType.Name);
						methodNSString = sb.ToString();
						methodXNS = AddNamespace(methodNSString, xns.Assem);
						xns.DependsOnSchemaNS(methodXNS);
					}

					for (int i=0;i<methods.Length;i++)
					{
						MethodInfo method = methods[i];
						Util.Log("SdlGenerator.EnqueueReachableTypes methods "+method.Name+" "+methodXNS.Name);
						AddType(method.ReturnType, methodXNS);
						ParameterInfo[] parameters = method.GetParameters();
						for (int j=0;j<parameters.Length;j++)
							AddType(parameters[j].ParameterType, methodXNS);
					}
				}
			}
			else
			{
				// Process fields
				FieldInfo[] fields = rsType.GetInstanceFields();
				for (int i=0;i<fields.Length;i++)
				{
					if (fields[i].FieldType == null)
						continue;
					AddType(fields[i].FieldType, xns);
				}
			}

			return;
		}