internal void DependsOnSUDSNS(XMLNamespace xns){
Util.Log("XMLNamespace.DependsOnSUDSNS "+xns.Name+" "+xns.Assem);
if (LookupSUDSNamespace(xns.Name, xns.Assem) != null)
return;
_dependsOnSUDSNS.Add(xns);
return;
}
// Adds the given type if it has not been encountered before
private void AddType(Type type, XMLNamespace xns)
{
Util.Log("WsdlGenerator.AddType "+type+" ns "+xns.Namespace);
// System.Array says that it has element type, but returns null
// when asked for the element type.<STRIP> IMO, System.Array should not
// say that it has an element type. I have already pointed this
// out to David Mortenson</STRIP>
// Need to get underlying element type
// For arrays of arrays, want element, not embedded array
Type elementType = type.GetElementType();
Type nextelementType = elementType;
while(nextelementType != null)
{
nextelementType = elementType.GetElementType();
if (nextelementType != null)
elementType = nextelementType;
}
Util.Log("WsdlGenerator.AddType elementType "+type+" elementType "+elementType);
if (elementType != null)
EnqueueType(elementType, xns);
if (!type.IsArray && !type.IsByRef)
EnqueueType(type, xns);
if (!(type.IsPublic || type.IsNotPublic))
{
// nested type, enqueue parent
String refTypeName = type.FullName;
int index = refTypeName.IndexOf("+");
if (index > 0)
{
String parentName = refTypeName.Substring(0, index);
Assembly assembly = type.Module.Assembly;
Util.Log("WsdlGenerator.AddType parentName "+parentName+" assembly "+assembly);
Type parentType = assembly.GetType(parentName, true);
Util.Log("WsdlGenerator.AddType parentType "+parentType);
if (parentType == null)
{
//Error nested type
}
EnqueueType(parentType, xns);
}
}
}
internal static String TypeName(Type type, bool bEmbedded, XMLNamespace thisxns)
{
Util.Log("RealSchemaType.TypeName entry "+type+" bEmbedded "+bEmbedded+" xns "+thisxns.Name);
String typeName = null;
if (type.IsArray)
return ProcessArray(type, thisxns);
String clrTypeName = WsdlGenerator.RefName(type);
Type clrType = type;
// If ref type the name ends in &
if (type.IsByRef)
{
clrType = type.GetElementType();
clrTypeName = WsdlGenerator.RefName(clrType);
if (clrType.IsArray)
return ProcessArray(clrType, thisxns);
}
typeName = SudsConverter.MapClrTypeToXsdType(clrType);
if (typeName == null)
{
String ns = type.Namespace;
Assembly assem = type.Module.Assembly;
XMLNamespace xns = null;
Util.Log("RealSchemaType.TypeName realNS "+ns);
xns = (XMLNamespace)thisxns.Generator._typeToInteropNS[type];
if (xns == null)
{
xns = thisxns.LookupSchemaNamespace(ns, assem);
if (xns == null)
{
xns = thisxns.Generator.LookupNamespace(ns,assem);
if (xns == null)
{
xns = thisxns.Generator.AddNamespace(ns, assem);
}
thisxns.DependsOnSchemaNS(xns, false);
}
Util.Log("RealSchemaType.TypeName depended NS with assem equals "+xns.Name);
}
StringBuilder sb = new StringBuilder(256);
sb.Append(xns.Prefix);
sb.Append(':');
sb.Append(clrTypeName);
typeName = sb.ToString();
}
Util.Log("RealSchemaType.TypeName exit "+typeName);
return typeName;
}
internal void DependsOnSchemaNS(XMLNamespace xns, bool bImport){
Util.Log("XMLNamespace.DependsOnSchemaNS "+Namespace+" depends on "+xns.Namespace+" bImport "+bImport);
if (LookupSchemaNamespace(xns.Name, xns.Assem) != null)
return;
_dependsOnSchemaNS.Add(xns);
if (bImport && Namespace != xns.Namespace)
_xnsImports.Add(xns);
return;
}
// Adds the given type if it has not been encountered before
private void AddType(Type type, XMLNamespace xns)
{
Util.Log("SdlGenerator.AddTypes "+type);
// System.Array says that it has element type, but returns null
// when asked for the element type.
if (type.HasElementType)
{
Type eType = type.GetElementType();
if (eType != null)
{
type = eType;
while (type.HasElementType)
type = type.GetElementType();
}
}
if (type.IsPrimitive == false)
{
String ns;
Assembly assem;
bool bInteropType = GetNSAndAssembly(type, out ns, out assem);
// Lookup the namespace
XMLNamespace dependsOnNS = LookupNamespace(ns, assem);
// Create a new namespace if neccessary
if (dependsOnNS == null)
dependsOnNS = AddNamespace(ns, assem, bInteropType);
// The supplied namespace depends directly on the namespace of the type
xns.DependsOnSchemaNS(dependsOnNS);
// Enqueue the type if it does not belong to system namespace
if ((ns == null) || !ns.StartsWith("System"))
{
_queue.Enqueue(type);
}
}
return;
}
private static String ProcessArray(Type type, XMLNamespace xns)
{
Util.Log("RealSchemaType.ProcessArray Enter "+type);
String qname = null;
bool bbinary = false;
Type elementType = type.GetElementType();
String elementTypeName = "ArrayOf";
while (elementType.IsArray)
{
elementTypeName = elementTypeName+"ArrayOf";
elementType = elementType.GetElementType();
}
qname = RealSchemaType.TypeName(elementType, true, xns);
int index = qname.IndexOf(":");
String prefix = qname.Substring(0, index);
String wireName = qname.Substring(index+1);
Util.Log("RealSchemaType.ProcessArray qname "+qname+" wirename "+wireName);
int rank = type.GetArrayRank();
String rankStr = "";
if (rank > 1)
rankStr = rank.ToString(CultureInfo.InvariantCulture);
String csname =elementTypeName+wireName.Substring(0,1).ToUpper(CultureInfo.InvariantCulture)+wireName.Substring(1)+rankStr;
csname = csname.Replace('+','N'); // need to get rid of + in nested classes
ArraySchemaType ast = xns.LookupArraySchemaType(csname);
if (ast == null)
{
ArraySchemaType cstype = new ArraySchemaType(type, csname, SchemaBlockType.ComplexContent, false);
Restriction restriction = new Restriction();
SchemaAttribute attribute = new SchemaAttribute();
if (bbinary)
attribute.AddArray(qname);
else
{
String arrayTypeName = type.Name;
index = arrayTypeName.IndexOf("[");
attribute.AddArray(qname+arrayTypeName.Substring(index));
}
restriction.AddArray(attribute);
cstype.AddParticle(restriction);
xns.AddArraySchemaType(cstype);
}
String returnStr = xns.Prefix+":"+csname;
Util.Log("RealSchemaType.ProcessArray Exit "+returnStr);
return returnStr;
}
private SimpleSchemaType(Type type, XMLNamespace xns)
{
Util.Log("SimpleSchemaType.SimpleSchemaType "+type+" xns "+((xns != null) ? xns.Name : "Null"));
_type = type;
_xns = xns;
_abstractElms = new ArrayList();
_fullRefName = WsdlGenerator.RefName(type);
}
internal Restriction(String baseName, XMLNamespace baseNS)
{
Util.Log("Restriction.Restriction "+baseName+" "+baseNS.Namespace);
_baseName = baseName;
_baseNS = baseNS;
}
private void AddType(Type type, XMLNamespace xns)
{
Type elementType = type.GetElementType();
Type type3 = elementType;
while (type3 != null)
{
type3 = elementType.GetElementType();
if (type3 != null)
{
elementType = type3;
}
}
if (elementType != null)
{
this.EnqueueType(elementType, xns);
}
if (!type.IsArray && !type.IsByRef)
{
this.EnqueueType(type, xns);
}
if (!type.IsPublic && !type.IsNotPublic)
{
string fullName = type.FullName;
int index = fullName.IndexOf("+");
if (index > 0)
{
string name = fullName.Substring(0, index);
Type type4 = type.Module.Assembly.GetType(name, true);
bool flag1 = type4 == null;
this.EnqueueType(type4, xns);
}
}
}
private void EnqueueType(Type type, XMLNamespace xns)
{
if (!type.IsPrimitive || (type == s_charType))
{
string str;
Assembly assembly;
XMLNamespace namespace2 = null;
bool bInteropType = GetNSAndAssembly(type, out str, out assembly);
namespace2 = this.LookupNamespace(str, assembly);
if (namespace2 == null)
{
namespace2 = this.AddNamespace(str, assembly, bInteropType);
}
string str2 = SudsConverter.MapClrTypeToXsdType(type);
if ((type.IsInterface || (str2 != null)) || (type == s_voidType))
{
xns.DependsOnSchemaNS(namespace2, false);
}
else
{
xns.DependsOnSchemaNS(namespace2, true);
}
if (!type.FullName.StartsWith("System."))
{
this._queue.Enqueue(type);
}
}
}
private XMLNamespace AddNamespace(string name, Assembly assem, bool bInteropType)
{
XMLNamespace namespace2 = new XMLNamespace(name, assem, this._serviceEndpoint, this._typeToServiceEndpoint, "ns" + this._namespaces.Count, bInteropType, this);
this._namespaces.Add(namespace2);
return namespace2;
}
internal RealSchemaType(Type type, XMLNamespace xns, String serviceEndpoint, Hashtable typeToServiceEndpoint, bool bUnique)
: base(type.Name, type.IsSealed)
{
Util.Log("RealSchemaType.RealSchemaType "+type+" xns "+xns.Name+" serviceEndpoint "+serviceEndpoint+" bUnique "+bUnique);
_type = type;
_serviceEndpoint = serviceEndpoint;
_typeToServiceEndpoint = typeToServiceEndpoint;
_bUnique = bUnique;
_bStruct = type.IsValueType;
_xns = xns;
_implIFaces = null;
_iFaces = null;
_methods = null;
_fields = null;
_methodTypes = null;
}
internal static SimpleSchemaType GetSimpleSchemaType(Type type, XMLNamespace xns, bool fInline)
{
Util.Log("SimpleSchemaType.GetSimpleSchemaType "+type+" xns "+xns.Name);
SimpleSchemaType ssType = null;
if (fInline)
{
if ((type.IsArray == true) &&
(type.GetArrayRank() == 1) &&
(type.GetElementType() == typeof(byte)))
{
if (_byteArraySchemaType == null)
{
_byteArraySchemaType = new SimpleSchemaType(type, null);
_byteArraySchemaType._baseName = "xsd:binary";
_byteArraySchemaType._abstractElms.Add(new EncodingElement("base64"));
}
ssType = _byteArraySchemaType;
}
}
else
{
if (type.IsEnum)
{
ssType = new SimpleSchemaType(type, xns);
ssType._baseName = RealSchemaType.TypeName(Enum.GetUnderlyingType(type), true, null);
String[] values = Enum.GetNames(type);
for (int i=0;i<values.Length;i++)
ssType._abstractElms.Add(new EnumElement(values[i]));
}
else
{
}
}
return(ssType);
}
private void EnqueueType(Type type, XMLNamespace xns)
{
Util.Log("WsdlGenerator.EnqueueType "+type+" ns "+xns.Namespace);
if (!type.IsPrimitive || type == s_charType) //char is not a xsd type
{
String ns;
Assembly assem;
XMLNamespace dependsOnNS = null;
bool bInteropType = GetNSAndAssembly(type, out ns, out assem);
// Lookup the namespace
dependsOnNS = LookupNamespace(ns, assem);
// Creat a new namespace if neccessary
if (dependsOnNS == null)
dependsOnNS = AddNamespace(ns, assem, bInteropType);
// The supplied namespace depends directly on the namespace of the type
String typeString = SudsConverter.MapClrTypeToXsdType(type); //see if this is a xsd type
if (type.IsInterface || typeString != null || type == s_voidType)
{
// Interfaces aren't in schema section
// Any xsd type
xns.DependsOnSchemaNS(dependsOnNS, false);
}
else
xns.DependsOnSchemaNS(dependsOnNS, true);
// Enqueue the type if does not belong to system namespace
if (!type.FullName.StartsWith("System."))
{
Util.Log("WsdlGenerator.EnqueueType place on queue "+type+" ns "+xns.Namespace);
_queue.Enqueue(type);
}
}
}
internal static SimpleSchemaType GetSimpleSchemaType(Type type, XMLNamespace xns, bool fInline)
{
Util.Log("SimpleSchemaType.GetSimpleSchemaType "+type+" xns "+xns.Name);
SimpleSchemaType ssType = null;
if (type.IsEnum)
{
ssType = new SimpleSchemaType(type, xns);
String baseName = RealSchemaType.TypeName(Enum.GetUnderlyingType(type), true, xns);
ssType._restriction = new Restriction(baseName, xns);
String[] values = Enum.GetNames(type);
for (int i=0;i<values.Length;i++)
ssType._restriction._abstractElms.Add(new EnumElement(values[i]));
ssType._restriction._rtype = Restriction.RestrictionType.Enum;
}
else
{
}
return(ssType);
}
private XMLNamespace AddNamespace(String name, Assembly assem, bool bInteropType)
{
Util.Log("WsdlGenerator.AddNamespace "+name);
Debug.Assert(LookupNamespace(name, assem) == null, "Duplicate Type found");
XMLNamespace xns = new XMLNamespace(name, assem,
_serviceEndpoint,
_typeToServiceEndpoint,
"ns" + _namespaces.Count,
bInteropType, this);
_namespaces.Add(xns);
return(xns);
}
internal RealSchemaType(Type type, XMLNamespace xns, String serviceEndpoint, Hashtable typeToServiceEndpoint, bool bUnique, WsdlGenerator WsdlGenerator)
: base(type)
{
Util.Log("RealSchemaType.RealSchemaType "+type+" xns "+xns.Name+" serviceEndpoint "+serviceEndpoint+" bUnique "+bUnique);
_type = type;
_serviceEndpoint = serviceEndpoint;
_typeToServiceEndpoint = typeToServiceEndpoint;
_bUnique = bUnique;
_WsdlGenerator = WsdlGenerator;
_bStruct = type.IsValueType;
_xns = xns;
_implIFaces = null;
_iFaces = null;
_methods = null;
_fields = null;
_methodTypes = null;
_nestedTypes = type.GetNestedTypes();
if (_nestedTypes != null)
{
foreach (Type ntype in _nestedTypes)
{
Util.Log("RealSchemaType.RealSchemaType nested classes"+ntype);
_WsdlGenerator.AddType(ntype, xns);
}
}
}
internal SchemaElement(String name, Type type, bool bEmbedded, XMLNamespace xns)
: base(){
Util.Log("SchemaElement.SchemaElement Particle "+name+" type "+type+" bEmbedded "+bEmbedded);
_name = name;
_typeString = null;
_schemaType = SimpleSchemaType.GetSimpleSchemaType(type, xns, true);
_typeString = RealSchemaType.TypeName(type, bEmbedded, xns);
}
internal static String TypeName(Type type, bool bEmbedded, XMLNamespace thisxns)
{
Util.Log("RealSchemaType.TypeName "+type+" bEmbedded "+bEmbedded);
String typeName;
Type uType;
if (type.HasElementType && ((uType = type.GetElementType()) != null))
{
while (uType.HasElementType)
uType = uType.GetElementType();
String uTypeName = TypeName(uType, type.IsArray, thisxns);
String suffix = type.Name.Substring(uType.Name.Length);
// Escape the compiler warning
typeName = " suds:refType='";
if (type.IsArray)
{
StringBuilder sb = new StringBuilder(256);
if (bEmbedded)
sb.Append("soap:Array'");
else
sb.Append("soap:Reference'");
sb.Append(typeName);
sb.Append(uTypeName);
sb.Append(suffix);
typeName = sb.ToString();
}
else if (type.IsByRef)
{
typeName = uTypeName;
}
else if (type.IsPointer)
{
typeName = uTypeName;
}
else
{
Debug.Assert(false, "Should not have reached here");
}
}
else if (type.IsPrimitive)
{
typeName = "xsd:" + MapURTTypesToSchemaTypes(type.Name);
}
else if (type.FullName == "System.String")
{
typeName = "xsd:string";
}
else if (type.FullName == "System.Object")
{
if (bEmbedded)
typeName = "xsd:ur-type"; //null;
else
typeName = "soap:Reference' suds:refType='xsd:ur-type";
}
else if (type.FullName == "System.Void")
{
typeName = "void";
}
else
{
String ns = type.Namespace;
Assembly assem = type.Module.Assembly;
XMLNamespace xns = thisxns.LookupSchemaNamespace(ns, assem);
StringBuilder sb = new StringBuilder(256);
if (bEmbedded == false && type.IsValueType == false)
sb.Append("soap:Reference' suds:refType='");
sb.Append(xns.Prefix);
sb.Append(':');
sb.Append(type.Name);
typeName = sb.ToString();
}
return(typeName);
}
