internal URTMethod(String name, String soapAction, String methodAttributes, URTComplexType complexType) { Util.Log("URTMethod.URTMethod name "+name+" soapAction "+soapAction+" attributes "+methodAttributes+" complexType "+complexType); _methodName = name; _soapAction = soapAction; _methodType = null; _complexType = complexType; int index = name.IndexOf('.'); _methodFlags = MethodFlags.None; // set method flags if (methodAttributes != null && methodAttributes.Length > 0) { String[] attributes = methodAttributes.Split(' '); foreach (String attribute in attributes) { if (attribute == "virtual") _methodFlags |= MethodFlags.Virtual; if (attribute == "new") _methodFlags |= MethodFlags.New; if (attribute == "override") _methodFlags |= MethodFlags.Override; if (attribute == "public") _methodFlags |= MethodFlags.Public; if (attribute == "protected") _methodFlags |= MethodFlags.Protected; if (attribute == "internal") _methodFlags |= MethodFlags.Internal; } } Util.Log("URTMethod.URTMethod methodFlags "+((Enum)_methodFlags).ToString()); }
// Constructor internal RRMethod(WsdlMethodInfo wsdlMethodInfo, URTComplexType complexType) : base (wsdlMethodInfo.methodName, wsdlMethodInfo.soapAction, wsdlMethodInfo.methodAttributes, complexType) { Util.Log("RRMethod.RRMethod WsdlMethodInfo name "+wsdlMethodInfo.methodName+" soapAction "+wsdlMethodInfo.soapAction); _wsdlMethodInfo = wsdlMethodInfo; _requestElementName = null; _requestElementNS = null; _responseElementName = null; _responseElementNS = null; }
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); }
// Parses element fields private void ParseElementField(URTNamespace parsingNamespace, URTComplexType parsingComplexType, int fieldNum) { Util.Log("WsdlParser.ParseElementField NS "+parsingNamespace+" fieldNum "+fieldNum); // Determine the field name String fieldTypeName, fieldTypeXmlNS; String fieldName = LookupAttribute(s_nameString, null, true); // Look for array bounds String minOccurs = LookupAttribute(s_minOccursString, null, false); String maxOccurs = LookupAttribute(s_maxOccursString, null, false); // Check if the field is optional bool bOptional = false; if (MatchingStrings(minOccurs, s_zeroString)) bOptional = true; // Check if the field is an inline array bool bArray = false; String arraySize = null; if (!MatchingStrings(maxOccurs, s_emptyString) && !MatchingStrings(maxOccurs, s_oneString)) { if (MatchingStrings(maxOccurs, s_unboundedString)) arraySize = String.Empty; else arraySize = maxOccurs; bArray = true; } // Handle anonymous types bool bEmbedded, bPrimitive; if (_XMLReader.IsEmptyElement == true) { // Non-anonymous type case fieldTypeName = LookupAttribute(s_typeString, null, false); // Handle the absense of type attribute (Object case) ResolveTypeAttribute(ref fieldTypeName, out fieldTypeXmlNS, out bEmbedded, out bPrimitive); // Read next element ReadNextXmlElement(); } else { // Anonymous type case fieldTypeXmlNS = parsingNamespace.Namespace; fieldTypeName = parsingNamespace.GetNextAnonymousName(); bPrimitive = false; bEmbedded = true; int curDepth = _XMLReader.Depth; ReadNextXmlElement(); // Parse the type String elementName; while (_XMLReader.Depth > curDepth) { elementName = _XMLReader.LocalName; if (MatchingStrings(elementName, s_complexTypeString)) { URTComplexType complexType = ParseComplexType(parsingNamespace, fieldTypeName); if (complexType.IsEmittableFieldType) { fieldTypeXmlNS = complexType.FieldNamespace; fieldTypeName = complexType.FieldName; bPrimitive = complexType.PrimitiveField; parsingNamespace.RemoveComplexType(complexType); } } else if (MatchingStrings(elementName, s_simpleTypeString)) { URTSimpleType simpleType = ParseSimpleType(parsingNamespace, fieldTypeName); if (simpleType.IsEmittableFieldType) { fieldTypeXmlNS = simpleType.FieldNamespace; fieldTypeName = simpleType.FieldName; bPrimitive = simpleType.PrimitiveField; parsingNamespace.RemoveSimpleType(simpleType); } } else { // Ignore others elements such as annotations SkipXmlElement(); } } } // Add field to the type being parsed parsingComplexType.AddField(new URTField(fieldName, fieldTypeName, fieldTypeXmlNS, this, bPrimitive, bEmbedded, false, bOptional, bArray, arraySize, parsingNamespace)); return; }
// Add a new type into the namespace internal void AddComplexType(URTComplexType type){ Util.Log("URTNamespace.AddComplexType "+this.GetHashCode()+" "+type.Name+" "+type.GetHashCode()+" ns "+_name); // Assert that simple and complex types share the same namespace Debug.Assert(LookupSimpleType(type.Name) == null, "Complex type has the same name as a simple type"); _URTComplexTypes.Add(type); ++_numURTComplexTypes; }
// Parses a class private void ParseClass(URTNamespace parsingNamespace) { Util.Log("SdlParser.ParseClass"); String className = LookupAttribute(s_nameString, null, false); bool bUnique = false; if((className == s_emptyString) && (_parsingInput.UniqueType == null)) { className = _parsingInput.Name; bUnique = true; } URTComplexType parsingComplexType = parsingNamespace.LookupComplexType(className); if(parsingComplexType == null) { parsingComplexType = new URTComplexType(className, parsingNamespace.Namespace, parsingNamespace.EncodedNS, _blockDefault, true, false); if(_bWrappedProxy) { parsingComplexType.SUDSType = SUDSType.ClientProxy; if (_parsingInput.Location.Length > 0) { if (parsingComplexType.ConnectURLs == null) parsingComplexType.ConnectURLs = new ArrayList(10); parsingComplexType.ConnectURLs.Add(_parsingInput.Location); } } parsingNamespace.AddComplexType(parsingComplexType); } if(bUnique) { _parsingInput.UniqueType = parsingComplexType; } if(parsingComplexType.Methods.Count > 0) { SkipXmlElement(); } else { parsingComplexType.IsSUDSType = true; int curDepth = _XMLReader.Depth; ReadNextXmlElement(); while(_XMLReader.Depth > curDepth) { if(MatchingNamespace(s_sudsNamespaceString)) { String elmName = _XMLReader.LocalName; if(MatchingStrings(elmName, s_extendsString)) { String nameValue = LookupAttribute(s_nameString, null, true); String nameValueNS = ParseQName(ref nameValue); parsingComplexType.Extends(nameValue, nameValueNS); //Set up extend class so that it is marked as the correct SUDSType URTNamespace extendsNamespace = LookupNamespace(nameValueNS); if (extendsNamespace == null) extendsNamespace = new URTNamespace(nameValueNS, this); URTComplexType extendsComplexType = extendsNamespace.LookupComplexType(nameValue); if(extendsComplexType == null) { extendsComplexType = new URTComplexType(nameValue, extendsNamespace.Namespace, extendsNamespace.EncodedNS, _blockDefault ,true, false); extendsNamespace.AddComplexType(extendsComplexType); } else extendsComplexType.IsSUDSType = true; if (_bWrappedProxy) extendsComplexType.SUDSType = SUDSType.ClientProxy; else extendsComplexType.SUDSType = SUDSType.MarshalByRef; // Only top of inheritance hierarchy is marked //parsingComplexType.SUDSType = SUDSType.None; } else if(MatchingStrings(elmName, s_implementsString)) { String nameValue = LookupAttribute(s_nameString, null, true); String nameValueNS = ParseQName(ref nameValue); parsingComplexType.Implements(nameValue, nameValueNS, this); } else if(MatchingStrings(elmName, s_addressesString)) { ParseAddresses(parsingComplexType); continue; } else if(MatchingStrings(elmName, s_requestResponseString)) { ParseRRMethod(parsingComplexType, null); continue; } else if(MatchingStrings(elmName, s_onewayString)) { ParseOnewayMethod(parsingComplexType, null); continue; } else goto SkipXMLNode; } else goto SkipXMLNode; // Read next element ReadNextXmlElement(); continue; SkipXMLNode: // Ignore others elements such as annotations SkipXmlElement(); } } return; }
private URTComplexType ParseComplexType(URTNamespace parsingNamespace, string typeName) { if (typeName == null) { typeName = this.LookupAttribute(s_nameString, null, true); } URTNamespace returnNS = null; this.ParseQName(ref typeName, parsingNamespace, out returnNS); URTComplexType complexType = returnNS.LookupComplexType(typeName); if (complexType == null) { complexType = new URTComplexType(typeName, returnNS.Name, returnNS.Namespace, returnNS.EncodedNS, this._blockDefault, false, typeName != null, this, returnNS); returnNS.AddComplexType(complexType); } string left = this.LookupAttribute(s_baseString, null, false); if (!MatchingStrings(left, s_emptyString)) { string baseTypeNS = this.ParseQName(ref left, parsingNamespace); complexType.Extends(left, baseTypeNS); } if (complexType.Fields.Count > 0) { this.SkipXmlElement(); return complexType; } int depth = this._XMLReader.Depth; this.ReadNextXmlElement(); int fieldNum = 0; while (this._XMLReader.Depth > depth) { string localName = this._XMLReader.LocalName; if (MatchingStrings(localName, s_elementString)) { this.ParseElementField(returnNS, complexType, fieldNum); fieldNum++; } else { if (MatchingStrings(localName, s_attributeString)) { this.ParseAttributeField(returnNS, complexType); continue; } if (MatchingStrings(localName, s_allString)) { complexType.BlockType = SchemaBlockType.ALL; } else if (MatchingStrings(localName, s_sequenceString)) { complexType.BlockType = SchemaBlockType.SEQUENCE; } else if (MatchingStrings(localName, s_choiceString)) { complexType.BlockType = SchemaBlockType.CHOICE; } else if (MatchingStrings(localName, s_complexContentString)) { complexType.BlockType = SchemaBlockType.ComplexContent; } else { if (MatchingStrings(localName, s_restrictionString)) { this.ParseRestrictionField(returnNS, complexType); } else { this.SkipXmlElement(); } continue; } this.ReadNextXmlElement(); } } return complexType; }
// Parses attribute fields private void ParseAttributeField(URTNamespace parsingNamespace, URTComplexType parsingComplexType) { Util.Log("WsdlParser.ParseAttributeField NS "+parsingNamespace); // Lookup field name String attrTypeName, attrTypeNS; String attrName = LookupAttribute(s_nameString, null, true); // Check if the field is optional bool bOptional = false; String minOccurs = LookupAttribute(s_minOccursString, null, false); if (MatchingStrings(minOccurs, s_zeroString)) bOptional = true; // Handle anonymous types bool bEmbedded, bPrimitive; if (_XMLReader.IsEmptyElement == true) { // Non-anonymous type case and type has to present attrTypeName = LookupAttribute(s_typeString, null, true); ResolveTypeAttribute(ref attrTypeName, out attrTypeNS, out bEmbedded, out bPrimitive); // Read next element ReadNextXmlElement(); // Check for xsd:ID type if (MatchingStrings(attrTypeName, s_idString) && MatchingSchemaStrings(attrTypeNS)) { parsingComplexType.IsStruct = false; return; } } else { // Anonymous type case attrTypeNS = parsingNamespace.Namespace; attrTypeName = parsingNamespace.GetNextAnonymousName(); bPrimitive = false; bEmbedded = true; int curDepth = _XMLReader.Depth; ReadNextXmlElement(); // Parse the type String elementName; while (_XMLReader.Depth > curDepth) { elementName = _XMLReader.LocalName; if (MatchingStrings(elementName, s_simpleTypeString)) { URTSimpleType simpleType = ParseSimpleType(parsingNamespace, attrTypeName); if (simpleType.IsEmittableFieldType) { attrTypeNS = simpleType.FieldNamespace; attrTypeName = simpleType.FieldName; bPrimitive = simpleType.PrimitiveField; parsingNamespace.RemoveSimpleType(simpleType); } } else { // Ignore others elements such as annotations SkipXmlElement(); } } } // Add field to the type being parsed parsingComplexType.AddField(new URTField(attrName, attrTypeName, attrTypeNS, this, bPrimitive, bEmbedded, true, bOptional, false, null, parsingNamespace)); return; }
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); }
private void ParseAttributeField(URTNamespace parsingNamespace, URTComplexType parsingComplexType) { string nextAnonymousName; string fieldNamespace; bool flag2; bool primitiveField; string name = this.LookupAttribute(s_nameString, null, true); bool bOptional = false; if (MatchingStrings(this.LookupAttribute(s_minOccursString, null, false), s_zeroString)) { bOptional = true; } if (this._XMLReader.IsEmptyElement) { nextAnonymousName = this.LookupAttribute(s_typeString, null, true); this.ResolveTypeAttribute(ref nextAnonymousName, out fieldNamespace, out flag2, out primitiveField); this.ReadNextXmlElement(); if (MatchingStrings(nextAnonymousName, s_idString) && this.MatchingSchemaStrings(fieldNamespace)) { parsingComplexType.IsStruct = false; return; } } else { fieldNamespace = parsingNamespace.Namespace; nextAnonymousName = parsingNamespace.GetNextAnonymousName(); primitiveField = false; flag2 = true; int depth = this._XMLReader.Depth; this.ReadNextXmlElement(); while (this._XMLReader.Depth > depth) { if (MatchingStrings(this._XMLReader.LocalName, s_simpleTypeString)) { URTSimpleType type = this.ParseSimpleType(parsingNamespace, nextAnonymousName); if (type.IsEmittableFieldType) { fieldNamespace = type.FieldNamespace; nextAnonymousName = type.FieldName; primitiveField = type.PrimitiveField; parsingNamespace.RemoveSimpleType(type); } } else { this.SkipXmlElement(); } } } parsingComplexType.AddField(new URTField(name, nextAnonymousName, fieldNamespace, this, primitiveField, flag2, true, bOptional, false, null, parsingNamespace)); }
private void ResolveWsdlClass(WsdlBinding binding, WsdlBindingSuds suds, bool bFirstSuds) { URTComplexType complexType; URTNamespace namespace2; if (suds != null) { namespace2 = this.AddNewNamespace(suds.ns); complexType = namespace2.LookupComplexType(suds.typeName); if (complexType == null) { complexType = new URTComplexType(suds.typeName, namespace2.Name, namespace2.Namespace, namespace2.EncodedNS, this._blockDefault, false, false, this, namespace2); namespace2.AddComplexType(complexType); } if (MatchingStrings(suds.elementName, s_structString)) { complexType.IsValueType = true; } complexType.SudsUse = suds.sudsUse; if ((suds.sudsUse == SudsUse.MarshalByRef) || (suds.sudsUse == SudsUse.ServicedComponent)) { complexType.IsSUDSType = true; if (this._bWrappedProxy) { complexType.SUDSType = SUDSType.ClientProxy; } else { complexType.SUDSType = SUDSType.MarshalByRef; } if ((suds.extendsTypeName != null) && (suds.extendsTypeName.Length > 0)) { URTNamespace xns = this.AddNewNamespace(suds.extendsNs); URTComplexType type = xns.LookupComplexType(suds.extendsTypeName); if (type == null) { type = new URTComplexType(suds.extendsTypeName, xns.Name, xns.Namespace, xns.EncodedNS, this._blockDefault, true, false, this, xns); xns.AddComplexType(type); } else { type.IsSUDSType = true; } if (this._bWrappedProxy) { type.SUDSType = SUDSType.ClientProxy; } else { type.SUDSType = SUDSType.MarshalByRef; } type.SudsUse = suds.sudsUse; } } foreach (WsdlBindingSudsNestedType type3 in suds.nestedTypes) { this.ResolveWsdlNestedType(binding, suds, type3); } } else { namespace2 = this.AddNewNamespace(binding.typeNs); string name = binding.name; int index = binding.name.IndexOf("Binding"); if (index > 0) { name = binding.name.Substring(0, index); } complexType = namespace2.LookupComplexTypeEqual(name); if (complexType == null) { complexType = new URTComplexType(name, namespace2.Name, namespace2.Namespace, namespace2.EncodedNS, this._blockDefault, true, false, this, namespace2); namespace2.AddComplexType(complexType); } else { complexType.IsSUDSType = true; } if (this._bWrappedProxy) { complexType.SUDSType = SUDSType.ClientProxy; } else { complexType.SUDSType = SUDSType.MarshalByRef; } complexType.SudsUse = SudsUse.MarshalByRef; } complexType.ConnectURLs = this.ResolveWsdlAddress(binding); if (suds != null) { if (!MatchingStrings(suds.extendsTypeName, s_emptyString)) { complexType.Extends(suds.extendsTypeName, suds.extendsNs); } foreach (WsdlBindingSudsImplements implements in suds.implements) { complexType.Implements(implements.typeName, implements.ns, this); } } if (bFirstSuds && (((complexType.SudsUse == SudsUse.MarshalByRef) || (complexType.SudsUse == SudsUse.ServicedComponent)) || ((complexType.SudsUse == SudsUse.Delegate) || (complexType.SudsUse == SudsUse.Interface)))) { foreach (WsdlMethodInfo info in this.ResolveWsdlMethodInfo(binding)) { if ((info.inputMethodName == null) || (info.outputMethodName == null)) { if (info.inputMethodName == null) { throw new SUDSParserException(string.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_WsdlInvalidMessage"), new object[] { info.methodName })); } OnewayMethod method2 = new OnewayMethod(info, complexType); complexType.AddMethod(method2); method2.AddMessage(info.methodName, info.methodNameNs); } else { RRMethod method = new RRMethod(info, complexType); method.AddRequest(info.methodName, info.methodNameNs); method.AddResponse(info.methodName, info.methodNameNs); complexType.AddMethod(method); } } } }
// Parses a oneway method private void ParseOnewayMethod(URTComplexType parsingComplexType, URTInterface parsingInterface) { Util.Log("SdlParser.ParseOnewayMethod"); String methodName = LookupAttribute(s_nameString, null, true); String soapAction = LookupAttribute(s_soapActionString, null, false); OnewayMethod parsingMethod = new OnewayMethod(methodName, soapAction); int curDepth = _XMLReader.Depth; ReadNextXmlElement(); while(_XMLReader.Depth > curDepth) { if (MatchingNamespace(s_sudsNamespaceString)) { String elmName = _XMLReader.LocalName; if(MatchingStrings(elmName, s_requestString)) { String refValue = LookupAttribute(s_refString, null, true); String refNS = ParseQName(ref refValue); parsingMethod.AddMessage(refValue, refNS); ReadNextXmlElement(); continue; } } // Ignore others elements such as annotations SkipXmlElement(); } if(parsingComplexType != null) parsingComplexType.AddMethod(parsingMethod); else parsingInterface.AddMethod(parsingMethod); return; }
// Parses an address private void ParseAddresses(URTComplexType parsingComplexType) { Util.Log("SdlParser.ParseAddress"); int curDepth = _XMLReader.Depth; ReadNextXmlElement(); while(_XMLReader.Depth > curDepth) { if(MatchingNamespace(s_sudsNamespaceString)) { String elmName = _XMLReader.LocalName; if(MatchingStrings(elmName, s_addressString)) { String uriValue = LookupAttribute(s_uriString, null, true); if(_bWrappedProxy) { parsingComplexType.SUDSType = SUDSType.ClientProxy; if (parsingComplexType.ConnectURLs == null) parsingComplexType.ConnectURLs = new ArrayList(10); parsingComplexType.ConnectURLs.Add(uriValue); } ReadNextXmlElement(); continue; } } // Ignore others elements such as annotations SkipXmlElement(); } return; }
// Constructor internal OnewayMethod(String name, String soapAction, URTComplexType complexType) : base(name, soapAction, null, complexType) { Util.Log("OnewayMethod.OnewayMethod name "+name+" soapAction "+soapAction); _messageElementName = null; _messageElementNS = null; //_messageTypeName = null; //_messageTypeNS = null; }
private void ParseElementField(URTNamespace parsingNamespace, URTComplexType parsingComplexType, int fieldNum) { string nextAnonymousName; string fieldNamespace; bool flag3; bool primitiveField; string name = this.LookupAttribute(s_nameString, null, true); string left = this.LookupAttribute(s_minOccursString, null, false); string str5 = this.LookupAttribute(s_maxOccursString, null, false); bool bOptional = false; if (MatchingStrings(left, s_zeroString)) { bOptional = true; } bool bArray = false; string arraySize = null; if (!MatchingStrings(str5, s_emptyString) && !MatchingStrings(str5, s_oneString)) { if (MatchingStrings(str5, s_unboundedString)) { arraySize = string.Empty; } else { arraySize = str5; } bArray = true; } if (this._XMLReader.IsEmptyElement) { nextAnonymousName = this.LookupAttribute(s_typeString, null, false); this.ResolveTypeAttribute(ref nextAnonymousName, out fieldNamespace, out flag3, out primitiveField); this.ReadNextXmlElement(); } else { fieldNamespace = parsingNamespace.Namespace; nextAnonymousName = parsingNamespace.GetNextAnonymousName(); primitiveField = false; flag3 = true; int depth = this._XMLReader.Depth; this.ReadNextXmlElement(); while (this._XMLReader.Depth > depth) { string localName = this._XMLReader.LocalName; if (MatchingStrings(localName, s_complexTypeString)) { URTComplexType type = this.ParseComplexType(parsingNamespace, nextAnonymousName); if (type.IsEmittableFieldType) { fieldNamespace = type.FieldNamespace; nextAnonymousName = type.FieldName; primitiveField = type.PrimitiveField; parsingNamespace.RemoveComplexType(type); } } else { if (MatchingStrings(localName, s_simpleTypeString)) { URTSimpleType type2 = this.ParseSimpleType(parsingNamespace, nextAnonymousName); if (type2.IsEmittableFieldType) { fieldNamespace = type2.FieldNamespace; nextAnonymousName = type2.FieldName; primitiveField = type2.PrimitiveField; parsingNamespace.RemoveSimpleType(type2); } continue; } this.SkipXmlElement(); } } } parsingComplexType.AddField(new URTField(name, nextAnonymousName, fieldNamespace, this, primitiveField, flag3, false, bOptional, bArray, arraySize, parsingNamespace)); }
internal OnewayMethod(WsdlMethodInfo wsdlMethodInfo, URTComplexType complexType) : base (wsdlMethodInfo.methodName, wsdlMethodInfo.soapAction, wsdlMethodInfo.methodAttributes, complexType) { Util.Log("OnewayMethod.OnewayMethod WsdlMethodInfo name "+wsdlMethodInfo.methodName+" soapAction "+wsdlMethodInfo.soapAction); _wsdlMethodInfo = wsdlMethodInfo; _messageElementName = null; _messageElementNS = null; }
// Parses complex types private URTComplexType ParseComplexType(URTNamespace parsingNamespace, String typeName) { Util.Log("WsdlParser.ParseComplexType NS "+parsingNamespace.Name+" typeName "+typeName); // Lookup the name of the type and the base type from which it derives if (typeName == null) typeName = LookupAttribute(s_nameString, null, true); URTNamespace xns = null; String typeNS = ParseQName(ref typeName, parsingNamespace, out xns); Util.Log("WsdlParser.ParseComplexType actualNS 1 "+xns); Util.Log("WsdlParser.ParseComplexType actualNS 2 "+xns.Name); URTComplexType parsingComplexType = xns.LookupComplexType(typeName); if (parsingComplexType == null) { parsingComplexType = new URTComplexType(typeName, xns.Name, xns.Namespace, xns.EncodedNS, _blockDefault, false, typeName != null, this, xns); xns.AddComplexType(parsingComplexType); } String baseType = LookupAttribute(s_baseString, null, false); if (!MatchingStrings(baseType, s_emptyString)) { String baseNS = ParseQName(ref baseType, parsingNamespace); parsingComplexType.Extends(baseType, baseNS); } if (parsingComplexType.Fields.Count > 0) { SkipXmlElement(); } else { int curDepth = _XMLReader.Depth; ReadNextXmlElement(); int fieldNum = 0; String elementName; while (_XMLReader.Depth > curDepth) { elementName = _XMLReader.LocalName; if (MatchingStrings(elementName, s_elementString)) { ParseElementField(xns, parsingComplexType, fieldNum); ++fieldNum; continue; } else if (MatchingStrings(elementName, s_attributeString)) { ParseAttributeField(xns, parsingComplexType); continue; } else if (MatchingStrings(elementName, s_allString)) { parsingComplexType.BlockType = SchemaBlockType.ALL; } else if (MatchingStrings(elementName, s_sequenceString)) { parsingComplexType.BlockType = SchemaBlockType.SEQUENCE; } else if (MatchingStrings(elementName, s_choiceString)) { parsingComplexType.BlockType = SchemaBlockType.CHOICE; } else if (MatchingStrings(elementName, s_complexContentString)) { parsingComplexType.BlockType = SchemaBlockType.ComplexContent; } else if (MatchingStrings(elementName, s_restrictionString)) { ParseRestrictionField(xns, parsingComplexType); //++fieldNum; continue; } else { // Ignore others elements such as annotations SkipXmlElement(); continue; } // Read next element ReadNextXmlElement(); } } return(parsingComplexType); }
internal URTComplexType(String name, String urlNS, String ns, String encodedNS, SchemaBlockType blockDefault, bool bSUDSType, bool bAnonymous, WsdlParser parser, URTNamespace xns) : base(name, urlNS, ns, encodedNS) { Util.Log("URTComplexType.URTComplexType name "+this.GetHashCode()+" "+name+" urlNS "+urlNS+" ns "+ns+" encodedNS "+encodedNS+" bSUDStype "+bSUDSType+" bAnonymous "+bAnonymous); _baseTypeName = null; _baseTypeXmlNS = null; _baseType = null; _connectURLs = null; _bStruct = !bSUDSType; _blockType = blockDefault; _bSUDSType = bSUDSType; _bAnonymous = bAnonymous; Debug.Assert(bAnonymous == false || _bSUDSType == false); _fieldString = null; _fields = new ArrayList(); _methods = new ArrayList(); _implIFaces = new ArrayList(); _implIFaceNames = new ArrayList(); _sudsType = SUDSType.None; _parser = parser; int index = name.IndexOf('+'); if (index > 0) { // Nested type see if outer type has been added to namespace String outerType = parser.Atomize(name.Substring(0,index)); URTComplexType cs = xns.LookupComplexType(outerType); if (cs == null) { URTComplexType newCs = new URTComplexType(outerType, urlNS, ns, encodedNS, blockDefault, bSUDSType, bAnonymous, parser, xns); Util.Log("URTComplexType.URTComplexType add outerType to namespace "+outerType+" nestedname "+name); xns.AddComplexType(newCs); } } if (xns.UrtType == UrtType.Interop) { // Interop class names can have '.', replace these with '_', and set wire name to original type name. index = name.LastIndexOf('.'); if (index > -1) { // class names can't have '.' so replace with '$'. Use xmlType attribute to send original name on wire. _wireType = name; Name = name.Replace(".", "_"); SearchName = name; } } }
private void ResolveWsdlClass(WsdlBinding binding, WsdlBindingSuds suds, bool bFirstSuds) { // bFirstSuds is true then the suds class is the class for the binding. // The other suds are additional class without bindings in the same namespace. Util.Log("WsdlParser.ResolveWsdlClass suds "+suds); URTComplexType parsingComplexType; //URTNamespace parsingNamespace = binding.parsingNamespace; URTNamespace parsingNamespace; //URTNamespace parsingNamespace = binding.typeNs; if (suds != null) { Util.Log("WsdlParser.ResolveWsdlClass suds not null "+suds.elementName+" "+suds.typeName); // Suds parsingNamespace = AddNewNamespace(suds.ns); parsingComplexType = parsingNamespace.LookupComplexType(suds.typeName); if (parsingComplexType == null) { parsingComplexType = new URTComplexType(suds.typeName, parsingNamespace.Name, parsingNamespace.Namespace, parsingNamespace.EncodedNS, _blockDefault ,false, false, this, parsingNamespace); parsingNamespace.AddComplexType(parsingComplexType); } if (MatchingStrings(suds.elementName, s_structString)) parsingComplexType.IsValueType = true; parsingComplexType.SudsUse = suds.sudsUse; if (suds.sudsUse == SudsUse.MarshalByRef || suds.sudsUse == SudsUse.ServicedComponent ) { Util.Log("WsdlParser.ResolveWsdlClass MarshalByRef IsSudsType true 1 "+suds.elementName+" "+suds.typeName); parsingComplexType.IsSUDSType = true; if (_bWrappedProxy) parsingComplexType.SUDSType = SUDSType.ClientProxy; else parsingComplexType.SUDSType = SUDSType.MarshalByRef; if ((suds.extendsTypeName != null) && (suds.extendsTypeName.Length > 0)) { URTNamespace extendsNamespace = AddNewNamespace(suds.extendsNs); /* if (extendsNamespace == null) extendsNamespace = new URTNamespace(suds.extendsTypeName, this); */ URTComplexType extendsComplexType = extendsNamespace.LookupComplexType(suds.extendsTypeName); if (extendsComplexType == null) { extendsComplexType = new URTComplexType(suds.extendsTypeName, extendsNamespace.Name, extendsNamespace.Namespace, extendsNamespace.EncodedNS, _blockDefault ,true, false, this, extendsNamespace); extendsNamespace.AddComplexType(extendsComplexType); } else { Util.Log("WsdlParser.ResolveWsdlClass IsSudsType true 2 "+suds.elementName+" "+suds.typeName); extendsComplexType.IsSUDSType = true; } if (_bWrappedProxy) extendsComplexType.SUDSType = SUDSType.ClientProxy; else extendsComplexType.SUDSType = SUDSType.MarshalByRef; extendsComplexType.SudsUse = suds.sudsUse; // Only top of inheritance hierarchy is marked //parsingComplexType.SUDSType = SUDSType.None; } } foreach (WsdlBindingSudsNestedType nestedType in suds.nestedTypes) { ResolveWsdlNestedType(binding, suds, nestedType); } } else { // No suds Util.Log("WsdlParser.ResolveWsdlClass no suds "); parsingNamespace = AddNewNamespace(binding.typeNs); String name = binding.name; int index = binding.name.IndexOf("Binding"); if (index > 0) { //name = Atomize(binding.name.Substring(0,index)); name = binding.name.Substring(0,index); } parsingComplexType = parsingNamespace.LookupComplexTypeEqual(name); if (parsingComplexType == null) { parsingComplexType = new URTComplexType(name, parsingNamespace.Name, parsingNamespace.Namespace, parsingNamespace.EncodedNS, _blockDefault ,true, false, this, parsingNamespace); parsingNamespace.AddComplexType(parsingComplexType); } else { Util.Log("WsdlParser.ResolveWsdlClass IsSudsType true 3 "+name); parsingComplexType.IsSUDSType = true; } if (_bWrappedProxy) parsingComplexType.SUDSType = SUDSType.ClientProxy; else parsingComplexType.SUDSType = SUDSType.MarshalByRef; parsingComplexType.SudsUse = SudsUse.MarshalByRef; } // Resolve address parsingComplexType.ConnectURLs = ResolveWsdlAddress(binding); // Resolve extends and implements if (suds != null) { if (!MatchingStrings(suds.extendsTypeName, s_emptyString)) { parsingComplexType.Extends(suds.extendsTypeName, suds.extendsNs); } foreach (WsdlBindingSudsImplements impl in suds.implements) parsingComplexType.Implements(impl.typeName, impl.ns, this); } if (bFirstSuds && (parsingComplexType.SudsUse == SudsUse.MarshalByRef || parsingComplexType.SudsUse == SudsUse.ServicedComponent || parsingComplexType.SudsUse == SudsUse.Delegate || parsingComplexType.SudsUse == SudsUse.Interface)) { // Resolve methods ArrayList methodInfos = ResolveWsdlMethodInfo(binding); foreach (WsdlMethodInfo methodInfo in methodInfos) { if ((methodInfo.inputMethodName != null) && (methodInfo.outputMethodName != null)) { RRMethod parsingRRMethod = new RRMethod(methodInfo, parsingComplexType); parsingRRMethod.AddRequest(methodInfo.methodName, methodInfo.methodNameNs); parsingRRMethod.AddResponse(methodInfo.methodName, methodInfo.methodNameNs); parsingComplexType.AddMethod(parsingRRMethod); } else if (methodInfo.inputMethodName != null) { OnewayMethod parsingOWMethod = new OnewayMethod(methodInfo, parsingComplexType); parsingComplexType.AddMethod(parsingOWMethod); parsingOWMethod.AddMessage(methodInfo.methodName, methodInfo.methodNameNs); } else { throw new SUDSParserException( String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_WsdlInvalidMessage"), methodInfo.methodName)); } } } }
// Removes the given type from the namespace internal void RemoveComplexType(URTComplexType type){ Util.Log("URTNamespace.RemoveComplexType "+type.Name+" complex Type "+_name); for (int i=0;i<_URTComplexTypes.Count;i++) { Util.Log("URTNamespace.RemoveComplexType 1 "+type.Name+" complexTypes "+((_URTComplexTypes[i] != null) ? ((URTComplexType)_URTComplexTypes[i]).Name : "Null")); if (_URTComplexTypes[i] == type) { Util.Log("URTNamespace.RemoveComplexType 2 match "+type.Name+" complexTypes "+((_URTComplexTypes[i] != null) ? ((URTComplexType)_URTComplexTypes[i]).Name : "Null")); _URTComplexTypes[i] = null; --_numURTComplexTypes; return; } } throw new SUDSParserException( CoreChannel.GetResourceString("Remoting_Suds_TriedToRemoveNonexistentType")); }
// Add a new type into the namespace public void AddComplexType(URTComplexType type) { Util.Log("URTNamespace.AddComplexType "+type.Name); // Assert that simple and complex types share the same namespace Debug.Assert(LookupSimpleType(type.Name) == null, "Complex type has the same name as a simple type"); _URTComplexTypes.Add(type); ++_numURTComplexTypes; }