internal URTParam(string name, string typeName, string typeNS, string encodedNS, WsdlParser.URTParamType pType, bool bEmbedded, WsdlParser parser, WsdlParser.URTNamespace urtNamespace)
{
this._name = name;
this._typeName = typeName;
this._typeNS = typeNS;
this._encodedNS = encodedNS;
this._pType = pType;
this._embeddedParam = bEmbedded;
this._parser = parser;
this._urtNamespace = urtNamespace;
}
// Resolves internal references
internal void ResolveTypes(WsdlParser parser){
Util.Log("URTNamespace.ResolveTypes "+Name);
/*
// Process nested types
Hashtable typeTable = new Hashtable(10);
for (int i=0;i<_URTComplexTypes.Count;i++)
{
// fill up hashtable with types
URTComplexType ctype = (URTComplexType)_URTComplexTypes[i];
if (ctype.bNestedType)
{
Util.Log("URTNamespace.ResolveTypes nested type outer type "+ctype.OuterTypeName+" nested type "+ctype.NestedTypeName+" fullNestedTypeName "+ctype.Name);
// type is a nested class
URTComplexType outerType = (URTComplexType)typeTable[ctype.OuterTypeName];
if (outerType == null)
{
// place all the URTComplex types in the table, the nested type appears before the outer type in Wsdl
for (int j=0;j<_URTComplexTypes.Count;j++)
{
URTComplexType ctype2 = (URTComplexType)_URTComplexTypes[j];
Util.Log("URTNamespace.ResolveTypes miss find all types "+ctype2.Name);
typeTable[ctype2.Name] = ctype2;
}
}
outerType = (URTComplexType)typeTable[ctype.OuterTypeName];
if (outerType == null)
{
throw new SUDSParserException(
String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveNestedType"),
ctype.Name, ctype.UrlNS));
}
outerType._nestedTypes.Add(ctype);
}
else
{
Util.Log("URTNamespace.ResolveTypes nested place in table "+ctype.Name);
typeTable[ctype.Name] = ctype;
}
}
*/
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);
}
// Main parser
internal SUDSParser(TextReader input, String outputDir, ArrayList outCodeStreamList, String locationURL, bool bWrappedProxy, String proxyNamespace)
{
Util.Log("SUDSParser.SUDSParser outputDir "+outputDir+" locationURL "+locationURL+" bWrappedProxy "+bWrappedProxy+" proxyNamespace "+proxyNamespace);
Util.LogInput(ref input);
wsdlParser = new WsdlParser(input, outputDir, outCodeStreamList, locationURL, bWrappedProxy, proxyNamespace);
}
internal bool Resolve(WsdlParser parser){
Util.Log("ElementDecl.Resolve "+TypeName+" "+TypeNS);
// Return immediately for element declaration of primitive types
if (_bPrimitive)
return true;
// Lookup the type from the element declaration
URTNamespace typeNS = parser.LookupNamespace(TypeNS);
if (typeNS == null)
{
throw new SUDSParserException(
String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"),
TypeNS, TypeName));
}
BaseType type = typeNS.LookupType(TypeName);
if (type == null)
{
// Because there might be multiple bindings and some not soap, there can be failures in the non soap bindings.
return false;
/*
throw new SUDSParserException(
String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveTypeInNS"),
TypeName, TypeNS));
*/
}
type.ElementName = Name;
type.ElementNS = Namespace;
return true;
}
internal static String EncodeInterop(String name, WsdlParser parser)
{
String _encodedNS = name;
if ((parser.ProxyNamespace != null) && parser.ProxyNamespace.Length > 0)
{
String countStr = "";
if (parser.ProxyNamespaceCount > 0)
countStr = (parser.ProxyNamespaceCount).ToString(CultureInfo.InvariantCulture);
parser.ProxyNamespaceCount++;
_encodedNS = parser.ProxyNamespace+countStr;
}
else
{
int index = name.IndexOf(":");
if (index > 0)
_encodedNS = _encodedNS.Substring(index+1);
if (_encodedNS.StartsWith("//", StringComparison.Ordinal))
_encodedNS = _encodedNS.Substring(2);
_encodedNS = _encodedNS.Replace('/', '_');
}
Util.Log("URTNamespace.EncodeInterop encoded "+_encodedNS);
return _encodedNS;
}
internal URTSimpleType(String name, String urlNS, String ns, String encodedNS, bool bAnonymous, WsdlParser parser)
: base(name, urlNS, ns, encodedNS)
{
Util.Log("URTSimpleType.URTSimpleType name "+name+" ns "+ns+" encodedNS "+encodedNS+" bAnonymous "+bAnonymous);
_baseTypeName = null;
_baseTypeXmlNS = null;
_baseType = null;
_fieldString = null;
_facets = new ArrayList();
_bEnum = false;
_bAnonymous = bAnonymous;
_encoding = null;
_parser = parser;
}
internal void Implements(String iFaceName, String iFaceNS, WsdlParser 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.AddNewNamespace(iFaceNS);
/*
if (parsingNamespace == null)
{
parsingNamespace = new URTNamespace(iFaceNS, parser);
}
*/
URTInterface parsingInterface = parsingNamespace.LookupInterface(iFaceName);
if (parsingInterface == null)
{
parsingInterface = new URTInterface(iFaceName, parsingNamespace.Name, parsingNamespace.Namespace, parsingNamespace.EncodedNS, _parser);
parsingNamespace.AddInterface(parsingInterface);
}
}
internal static WsdlParser.WriterStream GetWriterStream(ref WsdlParser.WriterStream outputStreams, string outputDir, string fileName, ref string completeFileName)
{
WsdlParser.WriterStream stream;
for (stream = outputStreams; stream != null; stream = stream._next)
{
if (stream._fileName == fileName)
{
return stream;
}
}
string str = fileName;
if (str.EndsWith(".exe", StringComparison.Ordinal) || str.EndsWith(".dll", StringComparison.Ordinal))
{
str = str.Substring(0, str.Length - 4);
}
string path = outputDir + str + ".cs";
completeFileName = path;
TextWriter writer = new StreamWriter(path, false, new UTF8Encoding(false));
stream = new WsdlParser.WriterStream(fileName, writer) {
_next = outputStreams
};
outputStreams = stream;
return stream;
}
// This method is called when the parsing is complete // and is useful for derived types internal abstract void ResolveTypes(WsdlParser parser);
internal static void Close(WsdlParser.WriterStream outputStreams)
{
for (WsdlParser.WriterStream stream = outputStreams; stream != null; stream = stream._next)
{
stream._writer.Close();
}
}
internal static void Flush(WsdlParser.WriterStream writerStream)
{
while (writerStream != null)
{
writerStream._writer.Flush();
writerStream = writerStream._next;
}
}
internal override WsdlParser.MethodFlags GetMethodFlags(WsdlParser.URTMethod method)
{
return WsdlParser.MethodFlags.None;
}
internal void AddFacet(WsdlParser.SchemaFacet facet)
{
this._facets.Add(facet);
}
internal URTSimpleType(string name, string urlNS, string ns, string encodedNS, bool bAnonymous, WsdlParser parser) : base(name, urlNS, ns, encodedNS)
{
this._baseTypeName = null;
this._baseTypeXmlNS = null;
this._baseType = null;
this._fieldString = null;
this._facets = new ArrayList();
this._bEnum = false;
this._bAnonymous = bAnonymous;
this._encoding = null;
this._parser = parser;
}
internal URTField(String name, String typeName, String xmlNS, WsdlParser parser,
bool bPrimitive, bool bEmbedded, bool bAttribute, bool bOptional,
bool bArray, String arraySize, URTNamespace urtNamespace)
{
Util.Log("URTField.URTField "+name+" typeName "+typeName+" xmlNS "+xmlNS+" bPrimitive "+bPrimitive+" bEmbedded "+bEmbedded+" bAttribute "+bAttribute);
_name = name;
_typeName = typeName;
_parser = parser;
String typeAssemName;
UrtType urtType = parser.IsURTExportedType(xmlNS, out _typeNS, out typeAssemName);
if (urtType == UrtType.Interop)
_encodedNS = urtNamespace.EncodedNS;
else
_encodedNS = _typeNS;
_primitiveField = bPrimitive;
_embeddedField = bEmbedded;
_attributeField = bAttribute;
_optionalField = bOptional;
_arrayField = bArray;
_arraySize = arraySize;
_urtNamespace = urtNamespace;
}
// Helper method used by Resolve
protected void ResolveWsdlParams(WsdlParser parser, String targetNS, String targetName,
bool bRequest, WsdlMethodInfo wsdlMethodInfo)
{
Util.Log("URTMethod.ResolveWsdlParams targetName "+targetName+" targetNS "+targetNS+" bRequest "+bRequest+" wsdlMethodInfo "+wsdlMethodInfo);
_wsdlMethodInfo = wsdlMethodInfo;
_paramNamesOrder = _wsdlMethodInfo.paramNamesOrder;
int length;
if (_wsdlMethodInfo.bProperty)
length = 1;
else if (bRequest)
length = wsdlMethodInfo.inputNames.Length;
else
length = wsdlMethodInfo.outputNames.Length;
for (int i=0; i<length; i++)
{
String element = null;
String elementNs = null;
String name = null;
String nameNs = null;
String typeName = null;;
String typeNameNs = null;;
URTParamType pType;
if (_wsdlMethodInfo.bProperty)
{
typeName = wsdlMethodInfo.propertyType;
typeNameNs = wsdlMethodInfo.propertyNs;
pType = URTParamType.OUT;
}
else if (bRequest && !_wsdlMethodInfo.bProperty)
{
element = wsdlMethodInfo.inputElements[i];
elementNs = wsdlMethodInfo.inputElementsNs[i];
name = wsdlMethodInfo.inputNames[i];
nameNs = wsdlMethodInfo.inputNamesNs[i];
typeName = wsdlMethodInfo.inputTypes[i];
typeNameNs = wsdlMethodInfo.inputTypesNs[i];
pType = URTParamType.IN;
}
else
{
element = wsdlMethodInfo.outputElements[i];
elementNs = wsdlMethodInfo.outputElementsNs[i];
name = wsdlMethodInfo.outputNames[i];
nameNs = wsdlMethodInfo.outputNamesNs[i];
typeName = wsdlMethodInfo.outputTypes[i];
typeNameNs = wsdlMethodInfo.outputTypesNs[i];
pType = URTParamType.OUT;
}
String actualType;
String actualTypeNs;
if ((element == null) || element.Length == 0)
{
actualType = typeName;
actualTypeNs = typeNameNs;
}
else
{
actualType = element;
actualTypeNs = elementNs;
}
Util.Log("URTMethod.ResolveWsdlParams actualType "+actualType+" actualTypeNs "+actualTypeNs);
URTNamespace ns = parser.LookupNamespace(actualTypeNs);
if (ns == null)
{
throw new SUDSParserException(
String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"),
actualTypeNs, actualType));
}
URTComplexType ct = ns.LookupComplexType(actualType);
if (ct != null && ct.IsArray())
{
if (ct.GetArray() == null)
ct.ResolveArray();
String arrayName = ct.GetArray();
URTNamespace arrayNS = ct.GetArrayNS();
AddParam(new URTParam(name, arrayName, arrayNS.Name, arrayNS.EncodedNS, pType, true, parser, arrayNS));
}
else
{
Util.Log("URTMethod.ResolveWsdlParams actualType 2 UrtType "+((Enum)ns.UrtType).ToString());
if (ns.UrtType == UrtType.Xsd)
{
String clrtypeName = parser.MapSchemaTypesToCSharpTypes(actualType);
AddParam(new URTParam(name, clrtypeName, ns.Namespace, ns.EncodedNS, pType, true, parser, ns));
}
else
{
String foundTypeName = null;
if (ct != null)
{
foundTypeName = ct.Name;
}
else
{
URTSimpleType stype = ns.LookupSimpleType(actualType);
if (stype != null)
{
foundTypeName = stype.Name;
}
else
{
foundTypeName = actualType;
/*
throw new SUDSParserException(
String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveTypeInNS"),
actualType, ns.Name));
*/
}
}
//typeNS.RemoveComplexType(type);
AddParam(new URTParam(name, foundTypeName, ns.Namespace, ns.EncodedNS, pType, true, parser, ns));
}
}
}
}
internal virtual void ResolveTypes(WsdlParser parser)
{
}
// Resolves the method
internal override void ResolveTypes(WsdlParser parser)
{
Util.Log("OnewayMethod.ResolveTypes name "+ _messageElementName);
ResolveWsdlParams(parser, _messageElementNS, _messageElementName, true, _wsdlMethodInfo);
if (_paramNamesOrder != null)
{
// reorder parameters if there is a parameter order
Object[] paramsInOrder = new Object[_params.Count];
for (int i=0; i<_params.Count; i++)
{
paramsInOrder[(int)_paramPosition[i]] = _params[i];
}
_params = new ArrayList(paramsInOrder);
}
ResolveMethodAttributes(); //Needs to be after param order
return;
}
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;
}
}
}
internal BaseInterface(String name, String urlNS, String ns, String encodedNS, WsdlParser parser)
{
Util.Log("BaseInterface.BaseInterface");
_name = name;
_urlNS = urlNS;
_namespace = ns;
_encodedNS = encodedNS;
_parser = parser;
}
internal void ResolveTypes(WsdlParser parser)
{
Util.Log("URTComplexType.ResolveTypes "+Name+" _baseTypeName "+_baseTypeName+" IsSUDSType "+IsSUDSType);
String baseTypeNS = null;
String baseTypeAssemName = null;
if (IsArray())
{
ResolveArray();
return;
}
if (IsSUDSType)
{
// BaseType == null;
if (_sudsType == SUDSType.None)
{
if (_parser._bWrappedProxy)
_sudsType = SUDSType.ClientProxy;
else
_sudsType = SUDSType.MarshalByRef;
}
}
if (_baseTypeName != null)
{
Util.Log("URTComplexType.ResolveTypes 1 ");
UrtType urtType = parser.IsURTExportedType(_baseTypeXmlNS, out baseTypeNS, out baseTypeAssemName);
if (urtType == UrtType.UrtSystem || baseTypeNS.StartsWith("System", StringComparison.Ordinal))
{
_baseType = new SystemType(_baseTypeName, _baseTypeXmlNS, baseTypeNS, baseTypeAssemName);
}
else
{
URTNamespace ns = parser.LookupNamespace(_baseTypeXmlNS);
if (ns == null)
{
throw new SUDSParserException(
String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"),
_baseTypeXmlNS, _baseTypeName));
}
_baseType = ns.LookupComplexType(_baseTypeName);
if (_baseType == null)
{
_baseType = new SystemType(_baseTypeName, _baseTypeXmlNS, baseTypeNS, baseTypeAssemName);
/*
throw new SUDSParserException(
String.Format(CoreChannel.GetResourceString("Remoting_Suds_CantResolveTypeInNS"),
_baseTypeName, _baseTypeXmlNS));
*/
}
}
}
// Top of inheritance hiearchy for a Wrapped proxy is RemotingClientProxy
if (IsSUDSType)
{
if (_parser._bWrappedProxy)
{
if (_baseTypeName == null || _baseType is SystemType)
{
_baseTypeName = "RemotingClientProxy";
_baseTypeXmlNS = SoapServices.CodeXmlNamespaceForClrTypeNamespace("System.Runtime.Remoting","System.Runtime.Remoting");
baseTypeNS = "System.Runtime.Remoting.Services";
baseTypeAssemName = "System.Runtime.Remoting";
_baseType = new SystemType(_baseTypeName, _baseTypeXmlNS, baseTypeNS, baseTypeAssemName);
}
}
else if (_baseTypeName == null)
{
_baseTypeName = "MarshalByRefObject";
_baseTypeXmlNS = SoapServices.CodeXmlNamespaceForClrTypeNamespace("System", null);
baseTypeNS = "System";
baseTypeAssemName = null;
_baseType = new SystemType(_baseTypeName, _baseTypeXmlNS, baseTypeNS, baseTypeAssemName);
}
}
else if (_baseType == null)
{
Util.Log("URTComplexType.ResolveTypes 5 ");
_baseType = new SystemType("Object", SoapServices.CodeXmlNamespaceForClrTypeNamespace("System", null), "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", StringComparison.Ordinal))
{
iFace = new SystemInterface(implIFaceName, implIFaceXmlNS, implIFaceNS, parser, implIFaceAssemName);
}
else
{
URTNamespace ns = parser.LookupNamespace(implIFaceXmlNS);
if (ns == null)
{
throw new SUDSParserException(
String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"),
implIFaceXmlNS, implIFaceName));
}
iFace = ns.LookupInterface(implIFaceName);
if (iFace == null)
{
throw new SUDSParserException(
String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_CantResolveTypeInNS"),
implIFaceName, implIFaceXmlNS));
}
}
_implIFaces.Add(iFace);
}
for (int i=0;i<_methods.Count;i++)
((URTMethod) _methods[i]).ResolveTypes(parser);
}
internal SystemInterface(String name, String urlNS, String ns, WsdlParser parser, String assemName)
: base(name, urlNS, ns, ns, parser)
{
Util.Log("SystemInterface.SystemInterface");
Debug.Assert(ns.StartsWith("System", StringComparison.Ordinal), "Invalid System type");
String fullName = ns + '.' + name;
Assembly assem = null;
if (assemName == null)
assem = typeof(string).Assembly;
else
#pragma warning disable 618
assem = Assembly.LoadWithPartialName(assemName, null);
#pragma warning restore 618
if (assem == null)
throw new SUDSParserException(String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_AssemblyNotFound"), assemName));
_type = assem.GetType(fullName, true);
}
// Constructor
internal URTNamespace(String name, WsdlParser parser)
{
Util.Log("URTNamespace.URTNamespace Enter name "+name);
_name = name;
_parser = parser;
_nsType = parser.IsURTExportedType(name, out _namespace, out _assemName);
if (_nsType == UrtType.Interop)
{
_encodedNS = EncodeInterop(_namespace, parser);
}
else
_encodedNS = _namespace;
_elmDecls = new ArrayList();
_URTComplexTypes = new ArrayList();
_numURTComplexTypes = 0;
_URTSimpleTypes = new ArrayList();
_numURTSimpleTypes = 0;
_URTInterfaces = new ArrayList();
_anonymousSeqNum = 0;
parser.AddNamespace(this);
Util.Log("URTNamespace.URTNamespace Exit name "+this.GetHashCode()+" "+name+" _namespace "+_namespace+" _assemName "+_assemName+" _encodedNS "+_encodedNS);
}
internal URTInterface(String name, String urlNS, String ns, String encodedNS, WsdlParser parser)
: base(name, urlNS, ns, encodedNS, parser)
{
Util.Log("URTInterface.URTInterface name "+name+" ns "+ns+" encodedNS "+encodedNS);
_baseIFaces = new ArrayList();
_baseIFaceNames = new ArrayList();
_extendsInterface = new ArrayList();
_methods = new ArrayList();
_parser = parser;
}
// Resolve element references
internal void ResolveElements(WsdlParser parser){
Util.Log("URTNamespace.ResolveElements "+Name);
for (int i=0;i<_elmDecls.Count;i++)
{
((ElementDecl) _elmDecls[i]).Resolve(parser);
}
}
internal void Extends(String baseName, String baseNS, WsdlParser 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.AddNewNamespace(baseNS);
/*
if (parsingNamespace == null)
{
parsingNamespace = new URTNamespace(baseNS, parser);
}
*/
URTInterface parsingInterface = parsingNamespace.LookupInterface(baseName);
if (parsingInterface == null)
{
parsingInterface = new URTInterface(baseName, parsingNamespace.Name, parsingNamespace.Namespace, parsingNamespace.EncodedNS, parser);
parsingNamespace.AddInterface(parsingInterface);
}
_extendsInterface.Add(parsingInterface);
}
internal SUDSParser(TextReader input, string outputDir, ArrayList outCodeStreamList, string locationURL, bool bWrappedProxy, string proxyNamespace)
{
this.wsdlParser = new WsdlParser(input, outputDir, outCodeStreamList, locationURL, bWrappedProxy, proxyNamespace);
}
internal void ResolveTypes(WsdlParser 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", StringComparison.Ordinal))
{
iFace = new SystemInterface(baseIFaceName, baseIFaceXmlNS, baseIFaceNS, _parser, baseIFaceAssemName);
}
else
{
URTNamespace ns = parser.LookupNamespace(baseIFaceXmlNS);
if (ns == null)
{
throw new SUDSParserException(
String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_CantResolveSchemaNS"),
baseIFaceXmlNS, baseIFaceName));
}
iFace = ns.LookupInterface(baseIFaceName);
if (iFace == null)
{
throw new SUDSParserException(
String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_CantResolveTypeInNS"),
baseIFaceName, baseIFaceXmlNS));
}
}
_baseIFaces.Add(iFace);
}
for (int i=0;i<_methods.Count;i++)
((URTMethod) _methods[i]).ResolveTypes(parser);
}
internal URTParam(String name, String typeName, String typeNS, String encodedNS,
URTParamType pType, bool bEmbedded, WsdlParser parser, URTNamespace urtNamespace)
{
Util.Log("URTParam.URTParam name "+name+" typeName "+typeName+" typeNS "+typeNS+" ecodedNS "+encodedNS+" pType "+pType+" bEmbedded "+bEmbedded);
_name = name;
_typeName = typeName;
_typeNS = typeNS;
_encodedNS = encodedNS;
_pType = pType;
_embeddedParam = bEmbedded;
_parser = parser;
_urtNamespace = urtNamespace;
}
internal void ResolveTypes(WsdlParser parser)
{
for (int i = 0; i < this._URTComplexTypes.Count; i++)
{
if (this._URTComplexTypes[i] != null)
{
((WsdlParser.URTComplexType) this._URTComplexTypes[i]).ResolveTypes(parser);
}
}
for (int j = 0; j < this._URTInterfaces.Count; j++)
{
((WsdlParser.URTInterface) this._URTInterfaces[j]).ResolveTypes(parser);
}
}
