internal XmlMembersMapping(TypeScope scope, ElementAccessor accessor, XmlMappingAccess access) : base(scope, accessor, access)
{
MembersMapping mapping = (MembersMapping)accessor.Mapping !;
StringBuilder key = new StringBuilder();
key.Append(':');
_mappings = new XmlMemberMapping[mapping.Members !.Length];
/// <include file='doc\SoapSchemaImporter.uex' path='docs/doc[@for="SoapSchemaImporter.ImportMembersMapping"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public XmlMembersMapping ImportMembersMapping(string name, string ns, SoapSchemaMember member)
{
TypeMapping typeMapping = ImportType(member.MemberType, true);
if (!(typeMapping is StructMapping))
{
return(ImportMembersMapping(name, ns, new SoapSchemaMember[] { member }));
}
MembersMapping mapping = new MembersMapping();
mapping.TypeDesc = Scope.GetTypeDesc(typeof(object[]));
mapping.Members = ((StructMapping)typeMapping).Members;
mapping.HasWrapperElement = true;
ElementAccessor accessor = new ElementAccessor();
accessor.IsSoap = true;
accessor.Name = name;
accessor.Namespace = typeMapping.Namespace != null ? typeMapping.Namespace : ns;
accessor.Mapping = mapping;
accessor.IsNullable = false;
accessor.Form = XmlSchemaForm.Qualified;
return(new XmlMembersMapping(Scope, accessor, XmlMappingAccess.Read | XmlMappingAccess.Write));
}
internal XmlMembersMapping(TypeScope scope, ElementAccessor accessor) : base(scope)
{
this.accessor = accessor;
MembersMapping mapping = (MembersMapping)accessor.Mapping;
mappings = new XmlMemberMapping[mapping.Members.Length];
for (int i = 0; i < mappings.Length; i++)
{
mappings[i] = new XmlMemberMapping(scope, mapping.Members[i]);
}
}
XmlSchemaType ExportMembersMapping(MembersMapping mapping, string ns)
{
XmlSchemaComplexType type = new XmlSchemaComplexType();
ExportTypeMembers(type, mapping.Members, mapping.TypeName, ns, false);
if (mapping.XmlnsMember != null)
{
AddXmlnsAnnotation(type, mapping.XmlnsMember.Name);
}
return(type);
}
/// <include file='doc\XmlSchemaExporter.uex' path='docs/doc[@for="XmlSchemaExporter.ExportTypeMapping1"]/*' />
public XmlQualifiedName ExportTypeMapping(XmlMembersMapping xmlMembersMapping)
{
CheckScope(xmlMembersMapping.Scope);
MembersMapping mapping = (MembersMapping)xmlMembersMapping.Accessor.Mapping;
if (mapping.Members.Length == 1 && mapping.Members[0].Elements[0].Mapping is SpecialMapping)
{
SpecialMapping special = (SpecialMapping)mapping.Members[0].Elements[0].Mapping;
XmlSchemaType type = ExportSpecialMapping(special, xmlMembersMapping.Accessor.Namespace, false);
type.Name = xmlMembersMapping.Accessor.Name;
AddSchemaItem(type, xmlMembersMapping.Accessor.Namespace, null);
ExportRootIfNecessary(xmlMembersMapping.Scope);
return(new XmlQualifiedName(xmlMembersMapping.Accessor.Name, xmlMembersMapping.Accessor.Namespace));
}
return(null);
}
MembersMapping ImportMembersMapping(XmlReflectionMember[] xmlReflectionMembers, string ns, bool hasWrapperElement, bool writeAccessors, bool validateWrapperElement)
{
MembersMapping members = new MembersMapping();
members.TypeDesc = typeScope.GetTypeDesc(typeof(object[]));
MemberMapping[] mappings = new MemberMapping[xmlReflectionMembers.Length];
for (int i = 0; i < mappings.Length; i++)
{
try {
XmlReflectionMember member = xmlReflectionMembers[i];
MemberMapping mapping = ImportMemberMapping(member, ns, xmlReflectionMembers, hasWrapperElement ? XmlSchemaForm.Unqualified : XmlSchemaForm.Qualified);
if (member.IsReturnValue && writeAccessors) // no special treatment for return values with doc/enc
{
if (i > 0)
{
throw new InvalidOperationException(Res.GetString(Res.XmlInvalidReturnPosition));
}
mapping.IsReturnValue = true;
}
mappings[i] = mapping;
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
{
throw;
}
throw ReflectionException(xmlReflectionMembers[i].MemberName, e);
}
catch {
throw ReflectionException(xmlReflectionMembers[i].MemberName, null);
}
}
members.Members = mappings;
members.HasWrapperElement = hasWrapperElement;
if (hasWrapperElement)
{
members.ValidateRpcWrapperElement = validateWrapperElement;
}
members.WriteAccessors = writeAccessors;
members.IsSoap = true;
if (hasWrapperElement && !writeAccessors)
{
members.Namespace = ns;
}
return(members);
}
private MembersMapping ImportMembersMapping(XmlReflectionMember[] xmlReflectionMembers, string ns, bool hasWrapperElement, bool writeAccessors, bool validateWrapperElement, RecursionLimiter limiter)
{
MembersMapping mapping = new MembersMapping {
TypeDesc = this.typeScope.GetTypeDesc(typeof(object[]))
};
MemberMapping[] mappingArray = new MemberMapping[xmlReflectionMembers.Length];
for (int i = 0; i < mappingArray.Length; i++)
{
try
{
XmlReflectionMember xmlReflectionMember = xmlReflectionMembers[i];
MemberMapping mapping2 = this.ImportMemberMapping(xmlReflectionMember, ns, xmlReflectionMembers, hasWrapperElement ? XmlSchemaForm.Unqualified : XmlSchemaForm.Qualified, limiter);
if (xmlReflectionMember.IsReturnValue && writeAccessors)
{
if (i > 0)
{
throw new InvalidOperationException(Res.GetString("XmlInvalidReturnPosition"));
}
mapping2.IsReturnValue = true;
}
mappingArray[i] = mapping2;
}
catch (Exception exception)
{
if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException))
{
throw;
}
throw this.ReflectionException(xmlReflectionMembers[i].MemberName, exception);
}
}
mapping.Members = mappingArray;
mapping.HasWrapperElement = hasWrapperElement;
if (hasWrapperElement)
{
mapping.ValidateRpcWrapperElement = validateWrapperElement;
}
mapping.WriteAccessors = writeAccessors;
mapping.IsSoap = true;
if (hasWrapperElement && !writeAccessors)
{
mapping.Namespace = ns;
}
return(mapping);
}
/// <include file='doc\SoapSchemaImporter.uex' path='docs/doc[@for="SoapSchemaImporter.ImportMembersMapping3"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public XmlMembersMapping ImportMembersMapping(string name, string ns, SoapSchemaMember[] members, bool hasWrapperElement, Type baseType, bool baseTypeCanBeIndirect)
{
XmlSchemaComplexType type = new XmlSchemaComplexType();
XmlSchemaSequence seq = new XmlSchemaSequence();
type.Particle = seq;
foreach (SoapSchemaMember member in members)
{
XmlSchemaElement element = new XmlSchemaElement();
element.Name = member.MemberName;
element.SchemaTypeName = member.MemberType;
seq.Items.Add(element);
}
CodeIdentifiers identifiers = new CodeIdentifiers();
identifiers.UseCamelCasing = true;
MembersMapping mapping = new MembersMapping();
mapping.TypeDesc = Scope.GetTypeDesc(typeof(object[]));
mapping.Members = ImportTypeMembers(type, ns, identifiers);
mapping.HasWrapperElement = hasWrapperElement;
if (baseType != null)
{
for (int i = 0; i < mapping.Members.Length; i++)
{
MemberMapping member = mapping.Members[i];
if (member.Accessor.Mapping is StructMapping)
{
MakeDerived((StructMapping)member.Accessor.Mapping, baseType, baseTypeCanBeIndirect);
}
}
}
ElementAccessor accessor = new ElementAccessor();
accessor.IsSoap = true;
accessor.Name = name;
accessor.Namespace = ns;
accessor.Mapping = mapping;
accessor.IsNullable = false;
accessor.Form = XmlSchemaForm.Qualified;
return(new XmlMembersMapping(Scope, accessor, XmlMappingAccess.Read | XmlMappingAccess.Write));
}
public XmlMembersMapping ImportMembersMapping(string name, string ns, SoapSchemaMember member)
{
TypeMapping mapping = this.ImportType(member.MemberType, true);
if (!(mapping is StructMapping))
{
return(this.ImportMembersMapping(name, ns, new SoapSchemaMember[] { member }));
}
MembersMapping mapping2 = new MembersMapping {
TypeDesc = base.Scope.GetTypeDesc(typeof(object[])),
Members = ((StructMapping)mapping).Members,
HasWrapperElement = true
};
return(new XmlMembersMapping(base.Scope, new ElementAccessor {
IsSoap = true, Name = name, Namespace = (mapping.Namespace != null) ? mapping.Namespace : ns, Mapping = mapping2, IsNullable = false, Form = XmlSchemaForm.Qualified
}, XmlMappingAccess.Write | XmlMappingAccess.Read));
}
internal XmlMembersMapping(TypeScope scope, ElementAccessor accessor, XmlMappingAccess access) : base(scope, accessor, access)
{
MembersMapping mapping = (MembersMapping)accessor.Mapping;
StringBuilder builder = new StringBuilder();
builder.Append(":");
this.mappings = new XmlMemberMapping[mapping.Members.Length];
for (int i = 0; i < this.mappings.Length; i++)
{
if (mapping.Members[i].TypeDesc.Type != null)
{
builder.Append(XmlMapping.GenerateKey(mapping.Members[i].TypeDesc.Type, null, null));
builder.Append(":");
}
this.mappings[i] = new XmlMemberMapping(mapping.Members[i]);
}
base.SetKeyInternal(builder.ToString());
}
internal XmlMembersMapping(TypeScope scope, ElementAccessor accessor, XmlMappingAccess access) : base(scope, accessor, access)
{
MembersMapping mapping = (MembersMapping)accessor.Mapping;
StringBuilder key = new StringBuilder();
key.Append(":");
mappings = new XmlMemberMapping[mapping.Members.Length];
for (int i = 0; i < mappings.Length; i++)
{
if (mapping.Members[i].TypeDesc.Type != null)
{
key.Append(GenerateKey(mapping.Members[i].TypeDesc.Type, null, null));
key.Append(":");
}
mappings[i] = new XmlMemberMapping(mapping.Members[i]);
}
SetKeyInternal(key.ToString());
}
XmlQualifiedName ExportMembersMapping(MembersMapping mapping, string ns)
{
XmlSchemaComplexType type = (XmlSchemaComplexType)types[mapping];
if (type == null)
{
CheckForDuplicateType(mapping.TypeName, mapping.Namespace);
type = new XmlSchemaComplexType();
type.Name = mapping.TypeName;
types.Add(mapping, type);
AddSchemaItem(type, mapping.Namespace, ns);
ExportTypeMembers(type, mapping.Members, mapping.Namespace);
}
else
{
AddSchemaImport(mapping.Namespace, ns);
}
return(new XmlQualifiedName(type.Name, mapping.Namespace));
}
/// <include file='doc\SoapSchemaExporter.uex' path='docs/doc[@for="SoapSchemaExporter.ExportMembersMapping1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping, bool exportEnclosingType)
{
CheckScope(xmlMembersMapping.Scope);
MembersMapping membersMapping = (MembersMapping)xmlMembersMapping.Accessor.Mapping;
if (exportEnclosingType)
{
ExportTypeMapping(membersMapping, null);
}
else
{
foreach (MemberMapping memberMapping in membersMapping.Members)
{
if (memberMapping.Elements.Length > 0)
{
ExportTypeMapping(memberMapping.Elements[0].Mapping, null);
}
}
}
}
public XmlMembersMapping ImportMembersMapping(string name, string ns, SoapSchemaMember[] members, bool hasWrapperElement, Type baseType, bool baseTypeCanBeIndirect)
{
XmlSchemaComplexType type = new XmlSchemaComplexType();
XmlSchemaSequence sequence = new XmlSchemaSequence();
type.Particle = sequence;
foreach (SoapSchemaMember member in members)
{
XmlSchemaElement item = new XmlSchemaElement {
Name = member.MemberName,
SchemaTypeName = member.MemberType
};
sequence.Items.Add(item);
}
CodeIdentifiers identifiers = new CodeIdentifiers {
UseCamelCasing = true
};
MembersMapping mapping = new MembersMapping {
TypeDesc = base.Scope.GetTypeDesc(typeof(object[])),
Members = this.ImportTypeMembers(type, ns, identifiers),
HasWrapperElement = hasWrapperElement
};
if (baseType != null)
{
for (int i = 0; i < mapping.Members.Length; i++)
{
MemberMapping mapping2 = mapping.Members[i];
if (mapping2.Accessor.Mapping is StructMapping)
{
base.MakeDerived((StructMapping)mapping2.Accessor.Mapping, baseType, baseTypeCanBeIndirect);
}
}
}
return(new XmlMembersMapping(base.Scope, new ElementAccessor {
IsSoap = true, Name = name, Namespace = ns, Mapping = mapping, IsNullable = false, Form = XmlSchemaForm.Qualified
}, XmlMappingAccess.Write | XmlMappingAccess.Read));
}
/// <include file='doc\XmlSchemaExporter.uex' path='docs/doc[@for="XmlSchemaExporter.ExportMembersMapping"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping)
{
MembersMapping mapping = (MembersMapping)xmlMembersMapping.Accessor.Mapping;
CheckScope(xmlMembersMapping.Scope);
if (mapping.HasWrapperElement)
{
ExportElement(xmlMembersMapping.Accessor);
}
else
{
foreach (MemberMapping member in mapping.Members)
{
if (member.Attribute != null)
{
throw new InvalidOperationException(Res.GetString(Res.XmlBareAttributeMember, member.Attribute.Name));
}
else if (member.Text != null)
{
throw new InvalidOperationException(Res.GetString(Res.XmlBareTextMember, member.Text.Name));
}
else if (member.Elements == null || member.Elements.Length == 0)
{
continue;
}
if (member.TypeDesc.IsArray && !(member.Elements[0].Mapping is ArrayMapping))
{
throw new InvalidOperationException(Res.GetString(Res.XmlIllegalArrayElement, member.Elements[0].Name));
}
ExportElement(member.Elements[0]);
}
}
ExportRootIfNecessary(xmlMembersMapping.Scope);
}
/// <include file='doc\XmlSchemaImporter.uex' path='docs/doc[@for="XmlSchemaImporter.ImportMembersMapping2"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public XmlMembersMapping ImportMembersMapping(XmlQualifiedName[] names, Type baseType, bool baseTypeCanBeIndirect) {
CodeIdentifiers memberScope = new CodeIdentifiers();
memberScope.UseCamelCasing = true;
MemberMapping[] members = new MemberMapping[names.Length];
for (int i = 0; i < names.Length; i++) {
XmlQualifiedName name = EncodeQName(names[i]);
ElementAccessor accessor = ImportElement(name, typeof(TypeMapping), baseType);
if (baseType != null && accessor.Mapping is StructMapping)
MakeDerived((StructMapping)accessor.Mapping, baseType, baseTypeCanBeIndirect);
MemberMapping member = new MemberMapping();
member.Name = CodeIdentifier.MakeValid(Accessor.UnescapeName(accessor.Name));
member.Name = memberScope.AddUnique(member.Name, member);
member.TypeDesc = accessor.Mapping.TypeDesc;
member.Elements = new ElementAccessor[] { accessor };
members[i] = member;
}
MembersMapping mapping = new MembersMapping();
mapping.HasWrapperElement = false;
mapping.TypeDesc = scope.GetTypeDesc(typeof(object[]));
mapping.Members = members;
ElementAccessor element = new ElementAccessor();
element.Mapping = mapping;
return new XmlMembersMapping(scope, element);
}
private XmlSchemaType ExportMembersMapping(MembersMapping mapping, string ns)
{
XmlSchemaComplexType type = new XmlSchemaComplexType();
this.ExportTypeMembers(type, mapping.Members, mapping.TypeName, ns, false, false);
if (mapping.XmlnsMember != null)
{
this.AddXmlnsAnnotation(type, mapping.XmlnsMember.Name);
}
return type;
}
public XmlMembersMapping ImportMembersMapping(XmlQualifiedName[] names, Type baseType, bool baseTypeCanBeIndirect)
{
CodeIdentifiers identifiers = new CodeIdentifiers {
UseCamelCasing = true
};
MemberMapping[] mappingArray = new MemberMapping[names.Length];
for (int i = 0; i < names.Length; i++)
{
MemberMapping mapping;
XmlQualifiedName name = names[i];
ElementAccessor accessor = this.ImportElement(name, typeof(TypeMapping), baseType);
if ((baseType != null) && (accessor.Mapping is StructMapping))
{
base.MakeDerived((StructMapping) accessor.Mapping, baseType, baseTypeCanBeIndirect);
}
mappingArray[i] = new MemberMapping { Name = CodeIdentifier.MakeValid(Accessor.UnescapeName(accessor.Name)), Name = identifiers.AddUnique(mapping.Name, mapping), TypeDesc = accessor.Mapping.TypeDesc, Elements = new ElementAccessor[] { accessor } };
}
MembersMapping mapping2 = new MembersMapping {
HasWrapperElement = false,
TypeDesc = base.Scope.GetTypeDesc(typeof(object[])),
Members = mappingArray
};
return new XmlMembersMapping(base.Scope, new ElementAccessor { Mapping = mapping2 }, XmlMappingAccess.Write | XmlMappingAccess.Read);
}
private MembersMapping ImportMembersMapping(XmlReflectionMember[] xmlReflectionMembers, string ns, bool hasWrapperElement, bool rpc, bool openModel, RecursionLimiter limiter)
{
MembersMapping mapping = new MembersMapping {
TypeDesc = this.typeScope.GetTypeDesc(typeof(object[]))
};
MemberMapping[] mappingArray = new MemberMapping[xmlReflectionMembers.Length];
System.Xml.Serialization.NameTable elements = new System.Xml.Serialization.NameTable();
System.Xml.Serialization.NameTable attributes = new System.Xml.Serialization.NameTable();
TextAccessor text = null;
bool isSequence = false;
for (int i = 0; i < mappingArray.Length; i++)
{
try
{
MemberMapping member = this.ImportMemberMapping(xmlReflectionMembers[i], ns, xmlReflectionMembers, rpc, openModel, limiter);
if (!hasWrapperElement && (member.Attribute != null))
{
if (rpc)
{
throw new InvalidOperationException(Res.GetString("XmlRpcLitAttributeAttributes"));
}
throw new InvalidOperationException(Res.GetString("XmlInvalidAttributeType", new object[] { "XmlAttribute" }));
}
if (rpc && xmlReflectionMembers[i].IsReturnValue)
{
if (i > 0)
{
throw new InvalidOperationException(Res.GetString("XmlInvalidReturnPosition"));
}
member.IsReturnValue = true;
}
mappingArray[i] = member;
isSequence |= member.IsSequence;
if (!xmlReflectionMembers[i].XmlAttributes.XmlIgnore)
{
AddUniqueAccessor(member, elements, attributes, isSequence);
}
mappingArray[i] = member;
if (member.Text != null)
{
if (text != null)
{
throw new InvalidOperationException(Res.GetString("XmlIllegalMultipleTextMembers"));
}
text = member.Text;
}
if (member.Xmlns != null)
{
if (mapping.XmlnsMember != null)
{
throw new InvalidOperationException(Res.GetString("XmlMultipleXmlnsMembers"));
}
mapping.XmlnsMember = member;
}
}
catch (Exception exception)
{
if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException))
{
throw;
}
throw this.CreateReflectionException(xmlReflectionMembers[i].MemberName, exception);
}
}
if (isSequence)
{
throw new InvalidOperationException(Res.GetString("XmlSequenceMembers", new object[] { "Order" }));
}
mapping.Members = mappingArray;
mapping.HasWrapperElement = hasWrapperElement;
return mapping;
}
MembersMapping ImportMembersMapping(XmlReflectionMember[] xmlReflectionMembers, string ns, bool hasWrapperElement, bool rpc, bool openModel) {
MembersMapping members = new MembersMapping();
members.TypeDesc = typeScope.GetTypeDesc(typeof(object[]));
MemberMapping[] mappings = new MemberMapping[xmlReflectionMembers.Length];
NameTable elements = new NameTable();
NameTable attributes = new NameTable();
TextAccessor textAccessor = null;
bool isSequence = false;
for (int i = 0; i < mappings.Length; i++) {
try {
MemberMapping mapping = ImportMemberMapping(xmlReflectionMembers[i], ns, xmlReflectionMembers, rpc, openModel);
if (!hasWrapperElement) {
if (mapping.Attribute != null) {
if (rpc) {
throw new InvalidOperationException(Res.GetString(Res.XmlRpcLitAttributeAttributes));
}
else {
throw new InvalidOperationException(Res.GetString(Res.XmlInvalidAttributeType, "XmlAttribute"));
}
}
}
if (rpc && xmlReflectionMembers[i].IsReturnValue) {
if (i > 0) throw new InvalidOperationException(Res.GetString(Res.XmlInvalidReturnPosition));
mapping.IsReturnValue = true;
}
mappings[i] = mapping;
isSequence |= mapping.IsSequence;
if (!xmlReflectionMembers[i].XmlAttributes.XmlIgnore) {
// add All memeber accessors to the scope accessors
AddUniqueAccessor(mapping, elements, attributes, isSequence);
}
mappings[i] = mapping;
if (mapping.Text != null) {
if (textAccessor != null) {
throw new InvalidOperationException(Res.GetString(Res.XmlIllegalMultipleTextMembers));
}
textAccessor = mapping.Text;
}
if (mapping.Xmlns != null) {
if (members.XmlnsMember != null)
throw new InvalidOperationException(Res.GetString(Res.XmlMultipleXmlnsMembers));
members.XmlnsMember = mapping;
}
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
throw;
}
throw CreateReflectionException(xmlReflectionMembers[i].MemberName, e);
}
catch {
throw CreateReflectionException(xmlReflectionMembers[i].MemberName, null);
}
}
if (isSequence) {
throw new InvalidOperationException(Res.GetString(Res.XmlSequenceMembers, "Order"));
}
members.Members = mappings;
members.HasWrapperElement = hasWrapperElement;
return members;
}
MembersMapping ImportMembersMapping(XmlReflectionMember[] xmlReflectionMembers, string ns, bool hasWrapperElement) {
MembersMapping members = new MembersMapping();
members.TypeDesc = typeScope.GetTypeDesc(typeof(object[]));
MemberMapping[] mappings = new MemberMapping[xmlReflectionMembers.Length];
NameTable elements = new NameTable();
NameTable attributes = new NameTable();
TextAccessor textAccessor = null;
for (int i = 0; i < mappings.Length; i++) {
try {
MemberMapping mapping = ImportMemberMapping(xmlReflectionMembers[i], ns, xmlReflectionMembers);
if (!hasWrapperElement) {
if (mapping.Attribute != null) throw new InvalidOperationException(Res.GetString(Res.XmlInvalidAttributeType, "XmlAttribute"));
}
// add All memeber accessors to the scope accessors
AddUniqueAccessor(mapping, elements, attributes);
mappings[i] = mapping;
if (mapping.Text != null) {
if (textAccessor != null) {
throw new InvalidOperationException(Res.GetString(Res.XmlIllegalMultipleTextMembers));
}
textAccessor = mapping.Text;
}
if (mapping.Xmlns != null) {
if (members.XmlnsMember != null)
throw new InvalidOperationException(Res.GetString(Res.XmlMultipleXmlnsMembers));
members.XmlnsMember = mapping;
}
}
catch (Exception e) {
throw ReflectionException(xmlReflectionMembers[i].MemberName, e);
}
}
members.Members = mappings;
members.HasWrapperElement = hasWrapperElement;
return members;
}
public XmlMembersMapping ImportMembersMapping(string name, string ns, SoapSchemaMember[] members, bool hasWrapperElement, Type baseType, bool baseTypeCanBeIndirect)
{
XmlSchemaComplexType type = new XmlSchemaComplexType();
XmlSchemaSequence sequence = new XmlSchemaSequence();
type.Particle = sequence;
foreach (SoapSchemaMember member in members)
{
XmlSchemaElement item = new XmlSchemaElement {
Name = member.MemberName,
SchemaTypeName = member.MemberType
};
sequence.Items.Add(item);
}
CodeIdentifiers identifiers = new CodeIdentifiers {
UseCamelCasing = true
};
MembersMapping mapping = new MembersMapping {
TypeDesc = base.Scope.GetTypeDesc(typeof(object[])),
Members = this.ImportTypeMembers(type, ns, identifiers),
HasWrapperElement = hasWrapperElement
};
if (baseType != null)
{
for (int i = 0; i < mapping.Members.Length; i++)
{
MemberMapping mapping2 = mapping.Members[i];
if (mapping2.Accessor.Mapping is StructMapping)
{
base.MakeDerived((StructMapping) mapping2.Accessor.Mapping, baseType, baseTypeCanBeIndirect);
}
}
}
return new XmlMembersMapping(base.Scope, new ElementAccessor { IsSoap = true, Name = name, Namespace = ns, Mapping = mapping, IsNullable = false, Form = XmlSchemaForm.Qualified }, XmlMappingAccess.Write | XmlMappingAccess.Read);
}
/// <include file='doc\SoapSchemaImporter.uex' path='docs/doc[@for="SoapSchemaImporter.ImportMembersMapping3"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public XmlMembersMapping ImportMembersMapping(string name, string ns, SoapSchemaMember[] members, bool hasWrapperElement, Type baseType, bool baseTypeCanBeIndirect) {
XmlSchemaComplexType type = new XmlSchemaComplexType();
XmlSchemaSequence seq = new XmlSchemaSequence();
type.Particle = seq;
foreach (SoapSchemaMember member in members) {
XmlSchemaElement element = new XmlSchemaElement();
element.Name = member.MemberName;
element.SchemaTypeName = member.MemberType;
seq.Items.Add(element);
}
CodeIdentifiers identifiers = new CodeIdentifiers();
identifiers.UseCamelCasing = true;
MembersMapping mapping = new MembersMapping();
mapping.TypeDesc = Scope.GetTypeDesc(typeof(object[]));
mapping.Members = ImportTypeMembers(type, ns, identifiers);
mapping.HasWrapperElement = hasWrapperElement;
if (baseType != null) {
for (int i = 0; i < mapping.Members.Length; i++) {
MemberMapping member = mapping.Members[i];
if (member.Accessor.Mapping is StructMapping)
MakeDerived((StructMapping)member.Accessor.Mapping, baseType, baseTypeCanBeIndirect);
}
}
ElementAccessor accessor = new ElementAccessor();
accessor.IsSoap = true;
accessor.Name = name;
accessor.Namespace = ns;
accessor.Mapping = mapping;
accessor.IsNullable = false;
accessor.Form = XmlSchemaForm.Qualified;
return new XmlMembersMapping(Scope, accessor, XmlMappingAccess.Read | XmlMappingAccess.Write);
}
XmlQualifiedName ExportMembersMapping(MembersMapping mapping, string ns) {
XmlSchemaComplexType type = (XmlSchemaComplexType)types[mapping];
if(type == null) {
CheckForDuplicateType(mapping.TypeName, mapping.Namespace);
type = new XmlSchemaComplexType();
type.Name = mapping.TypeName;
types.Add(mapping, type);
AddSchemaItem(type, mapping.Namespace, ns);
ExportTypeMembers(type, mapping.Members, mapping.Namespace);
}
else {
AddSchemaImport(mapping.Namespace, ns);
}
return new XmlQualifiedName(type.Name, mapping.Namespace);
}
private MembersMapping ImportMembersType(XmlSchemaType type, string typeNs, string identifier)
{
if (!type.DerivedFrom.IsEmpty) throw new InvalidOperationException(SR.XmlMembersDeriveError);
CodeIdentifiers memberScope = new CodeIdentifiers();
memberScope.UseCamelCasing = true;
bool needExplicitOrder = false;
MemberMapping[] members = ImportTypeMembers(type, typeNs, identifier, memberScope, new CodeIdentifiers(), new NameTable(), ref needExplicitOrder, false, false);
MembersMapping mappings = new MembersMapping();
mappings.HasWrapperElement = true;
mappings.TypeDesc = Scope.GetTypeDesc(typeof(object[]));
mappings.Members = members;
return mappings;
}
/// <include file='doc\SoapSchemaImporter.uex' path='docs/doc[@for="SoapSchemaImporter.ImportMembersMapping"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public XmlMembersMapping ImportMembersMapping(string name, string ns, SoapSchemaMember member) {
TypeMapping typeMapping = ImportType(member.MemberType, true);
if (!(typeMapping is StructMapping)) return ImportMembersMapping(name, ns, new SoapSchemaMember[] { member });
MembersMapping mapping = new MembersMapping();
mapping.TypeDesc = Scope.GetTypeDesc(typeof(object[]));
mapping.Members = ((StructMapping)typeMapping).Members;
mapping.HasWrapperElement = true;
ElementAccessor accessor = new ElementAccessor();
accessor.IsSoap = true;
accessor.Name = name;
accessor.Namespace = typeMapping.Namespace != null ? typeMapping.Namespace : ns;
accessor.Mapping = mapping;
accessor.IsNullable = false;
accessor.Form = XmlSchemaForm.Qualified;
return new XmlMembersMapping(Scope, accessor, XmlMappingAccess.Read | XmlMappingAccess.Write);
}
MembersMapping ImportMembersType(XmlSchemaType type, string typeNs, string identifier) {
if (!type.DerivedFrom.IsEmpty) throw new InvalidOperationException(Res.GetString(Res.XmlMembersDeriveError));
CodeIdentifiers memberScope = new CodeIdentifiers();
memberScope.UseCamelCasing = true;
MemberMapping[] members = ImportTypeMembers(type, typeNs, identifier, memberScope);
MembersMapping mappings = new MembersMapping();
mappings.HasWrapperElement = true;
mappings.TypeDesc = scope.GetTypeDesc(typeof(object[]));
mappings.Members = members;
return mappings;
}
MembersMapping ImportMembersMapping(XmlReflectionMember[] xmlReflectionMembers, string ns, bool hasWrapperElement, bool writeAccessors, bool validateWrapperElement) {
MembersMapping members = new MembersMapping();
members.TypeDesc = typeScope.GetTypeDesc(typeof(object[]));
MemberMapping[] mappings = new MemberMapping[xmlReflectionMembers.Length];
for (int i = 0; i < mappings.Length; i++) {
try {
XmlReflectionMember member = xmlReflectionMembers[i];
MemberMapping mapping = ImportMemberMapping(member, ns, xmlReflectionMembers, hasWrapperElement ? XmlSchemaForm.Unqualified : XmlSchemaForm.Qualified);
if (member.IsReturnValue && writeAccessors) { // no special treatment for return values with doc/enc
if (i > 0) throw new InvalidOperationException(Res.GetString(Res.XmlInvalidReturnPosition));
mapping.IsReturnValue = true;
}
mappings[i] = mapping;
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
throw;
}
throw ReflectionException(xmlReflectionMembers[i].MemberName, e);
}
catch {
throw ReflectionException(xmlReflectionMembers[i].MemberName, null);
}
}
members.Members = mappings;
members.HasWrapperElement = hasWrapperElement;
if (hasWrapperElement) {
members.ValidateRpcWrapperElement = validateWrapperElement;
}
members.WriteAccessors = writeAccessors;
members.IsSoap = true;
if (hasWrapperElement && !writeAccessors)
members.Namespace = ns;
return members;
}
public XmlMembersMapping ImportMembersMapping(string name, string ns, SoapSchemaMember member)
{
TypeMapping mapping = this.ImportType(member.MemberType, true);
if (!(mapping is StructMapping))
{
return this.ImportMembersMapping(name, ns, new SoapSchemaMember[] { member });
}
MembersMapping mapping2 = new MembersMapping {
TypeDesc = base.Scope.GetTypeDesc(typeof(object[])),
Members = ((StructMapping) mapping).Members,
HasWrapperElement = true
};
return new XmlMembersMapping(base.Scope, new ElementAccessor { IsSoap = true, Name = name, Namespace = (mapping.Namespace != null) ? mapping.Namespace : ns, Mapping = mapping2, IsNullable = false, Form = XmlSchemaForm.Qualified }, XmlMappingAccess.Write | XmlMappingAccess.Read);
}