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;
}
