示例#1
0
        private void ResolveWsdlNestedType(WsdlBinding binding, WsdlBindingSuds suds, WsdlBindingSudsNestedType nested)
        {
            Util.Log("WsdlParser.ResolveWsdlNestedType "+binding.name+" ns "+binding.parsingNamespace.Namespace+" suds "+suds.typeName+" nestedName "+nested.name+" nestedTypeName "+nested.typeName);
            String className = suds.typeName;
            String ns = nested.ns;
            String nestedName = nested.name;
            String nestedTypeName = nested.typeName;
            if (suds.ns != ns)
            {
                throw new SUDSParserException(
                                             String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_CantResolveNestedTypeNS"),
                                                           suds.typeName, suds.ns));
            }

            URTNamespace sudsNamespace = AddNewNamespace(suds.ns);

            URTComplexType outerType = sudsNamespace.LookupComplexType(suds.typeName);
            if (outerType == null)
            {
                throw new SUDSParserException(
                                             String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_CantResolveNestedType"),
                                                           suds.typeName, suds.ns));
            }

            BaseType innerType = sudsNamespace.LookupType(nested.typeName);
            if (innerType == null)
            {
                // Can be URTSimpleType for Enum
                Util.Log("WsdlParser.ResolveWsdlNestedType cann't find inner type "+nested.typeName+" className "+className+" ns "+ns);

                innerType = sudsNamespace.LookupComplexType(nested.typeName);
                if (innerType == null)
                {
                    innerType = new URTComplexType(nested.typeName, sudsNamespace.Name, sudsNamespace.Namespace, sudsNamespace.EncodedNS, _blockDefault ,false, false, this, sudsNamespace);
                    sudsNamespace.AddComplexType((URTComplexType)innerType);
                }
            }


            innerType.bNestedType = true;
            innerType.NestedTypeName = nested.name;
            innerType.FullNestedTypeName = nested.typeName;
            innerType.OuterTypeName = suds.typeName;

            outerType.AddNestedType(innerType);
        }
 private void ResolveWsdlNestedType(WsdlBinding binding, WsdlBindingSuds suds, WsdlBindingSudsNestedType nested)
 {
     string typeName = suds.typeName;
     string ns = nested.ns;
     string name = nested.name;
     string text3 = nested.typeName;
     if (suds.ns != ns)
     {
         throw new SUDSParserException(string.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_CantResolveNestedTypeNS"), new object[] { suds.typeName, suds.ns }));
     }
     URTNamespace xns = this.AddNewNamespace(suds.ns);
     URTComplexType complexType = xns.LookupComplexType(suds.typeName);
     if (complexType == null)
     {
         throw new SUDSParserException(string.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_CantResolveNestedType"), new object[] { suds.typeName, suds.ns }));
     }
     BaseType type = xns.LookupType(nested.typeName);
     if (type == null)
     {
         type = xns.LookupComplexType(nested.typeName);
         if (type == null)
         {
             type = new URTComplexType(nested.typeName, xns.Name, xns.Namespace, xns.EncodedNS, this._blockDefault, false, false, this, xns);
             xns.AddComplexType((URTComplexType) type);
         }
     }
     type.bNestedType = true;
     type.NestedTypeName = nested.name;
     type.FullNestedTypeName = nested.typeName;
     type.OuterTypeName = suds.typeName;
     complexType.AddNestedType(type);
 }
示例#3
0
        private void ParseWsdlBindingSuds(WsdlBindingSuds suds)
        {
            Util.Log("WsdlParser.ParseWsdlBindingSuds");            
            int curDepth = _XMLReader.Depth; 
            ReadNextXmlElement();               
            while (_XMLReader.Depth > curDepth)
            {
                String elementName = _XMLReader.LocalName;

                if (MatchingStrings(elementName, s_implementsString) ||
                    MatchingStrings(elementName, s_extendsString))
                {
                    WsdlBindingSudsImplements impl = new WsdlBindingSudsImplements();
                    impl.typeName = LookupAttribute(s_typeString, null, true);
                    impl.ns = ParseQName(ref impl.typeName);
                    suds.implements.Add(impl);
                    ReadNextXmlElement();
                    continue;                   
                }
                else if (MatchingStrings(elementName, s_nestedTypeString))
                {
                    WsdlBindingSudsNestedType nestedType = new WsdlBindingSudsNestedType();
                    nestedType.name = LookupAttribute(s_nameString, null, true);
                    nestedType.typeName = LookupAttribute(s_typeString, null, true);
                    nestedType.ns = ParseQName(ref nestedType.typeName);
                    suds.nestedTypes.Add(nestedType);
                    ReadNextXmlElement();
                    continue;                   
                }


                // Ignore others elements such as annotations
                SkipXmlElement();
            }
        }
 private void ParseWsdlBindingSuds(WsdlBindingSuds suds)
 {
     int depth = this._XMLReader.Depth;
     this.ReadNextXmlElement();
     while (this._XMLReader.Depth > depth)
     {
         string localName = this._XMLReader.LocalName;
         if (MatchingStrings(localName, s_implementsString) || MatchingStrings(localName, s_extendsString))
         {
             WsdlBindingSudsImplements implements;
             implements = new WsdlBindingSudsImplements {
                 typeName = this.LookupAttribute(s_typeString, null, true),
                 ns = this.ParseQName(ref implements.typeName)
             };
             suds.implements.Add(implements);
             this.ReadNextXmlElement();
         }
         else if (MatchingStrings(localName, s_nestedTypeString))
         {
             WsdlBindingSudsNestedType type;
             type = new WsdlBindingSudsNestedType {
                 name = this.LookupAttribute(s_nameString, null, true),
                 typeName = this.LookupAttribute(s_typeString, null, true),
                 ns = this.ParseQName(ref type.typeName)
             };
             suds.nestedTypes.Add(type);
             this.ReadNextXmlElement();
         }
         else
         {
             this.SkipXmlElement();
         }
     }
 }