// Resolve element references public void ResolveElements(SdlParser parser) { Util.Log("URTNamespace.ResolveElements "+Name); for(int i=0;i<_elmDecls.Count;i++) ((ElementDecl) _elmDecls[i]).Resolve(parser); }
// Resolves internal references public void ResolveTypes(SdlParser parser) { Util.Log("URTNamespace.ResolveTypes "+Name); for(int i=0;i<_URTComplexTypes.Count;i++) { if(_URTComplexTypes[i] != null) ((URTComplexType)_URTComplexTypes[i]).ResolveTypes(parser); } for(int i=0;i<_URTInterfaces.Count;i++) ((URTInterface)_URTInterfaces[i]).ResolveTypes(parser); }
public void Resolve(SdlParser parser) { Util.Log("ElementDecl.Resolve "+TypeName+" "+TypeNS); // Return immediately for element declaration of primitive types if(_bPrimitive) return; // Lookup the type from the element declaration URTNamespace typeNS = parser.LookupNamespace(TypeNS); if(typeNS == null) { throw new SUDSParserException( String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"), TypeNS)); } BaseType type = typeNS.LookupType(TypeName); if(type == null) { throw new SUDSParserException( String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveTypeInNS"), TypeName, TypeNS)); } type.ElementName = Name; type.ElementNS = Namespace; return; }
// Constructor public URTNamespace(String name, SdlParser parser) { Util.Log("URTNamespace.URTNamespace name "+name); _name = name; _nsType = parser.IsURTExportedType(name, out _namespace, out _assemName); if(_nsType == UrtType.Interop) _encodedNS = "InteropProxy"; else _encodedNS = _namespace; _elmDecls = new ArrayList(); _URTComplexTypes = new ArrayList(); _numURTComplexTypes = 0; _URTSimpleTypes = new ArrayList(); _numURTSimpleTypes = 0; _URTInterfaces = new ArrayList(); _anonymousSeqNum = 0; }
internal void Implements(String iFaceName, String iFaceNS, SdlParser parser) { Util.Log("URTComplexType.Implements IFaceName "+iFaceName+" iFaceNS "+iFaceNS); _implIFaceNames.Add(iFaceName); _implIFaceNames.Add(iFaceNS); // Urt namespace will not have schema, they need to be recorded. URTNamespace parsingNamespace = parser.LookupNamespace(iFaceNS); if(parsingNamespace == null) { parsingNamespace = new URTNamespace(iFaceNS, parser); parser._URTNamespaces.Add(parsingNamespace); } URTInterface parsingInterface = parsingNamespace.LookupInterface(iFaceName); if(parsingInterface == null) { parsingInterface = new URTInterface(iFaceName, parsingNamespace.Namespace, parsingNamespace.EncodedNS); parsingNamespace.AddInterface(parsingInterface); } }
internal void ResolveTypes(SdlParser parser) { Util.Log("URTComplexType.ResolveTypes "+Name+" _baseTypeName "+_baseTypeName+" IsSUDSType "+IsSUDSType); String baseTypeNS = null; String baseTypeAssemName = null; if(_baseTypeName != null) { Util.Log("URTComplexType.ResolveTypes 1 "); UrtType urtType = parser.IsURTExportedType(_baseTypeXmlNS, out baseTypeNS, out baseTypeAssemName); if ((urtType == UrtType.Interop) && baseTypeNS.StartsWith("System")) { _baseType = new SystemType(_baseTypeName, baseTypeNS, baseTypeAssemName); } else { URTNamespace ns = parser.LookupNamespace(_baseTypeXmlNS); if(ns == null) { throw new SUDSParserException( String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"), _baseTypeXmlNS)); } _baseType = ns.LookupComplexType(_baseTypeName); if(_baseType == null) { throw new SUDSParserException( String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveTypeInNS"), _baseTypeName, _baseTypeXmlNS)); } } } else if(IsSUDSType) { Util.Log("URTComplexType.ResolveTypes 2 SUDSType "+ ((Enum)_sudsType).ToString()); if (_sudsType == SUDSType.ClientProxy) { Util.Log("URTComplexType.ResolveTypes 3 "); _baseTypeName = "RemotingClientProxy"; _baseTypeXmlNS = SoapServices.CodeXmlNamespaceForClrTypeNamespace("System.Runtime.Remoting","System.Runtime.Remoting"); baseTypeNS = "System.Runtime.Remoting.Services"; baseTypeAssemName = "System.Runtime.Remoting"; } else if (_sudsType == SUDSType.MarshalByRef) { Util.Log("URTComplexType.ResolveTypes 4 "); _baseTypeName = "MarshalByRefObject"; _baseTypeXmlNS = SoapServices.CodeXmlNamespaceForClrTypeNamespace("System", null); baseTypeNS = "System"; baseTypeAssemName = null; } _baseType = new SystemType(_baseTypeName, baseTypeNS, baseTypeAssemName); } else { Util.Log("URTComplexType.ResolveTypes 5 "); _baseType = new SystemType("Object", "System", null); } for(int i=0;i<_implIFaceNames.Count;i=i+2) { String implIFaceName = (String) _implIFaceNames[i]; String implIFaceXmlNS = (String) _implIFaceNames[i+1]; String implIFaceNS, implIFaceAssemName; BaseInterface iFace; UrtType iType = parser.IsURTExportedType(implIFaceXmlNS, out implIFaceNS, out implIFaceAssemName); if ((iType == UrtType.UrtSystem) && implIFaceNS.StartsWith("System")) { iFace = new SystemInterface(implIFaceName, implIFaceNS); } else { URTNamespace ns = parser.LookupNamespace(implIFaceXmlNS); if(ns == null) { throw new SUDSParserException( String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"), implIFaceXmlNS)); } iFace = ns.LookupInterface(implIFaceName); if(iFace == null) { throw new SUDSParserException( String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveTypeInNS"), implIFaceName, implIFaceXmlNS)); } } _implIFaces.Add(iFace); } for(int i=0;i<_methods.Count;i++) ((URTMethod) _methods[i]).ResolveTypes(parser); }
internal virtual void ResolveTypes(SdlParser parser) { }
internal void ResolveTypes(SdlParser parser) { Util.Log("URTSimpleType.ResolveTypes "+Name); if(_baseTypeName != null) { if(SdlParser.IsPrimitiveType(_baseTypeXmlNS, _baseTypeName)) { if(IsEnum == false) _baseName = SdlParser.MapSchemaTypesToCSharpTypes(_baseTypeName); } else { URTNamespace ns = parser.LookupNamespace(_baseTypeXmlNS); if(ns == null) { throw new SUDSParserException( String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"), _baseTypeXmlNS)); } _baseType = ns.LookupComplexType(_baseTypeName); if(_baseType == null) { throw new SUDSParserException( String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveTypeInNS"), _baseTypeName, _baseTypeXmlNS)); } } } for(int i=0;i<_facets.Count;i++) ((SchemaFacet) _facets[i]).ResolveTypes(parser); return; }
internal void ResolveTypes(SdlParser parser) { Util.Log("URTInterface.ResolveTypes "+Name); for(int i=0;i<_baseIFaceNames.Count;i=i+2) { String baseIFaceName = (String) _baseIFaceNames[i]; String baseIFaceXmlNS = (String) _baseIFaceNames[i+1]; String baseIFaceNS, baseIFaceAssemName; BaseInterface iFace; UrtType iType = parser.IsURTExportedType(baseIFaceXmlNS, out baseIFaceNS, out baseIFaceAssemName); Util.Log("URTInterface.ResolveTypes Is System "+Name+" iType "+((Enum)iType).ToString()+" baseIFaceNS "+baseIFaceNS); if ((iType != UrtType.Interop) && baseIFaceNS.StartsWith("System")) { iFace = new SystemInterface(baseIFaceName, baseIFaceNS); } else { URTNamespace ns = parser.LookupNamespace(baseIFaceXmlNS); if(ns == null) { throw new SUDSParserException( String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"), baseIFaceXmlNS)); } iFace = ns.LookupInterface(baseIFaceName); if(iFace == null) { throw new SUDSParserException( String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveTypeInNS"), baseIFaceName, baseIFaceXmlNS)); } } _baseIFaces.Add(iFace); } for(int i=0;i<_methods.Count;i++) ((URTMethod) _methods[i]).ResolveTypes(parser); }
internal URTField(String name, String typeName, String xmlNS, SdlParser parser, bool bPrimitive, bool bEmbedded, bool bAttribute, bool bOptional, bool bArray, String arraySize) { Util.Log("URTField.URTField "+name+" typeName "+typeName+" xmlNS "+xmlNS+" bPrimitive "+bPrimitive+" bEmbedded "+bEmbedded+" bAttribute "+bAttribute); _name = name; _typeName = typeName; String typeAssemName; UrtType urtType = parser.IsURTExportedType(xmlNS, out _typeNS, out typeAssemName); if(urtType == UrtType.Interop) _encodedNS = "InteropProxy"; else _encodedNS = _typeNS; _primitiveField = bPrimitive; _embeddedField = bEmbedded; _attributeField = bAttribute; _optionalField = bOptional; _arrayField = bArray; _arraySize = arraySize; }
internal void Extends(String baseName, String baseNS, SdlParser parser) { Util.Log("URTInterface.Extends baseName "+baseName+" baseNSf "+baseNS); _baseIFaceNames.Add(baseName); _baseIFaceNames.Add(baseNS); // Urt namespace will not have schema, they need to be recorded. URTNamespace parsingNamespace = parser.LookupNamespace(baseNS); if(parsingNamespace == null) { parsingNamespace = new URTNamespace(baseNS, parser); parser._URTNamespaces.Add(parsingNamespace); } URTInterface parsingInterface = parsingNamespace.LookupInterface(baseName); if(parsingInterface == null) { parsingInterface = new URTInterface(baseName, parsingNamespace.Namespace, parsingNamespace.EncodedNS); parsingNamespace.AddInterface(parsingInterface); } }
// Resolves the method internal override void ResolveTypes(SdlParser parser) { Util.Log("OnewayMethod.ResolveTypes name "+ _messageElementName); ResolveParams(parser, _messageElementNS, _messageElementName, true); return; }
// Resolves the method internal override void ResolveTypes(SdlParser parser) { Util.Log("RRMethod.ResolveTypes "+_requestElementName+" "+_responseElementName); ResolveParams(parser, _requestElementNS, _requestElementName, true); ResolveParams(parser, _responseElementNS, _responseElementName, false); return; }
// Helper method used by Resolve protected void ResolveParams(SdlParser parser, String targetNS, String targetName, bool bRequest) { Util.Log("URTMethod.ResolveParams targetName "+targetName+"targetNS "+targetNS+" bRequest "+bRequest); // Lookup the element declaration using target namespace and type name URTNamespace elmNS = parser.LookupNamespace(targetNS); if(elmNS == null) { throw new SUDSParserException( String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"), targetNS)); } ElementDecl elm = elmNS.LookupElementDecl(targetName); if(elm == null) { throw new SUDSParserException( String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveElementInNS"), targetName, targetNS)); } // Lookup the type from the element declaration URTNamespace typeNS = parser.LookupNamespace(elm.TypeNS); if(typeNS == null) { throw new SUDSParserException( String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"), elm.TypeNS)); } URTComplexType type = typeNS.LookupComplexType(elm.TypeName); if(type == null) { throw new SUDSParserException( String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveTypeInNS"), elm.TypeName, elm.TypeNS)); } Util.Log("URTMethod.ResolveParams Before RemoveComplexType "); typeNS.RemoveComplexType(type); // The fields of the type are the params of the method ArrayList fields = type.Fields; for(int i=0;i<fields.Count;i++) { URTField field = (URTField) fields[i]; URTParamType pType = bRequest ? URTParamType.IN : URTParamType.OUT; AddParam(new URTParam(field.Name, field.TypeName, field.TypeNS, field.EncodedNS, pType, field.IsEmbedded)); } return; }
// This method is called when the parsing is complete // and is useful for derived types internal abstract void ResolveTypes(SdlParser parser);