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);
}
}
// Adds a new interface into the namespace
internal void AddInterface(URTInterface iface){
Util.Log("URTNamespace.AddInterface "+iface.Name);
_URTInterfaces.Add(iface);
}
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);
}
private void ResolveWsdlInterface(WsdlBinding binding, WsdlBindingSuds suds)
{
Util.Log("WsdlParser.ResolveWsdlInterface "+binding.name+" ns "+binding.parsingNamespace.Namespace+" suds "+suds.typeName);
URTNamespace parsingNamespace = binding.parsingNamespace;
URTNamespace sudsNamespace = AddNewNamespace(suds.ns);
/*
if (sudsNamespace == null)
{
sudsNamespace = new URTNamespace(suds.ns, this);
}
*/
URTInterface parsingInterface = sudsNamespace.LookupInterface(suds.typeName);
if (parsingInterface == null)
{
parsingInterface = new URTInterface(suds.typeName, sudsNamespace.Name, sudsNamespace.Namespace, sudsNamespace.EncodedNS, this);
sudsNamespace.AddInterface(parsingInterface);
}
if (suds.extendsTypeName != null)
{
parsingInterface.Extends(suds.extendsTypeName, suds.extendsNs, this);
}
foreach (WsdlBindingSudsImplements impl in suds.implements)
{
parsingInterface.Extends(impl.typeName, impl.ns, this);
}
ArrayList methodInfos = ResolveWsdlMethodInfo(binding);
foreach (WsdlMethodInfo methodInfo in methodInfos)
{
if ((methodInfo.inputMethodName != null) && (methodInfo.outputMethodName != null))
{
RRMethod parsingRRMethod = new RRMethod(methodInfo, null);
parsingRRMethod.AddRequest(methodInfo.methodName, methodInfo.methodNameNs);
parsingRRMethod.AddResponse(methodInfo.methodName, methodInfo.methodNameNs);
parsingInterface.AddMethod(parsingRRMethod);
}
else if (methodInfo.inputMethodName != null)
{
OnewayMethod parsingOWMethod = new OnewayMethod(methodInfo.methodName, methodInfo.soapAction, null);
parsingOWMethod.AddMessage(methodInfo.methodName, methodInfo.methodNameNs);
parsingInterface.AddMethod(parsingOWMethod);
}
else
{
throw new SUDSParserException(
String.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Suds_WsdlInvalidMessage"),
methodInfo.methodName));
}
}
}
private void ResolveWsdlInterface(WsdlBinding binding, WsdlBindingSuds suds)
{
URTNamespace parsingNamespace = binding.parsingNamespace;
URTNamespace namespace2 = this.AddNewNamespace(suds.ns);
URTInterface iface = namespace2.LookupInterface(suds.typeName);
if (iface == null)
{
iface = new URTInterface(suds.typeName, namespace2.Name, namespace2.Namespace, namespace2.EncodedNS, this);
namespace2.AddInterface(iface);
}
if (suds.extendsTypeName != null)
{
iface.Extends(suds.extendsTypeName, suds.extendsNs, this);
}
foreach (WsdlBindingSudsImplements implements in suds.implements)
{
iface.Extends(implements.typeName, implements.ns, this);
}
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.methodName, info.soapAction, null);
method2.AddMessage(info.methodName, info.methodNameNs);
iface.AddMethod(method2);
}
else
{
RRMethod method = new RRMethod(info, null);
method.AddRequest(info.methodName, info.methodNameNs);
method.AddResponse(info.methodName, info.methodNameNs);
iface.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 interface
private void ParseInterface(URTNamespace parsingNamespace)
{
Util.Log("SdlParser.ParseInterface");
String intfName = LookupAttribute(s_nameString, null, true);
URTInterface parsingInterface = parsingNamespace.LookupInterface(intfName);
if (parsingInterface == null)
{
parsingInterface = new URTInterface(intfName, parsingNamespace.Namespace, parsingNamespace.EncodedNS);
parsingNamespace.AddInterface(parsingInterface);
}
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);
parsingInterface.Extends(nameValue, nameValueNS, this);
ReadNextXmlElement();
continue;
}
else if(MatchingStrings(elmName, s_requestResponseString))
{
ParseRRMethod(null, parsingInterface);
continue;
}
else if(MatchingStrings(elmName, s_onewayString))
{
ParseOnewayMethod(null, parsingInterface);
continue;
}
}
// Ignore others elements such as annotations
SkipXmlElement();
}
return;
}
