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]);
}
internal void Add(MessagePartDescription part, XmlMemberMapping memberMapping, XmlMembersMapping membersMapping, bool isEncoded)
{
PartInfo partInfo = new PartInfo();
partInfo.MemberMapping = memberMapping;
partInfo.MembersMapping = membersMapping;
partInfo.IsEncoded = isEncoded;
partInfoTable[part] = partInfo;
}
internal SoapParameters(XmlMembersMapping request, XmlMembersMapping response, string[] parameterOrder, CodeIdentifiers identifiers) {
ArrayList requestList = new ArrayList();
ArrayList responseList = new ArrayList();
AddMappings(requestList, request);
if (response != null) AddMappings(responseList, response);
if (parameterOrder != null) {
for (int i = 0; i < parameterOrder.Length; i++) {
string elementName = parameterOrder[i];
XmlMemberMapping requestMapping = FindMapping(requestList, elementName);
SoapParameter parameter = new SoapParameter();
if (requestMapping != null) {
if (RemoveByRefMapping(responseList, requestMapping))
parameter.codeFlags = CodeFlags.IsByRef;
parameter.mapping = requestMapping;
requestList.Remove(requestMapping);
AddParameter(parameter);
}
else {
XmlMemberMapping responseMapping = FindMapping(responseList, elementName);
if (responseMapping != null) {
parameter.codeFlags = CodeFlags.IsOut;
parameter.mapping = responseMapping;
responseList.Remove(responseMapping);
AddParameter(parameter);
}
}
}
}
foreach (XmlMemberMapping requestMapping in requestList) {
SoapParameter parameter = new SoapParameter();
if (RemoveByRefMapping(responseList, requestMapping))
parameter.codeFlags = CodeFlags.IsByRef;
parameter.mapping = requestMapping;
AddParameter(parameter);
}
if (responseList.Count > 0) {
if (!((XmlMemberMapping) responseList[0]).CheckSpecified) {
ret = (XmlMemberMapping)responseList[0];
responseList.RemoveAt(0);
}
foreach (XmlMemberMapping responseMapping in responseList) {
SoapParameter parameter = new SoapParameter();
parameter.mapping = responseMapping;
parameter.codeFlags = CodeFlags.IsOut;
AddParameter(parameter);
}
}
foreach (SoapParameter parameter in parameters) {
parameter.name = identifiers.MakeUnique(CodeIdentifier.MakeValid(parameter.mapping.MemberName));
}
}
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]);
}
}
public static void Print(XmlMemberMapping mm)
{
Console.WriteLine("/XmlMemberMapping:");
Console.WriteLine("Any: {0} ", mm.Any);
Console.WriteLine("ElementName: {0} ", mm.ElementName);
Console.WriteLine("MemberName: {0} ", mm.MemberName);
Console.WriteLine("Namespace: {0} ", mm.Namespace);
Console.WriteLine("TypeFullName: {0} ", mm.TypeFullName);
Console.WriteLine("TypeName: {0} ", mm.TypeName);
Console.WriteLine("TypeNamespace: {0} ", mm.TypeNamespace);
}
internal XmlMembersMapping (string elementName, string ns, bool hasWrapperElement, bool writeAccessors, XmlMemberMapping[] mapping)
: base (elementName, ns)
{
_hasWrapperElement = hasWrapperElement;
_mapping = mapping;
ClassMap map = new ClassMap ();
map.IgnoreMemberNamespace = writeAccessors;
foreach (XmlMemberMapping mm in mapping)
map.AddMember (mm.TypeMapMember);
ObjectMap = map;
}
public void AddMappingMetadata (CodeAttributeDeclarationCollection metadata, XmlMemberMapping member, bool forceUseMemberName)
{
TypeData memType = member.TypeMapMember.TypeData;
CodeAttributeDeclaration att = new CodeAttributeDeclaration ("System.Xml.Serialization.SoapElement");
if (forceUseMemberName || (member.ElementName != member.MemberName))
att.Arguments.Add (new CodeAttributeArgument (new CodePrimitiveExpression(member.ElementName)));
if (!TypeTranslator.IsDefaultPrimitiveTpeData (memType))
att.Arguments.Add (new CodeAttributeArgument ("DataType", new CodePrimitiveExpression(member.TypeName)));
if (att.Arguments.Count > 0)
metadata.Add (att);
}
public void AddMappingMetadata(CodeAttributeDeclarationCollection metadata, XmlMemberMapping member, string ns, bool forceUseMemberName)
{
CodeAttributeDeclaration att;
TypeData memType = member.TypeMapMember.TypeData;
if (member.Any)
{
XmlTypeMapElementInfoList list = (XmlTypeMapElementInfoList)((XmlTypeMapMemberElement)member.TypeMapMember).ElementInfo;
foreach (XmlTypeMapElementInfo info in list)
{
if (info.IsTextElement)
{
metadata.Add(new CodeAttributeDeclaration("System.Xml.Serialization.XmlText"));
}
else
{
att = new CodeAttributeDeclaration("System.Xml.Serialization.XmlAnyElement");
if (!info.IsUnnamedAnyElement)
{
att.Arguments.Add(MapCodeGenerator.GetArg("Name", info.ElementName));
if (info.Namespace != ns)
{
att.Arguments.Add(MapCodeGenerator.GetArg("Namespace", member.Namespace));
}
}
metadata.Add(att);
}
}
}
else if (member.TypeMapMember is XmlTypeMapMemberList)
{
// Array parameter
XmlTypeMapMemberList list = member.TypeMapMember as XmlTypeMapMemberList;
ListMap listMap = (ListMap)list.ListTypeMapping.ObjectMap;
codeGenerator.AddArrayAttributes(metadata, list, ns, forceUseMemberName);
codeGenerator.AddArrayItemAttributes(metadata, listMap, memType.ListItemTypeData, list.Namespace, 0);
}
else if (member.TypeMapMember is XmlTypeMapMemberElement)
{
codeGenerator.AddElementMemberAttributes((XmlTypeMapMemberElement)member.TypeMapMember, ns, metadata, forceUseMemberName);
}
else if (member.TypeMapMember is XmlTypeMapMemberAttribute)
{
codeGenerator.AddAttributeMemberAttributes((XmlTypeMapMemberAttribute)member.TypeMapMember, ns, metadata, forceUseMemberName);
}
else
{
throw new NotSupportedException("Schema type not supported");
}
}
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());
}
public XmlMembersMapping ImportMembersMapping (string elementName, string ns, XmlReflectionMember[] members, bool hasWrapperElement, bool writeAccessors, bool validate)
{
XmlMemberMapping[] mapping = new XmlMemberMapping[members.Length];
for (int n=0; n<members.Length; n++)
{
XmlTypeMapMember mapMem = CreateMapMember (members[n], ns);
mapping[n] = new XmlMemberMapping (members[n].MemberName, ns, mapMem, true);
}
XmlMembersMapping mps = new XmlMembersMapping (elementName, ns, hasWrapperElement, writeAccessors, mapping);
mps.RelatedMaps = relatedMaps;
mps.Format = SerializationFormat.Encoded;
mps.Source = new MembersSerializationSource (elementName, hasWrapperElement, members, writeAccessors, false, null, includedTypes);
return mps;
}
public XmlMembersMapping ImportMembersMapping(string elementName, string ns, XmlReflectionMember[] members, bool hasWrapperElement, bool writeAccessors, bool validate)
{
XmlMemberMapping[] mapping = new XmlMemberMapping[members.Length];
for (int n = 0; n < members.Length; n++)
{
XmlTypeMapMember mapMem = CreateMapMember(members[n], ns);
mapping[n] = new XmlMemberMapping(members[n].MemberName, ns, mapMem, true);
}
XmlMembersMapping mps = new XmlMembersMapping(elementName, ns, hasWrapperElement, writeAccessors, mapping);
mps.RelatedMaps = relatedMaps;
mps.Format = SerializationFormat.Encoded;
mps.Source = new MembersSerializationSource(elementName, hasWrapperElement, members, writeAccessors, false, null, includedTypes);
return(mps);
}
XmlMembersMapping ImportMembersMapping(string elementName, string ns, XmlReflectionMember[] members, bool hasWrapperElement, bool writeAccessors, bool validate, XmlMappingAccess access)
{
elementName = XmlConvert.EncodeLocalName(elementName);
XmlMemberMapping[] mapping = new XmlMemberMapping[members.Length];
for (int n = 0; n < members.Length; n++)
{
XmlTypeMapMember mapMem = CreateMapMember(members[n], ns);
mapping[n] = new XmlMemberMapping(XmlConvert.EncodeLocalName(members[n].MemberName), ns, mapMem, true);
}
XmlMembersMapping mps = new XmlMembersMapping(elementName, ns, hasWrapperElement, writeAccessors, mapping);
mps.RelatedMaps = relatedMaps;
mps.Format = SerializationFormat.Encoded;
Type[] extraTypes = includedTypes != null ? (Type[])includedTypes.ToArray(typeof(Type)) : null;
mps.Source = new MembersSerializationSource(elementName, hasWrapperElement, members, writeAccessors, false, null, extraTypes);
return(mps);
}
public XmlMembersMapping ImportMembersMapping(string elementName, string ns, XmlReflectionMember[] members, bool hasWrapperElement, bool writeAccessors, bool validate, XmlMappingAccess access)
{
elementName = XmlConvert.EncodeLocalName(elementName);
XmlMemberMapping[] array = new XmlMemberMapping[members.Length];
for (int i = 0; i < members.Length; i++)
{
XmlTypeMapMember mapMem = this.CreateMapMember(members[i], ns);
array[i] = new XmlMemberMapping(XmlConvert.EncodeLocalName(members[i].MemberName), ns, mapMem, true);
}
XmlMembersMapping xmlMembersMapping = new XmlMembersMapping(elementName, ns, hasWrapperElement, writeAccessors, array);
xmlMembersMapping.RelatedMaps = this.relatedMaps;
xmlMembersMapping.Format = SerializationFormat.Encoded;
Type[] array2 = (this.includedTypes == null) ? null : ((Type[])this.includedTypes.ToArray(typeof(Type)));
xmlMembersMapping.Source = new MembersSerializationSource(elementName, hasWrapperElement, members, writeAccessors, false, null, array2);
return(xmlMembersMapping);
}
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());
}
public void AddMappingMetadata(CodeAttributeDeclarationCollection metadata, XmlMemberMapping member, bool forceUseMemberName)
{
TypeData memType = member.TypeMapMember.TypeData;
CodeAttributeDeclaration att = new CodeAttributeDeclaration("System.Xml.Serialization.SoapElement");
if (forceUseMemberName || (member.ElementName != member.MemberName))
{
att.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(member.ElementName)));
}
if (!TypeTranslator.IsDefaultPrimitiveTpeData(memType))
{
att.Arguments.Add(new CodeAttributeArgument("DataType", new CodePrimitiveExpression(member.TypeName)));
}
if (att.Arguments.Count > 0)
{
metadata.Add(att);
}
}
public XmlMembersMapping ImportMembersMapping(string elementName,
string ns,
XmlReflectionMember [] members,
bool hasWrapperElement)
{
// Reset (); Disabled. See ChangeLog
XmlMemberMapping[] mapping = new XmlMemberMapping[members.Length];
for (int n = 0; n < members.Length; n++)
{
XmlTypeMapMember mapMem = CreateMapMember(members[n], ns);
mapping[n] = new XmlMemberMapping(members[n].MemberName, ns, mapMem, false);
}
XmlMembersMapping mps = new XmlMembersMapping(elementName, ns, hasWrapperElement, false, mapping);
mps.RelatedMaps = relatedMaps;
mps.Format = SerializationFormat.Literal;
mps.Source = new MembersSerializationSource(elementName, hasWrapperElement, members, false, true, ns, includedTypes);
if (allowPrivateTypes)
{
mps.Source.CanBeGenerated = false;
}
return(mps);
}
/// <include file='doc\SoapCodeExporter.uex' path='docs/doc[@for="SoapCodeExporter.AddMappingMetadata1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
internal void AddMappingMetadata(CodeAttributeDeclarationCollection metadata, XmlMemberMapping member)
{
AddMemberMetadata(metadata, member.Mapping, false);
}
public void AddMappingMetadata (CodeAttributeDeclarationCollection metadata, XmlMemberMapping member)
{
AddMappingMetadata (metadata, member, false);
}
/// <include file='doc\XmlCodeExporter.uex' path='docs/doc[@for="XmlCodeExporter.AddMappingMetadata2"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public void AddMappingMetadata(CodeAttributeDeclarationCollection metadata, XmlMemberMapping member, string ns)
{
AddMemberMetadata(null, metadata, member.Mapping, ns, false);
}
/// <include file='doc\SoapCodeExporter.uex' path='docs/doc[@for="SoapCodeExporter.AddMappingMetadata"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
internal void AddMappingMetadata(CodeAttributeDeclarationCollection metadata, XmlMemberMapping member, bool forceUseMemberName)
{
AddMemberMetadata(metadata, member.Mapping, forceUseMemberName);
}
XmlMemberMapping[] ImportMembersMappingComposite (XmlSchemaComplexType stype, XmlQualifiedName refer)
{
if (stype.Particle == null)
return new XmlMemberMapping [0];
ClassMap cmap = new ClassMap ();
XmlSchemaSequence seq = stype.Particle as XmlSchemaSequence;
if (seq == null) throw new InvalidOperationException ("Schema element '" + refer + "' cannot be imported as XmlMembersMapping");
CodeIdentifiers classIds = new CodeIdentifiers ();
ImportParticleComplexContent (refer, cmap, seq, classIds, false);
ImportAttributes (refer, cmap, stype.Attributes, stype.AnyAttribute, classIds);
BuildPendingMaps ();
int n = 0;
XmlMemberMapping[] mapping = new XmlMemberMapping [cmap.AllMembers.Count];
foreach (XmlTypeMapMember mapMem in cmap.AllMembers)
mapping[n++] = new XmlMemberMapping (mapMem.Name, refer.Namespace, mapMem, encodedFormat);
return mapping;
}
private static bool RemoveByRefMapping(ArrayList responseList, XmlMemberMapping requestMapping)
{
XmlMemberMapping mapping = FindMapping(responseList, requestMapping.ElementName);
if (mapping == null)
{
return false;
}
if (requestMapping.TypeFullName != mapping.TypeFullName)
{
return false;
}
if (requestMapping.Namespace != mapping.Namespace)
{
return false;
}
if (requestMapping.MemberName != mapping.MemberName)
{
return false;
}
responseList.Remove(mapping);
return true;
}
void GenerateReturnAttributes (XmlMembersMapping members, XmlMemberMapping member, SoapBindingUse use, CodeMemberMethod method)
{
if (use == SoapBindingUse.Literal)
xmlExporter.AddMappingMetadata (method.ReturnTypeCustomAttributes, member, members.Namespace, (member.ElementName != method.Name + "Result"));
else
soapExporter.AddMappingMetadata (method.ReturnTypeCustomAttributes, member, (member.ElementName != method.Name + "Result"));
}
/// <include file='doc\XmlCodeExporter.uex' path='docs/doc[@for="XmlCodeExporter.AddMappingMetadata1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public void AddMappingMetadata(CodeAttributeDeclarationCollection metadata, XmlMemberMapping member, string ns, bool forceUseMemberName) {
AddMemberMetadata(null, metadata, member.Mapping, ns, forceUseMemberName, null, null);
}
internal static string FullTypeName(XmlMemberMapping mapping, CodeDomProvider codeProvider)
{
return mapping.GenerateTypeName(codeProvider);
}
internal string GetTypeName(XmlMemberMapping member)
{
string typeName = member.GenerateTypeName(options.CodeProvider);
// If it is an array type, get the array element type name instead
string comparableTypeName = typeName.Replace("[]", null);
if (codeNamespace != null && !string.IsNullOrEmpty(codeNamespace.Name))
{
foreach (CodeTypeDeclaration typeDecl in codeNamespace.Types)
{
if (typeDecl.Name == comparableTypeName)
{
typeName = codeNamespace.Name + "." + typeName;
}
}
}
return typeName;
}
public void AddMappingMetadata (CodeAttributeDeclarationCollection metadata, XmlMemberMapping member, string ns, bool forceUseMemberName)
{
CodeAttributeDeclaration att;
TypeData memType = member.TypeMapMember.TypeData;
if (member.Any)
{
XmlTypeMapElementInfoList list = (XmlTypeMapElementInfoList)((XmlTypeMapMemberElement)member.TypeMapMember).ElementInfo;
foreach (XmlTypeMapElementInfo info in list)
{
if (info.IsTextElement)
metadata.Add (new CodeAttributeDeclaration ("System.Xml.Serialization.XmlText"));
else {
att = new CodeAttributeDeclaration ("System.Xml.Serialization.XmlAnyElement");
if (!info.IsUnnamedAnyElement) {
att.Arguments.Add (MapCodeGenerator.GetArg ("Name", info.ElementName));
if (info.Namespace != ns) att.Arguments.Add (MapCodeGenerator.GetArg ("Namespace", member.Namespace));
}
metadata.Add (att);
}
}
}
else if (member.TypeMapMember is XmlTypeMapMemberList)
{
// Array parameter
XmlTypeMapMemberList list = member.TypeMapMember as XmlTypeMapMemberList;
ListMap listMap = (ListMap) list.ListTypeMapping.ObjectMap;
codeGenerator.AddArrayAttributes (metadata, list, ns, forceUseMemberName);
codeGenerator.AddArrayItemAttributes (metadata, listMap, memType.ListItemTypeData, list.Namespace, 0);
}
else if (member.TypeMapMember is XmlTypeMapMemberElement) {
codeGenerator.AddElementMemberAttributes ((XmlTypeMapMemberElement) member.TypeMapMember, ns, metadata, forceUseMemberName);
}
else if (member.TypeMapMember is XmlTypeMapMemberAttribute) {
codeGenerator.AddAttributeMemberAttributes ((XmlTypeMapMemberAttribute) member.TypeMapMember, ns, metadata, forceUseMemberName);
}
else
throw new NotSupportedException ("Schema type not supported");
}
CodeParameterDeclarationExpression GenerateParameter (XmlMemberMapping member, FieldDirection dir)
{
CodeParameterDeclarationExpression par = new CodeParameterDeclarationExpression (member.TypeFullName, member.MemberName);
par.Direction = dir;
return par;
}
public XmlMembersMapping ImportMembersMapping (XmlQualifiedName[] names)
{
XmlMemberMapping[] mapping = new XmlMemberMapping [names.Length];
for (int n=0; n<names.Length; n++)
{
XmlSchemaElement elem = (XmlSchemaElement) schemas.Find (names[n], typeof (XmlSchemaElement));
if (elem == null) throw new InvalidOperationException ("Schema element '" + names[n] + "' not found");
XmlQualifiedName typeQName = new XmlQualifiedName ("Message", names[n].Namespace);
XmlTypeMapping tmap;
TypeData td = GetElementTypeData (typeQName, elem, names[n], out tmap);
mapping[n] = ImportMemberMapping (elem.Name, typeQName.Namespace, elem.IsNillable, td, tmap, n);
}
BuildPendingMaps ();
return new XmlMembersMapping (mapping);
}
void GenerateMemberAttributes (XmlMembersMapping members, XmlMemberMapping member, SoapBindingUse use, CodeParameterDeclarationExpression param)
{
if (use == SoapBindingUse.Literal)
xmlExporter.AddMappingMetadata (param.CustomAttributes, member, members.Namespace);
else
soapExporter.AddMappingMetadata (param.CustomAttributes, member);
}
internal SoapParameters(XmlMembersMapping request, XmlMembersMapping response, string[] parameterOrder, CodeIdentifiers identifiers)
{
ArrayList mappingsList = new ArrayList();
ArrayList list2 = new ArrayList();
AddMappings(mappingsList, request);
if (response != null)
{
AddMappings(list2, response);
}
if (parameterOrder != null)
{
for (int i = 0; i < parameterOrder.Length; i++)
{
string elementName = parameterOrder[i];
XmlMemberMapping requestMapping = FindMapping(mappingsList, elementName);
SoapParameter parameter = new SoapParameter();
if (requestMapping != null)
{
if (RemoveByRefMapping(list2, requestMapping))
{
parameter.codeFlags = CodeFlags.IsByRef;
}
parameter.mapping = requestMapping;
mappingsList.Remove(requestMapping);
this.AddParameter(parameter);
}
else
{
XmlMemberMapping mapping2 = FindMapping(list2, elementName);
if (mapping2 != null)
{
parameter.codeFlags = CodeFlags.IsOut;
parameter.mapping = mapping2;
list2.Remove(mapping2);
this.AddParameter(parameter);
}
}
}
}
foreach (XmlMemberMapping mapping3 in mappingsList)
{
SoapParameter parameter2 = new SoapParameter();
if (RemoveByRefMapping(list2, mapping3))
{
parameter2.codeFlags = CodeFlags.IsByRef;
}
parameter2.mapping = mapping3;
this.AddParameter(parameter2);
}
if (list2.Count > 0)
{
if (!((XmlMemberMapping) list2[0]).CheckSpecified)
{
this.ret = (XmlMemberMapping) list2[0];
list2.RemoveAt(0);
}
foreach (XmlMemberMapping mapping4 in list2)
{
SoapParameter parameter3 = new SoapParameter {
mapping = mapping4,
codeFlags = CodeFlags.IsOut
};
this.AddParameter(parameter3);
}
}
foreach (SoapParameter parameter4 in this.parameters)
{
parameter4.name = identifiers.MakeUnique(CodeIdentifier.MakeValid(parameter4.mapping.MemberName));
}
}
public XmlMembersMapping ImportAnyType (XmlQualifiedName typeName, string elementName)
{
if (typeName == XmlQualifiedName.Empty)
{
XmlTypeMapMemberAnyElement mapMem = new XmlTypeMapMemberAnyElement ();
mapMem.Name = typeName.Name;
mapMem.TypeData = TypeTranslator.GetTypeData(typeof(XmlNode));
mapMem.ElementInfo.Add (CreateElementInfo (typeName.Namespace, mapMem, typeName.Name, mapMem.TypeData, true, XmlSchemaForm.None, -1));
XmlMemberMapping[] mm = new XmlMemberMapping [1];
mm[0] = new XmlMemberMapping (typeName.Name, typeName.Namespace, mapMem, encodedFormat);
return new XmlMembersMapping (mm);
}
else
{
XmlSchemaComplexType stype = (XmlSchemaComplexType) schemas.Find (typeName, typeof (XmlSchemaComplexType));
if (stype == null)
throw new InvalidOperationException ("Referenced type '" + typeName + "' not found");
if (!CanBeAnyElement (stype))
throw new InvalidOperationException ("The type '" + typeName + "' is not valid for a collection of any elements");
ClassMap cmap = new ClassMap ();
CodeIdentifiers classIds = new CodeIdentifiers ();
bool isMixed = stype.IsMixed;
ImportSequenceContent (typeName, cmap, ((XmlSchemaSequence) stype.Particle).Items, classIds, false, ref isMixed);
XmlTypeMapMemberAnyElement mapMem = (XmlTypeMapMemberAnyElement) cmap.AllMembers[0];
mapMem.Name = typeName.Name;
XmlMemberMapping[] mm = new XmlMemberMapping [1];
mm[0] = new XmlMemberMapping (typeName.Name, typeName.Namespace, mapMem, encodedFormat);
return new XmlMembersMapping (mm);
}
}
XmlMembersMapping ImportMembersMapping (string elementName, string ns, XmlReflectionMember[] members, bool hasWrapperElement, bool writeAccessors, bool validate, XmlMappingAccess access)
{
elementName = XmlConvert.EncodeLocalName (elementName);
XmlMemberMapping[] mapping = new XmlMemberMapping[members.Length];
for (int n=0; n<members.Length; n++)
{
XmlTypeMapMember mapMem = CreateMapMember (members[n], ns);
mapping[n] = new XmlMemberMapping (XmlConvert.EncodeLocalName (members[n].MemberName), ns, mapMem, true);
}
XmlMembersMapping mps = new XmlMembersMapping (elementName, ns, hasWrapperElement, writeAccessors, mapping);
mps.RelatedMaps = relatedMaps;
mps.Format = SerializationFormat.Encoded;
Type[] extraTypes = includedTypes != null ? (Type[])includedTypes.ToArray(typeof(Type)) : null;
mps.Source = new MembersSerializationSource (elementName, hasWrapperElement, members, writeAccessors, false, null, extraTypes);
return mps;
}
internal XmlMembersMapping ImportEncodedMembersMapping (string name, string ns, SoapSchemaMember[] members, bool hasWrapperElement)
{
XmlMemberMapping[] mapping = new XmlMemberMapping [members.Length];
for (int n=0; n<members.Length; n++)
{
TypeData td = GetTypeData (members[n].MemberType, null, false); // FIXME: isNullable could be true?
XmlTypeMapping tmap = GetTypeMapping (td);
mapping[n] = ImportMemberMapping (members[n].MemberName, members[n].MemberType.Namespace, true, td, tmap, n);
}
BuildPendingMaps ();
return new XmlMembersMapping (name, ns, hasWrapperElement, false, mapping);
}
/// <include file='doc\SoapCodeExporter.uex' path='docs/doc[@for="SoapCodeExporter.AddMappingMetadata"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public void AddMappingMetadata(CodeAttributeDeclarationCollection metadata, XmlMemberMapping member, bool forceUseMemberName) {
AddMemberMetadata(metadata, member.Mapping, forceUseMemberName);
}
string GetSimpleType (XmlMemberMapping member)
{
// MS seems to always use System.String for input parameters, except for byte[]
switch (member.TypeName)
{
case "hexBinary":
case "base64Binary":
return "System.String";
default:
string ptype = member.TypeFullName;
int i = ptype.IndexOf ('[');
if (i == -1)
return "System.String";
else
return "System.String" + ptype.Substring (i);
}
}
internal XmlMembersMapping (XmlMemberMapping[] mapping): this ("", null, false, false, mapping)
{
}
/// <include file='doc\XmlCodeExporter.uex' path='docs/doc[@for="XmlCodeExporter.AddMappingMetadata1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public void AddMappingMetadata(CodeAttributeDeclarationCollection metadata, XmlMemberMapping member, string ns, bool forceUseMemberName)
{
AddMemberMetadata(null, metadata, member.Mapping, ns, forceUseMemberName);
}
internal XmlMembersMapping (string elementName, string ns, XmlMemberMapping[] mapping): this (elementName, ns, true, false, mapping)
{
}
/// <include file='doc\SoapCodeExporter.uex' path='docs/doc[@for="SoapCodeExporter.AddMappingMetadata1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
internal void AddMappingMetadata(CodeAttributeDeclarationCollection metadata, XmlMemberMapping member)
{
AddMemberMetadata(metadata, member.Mapping, false);
}
public void AddMappingMetadata(CodeAttributeDeclarationCollection metadata, XmlMemberMapping member)
{
AddMappingMetadata(metadata, member, false);
}
/// <include file='doc\XmlCodeExporter.uex' path='docs/doc[@for="XmlCodeExporter.AddMappingMetadata2"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public void AddMappingMetadata(CodeAttributeDeclarationCollection metadata, XmlMemberMapping member, string ns) {
AddMemberMetadata(null, metadata, member.Mapping, ns, false, null, null);
}
XmlMembersMapping ImportMembersMapping (string elementName,
string ns,
XmlReflectionMember[] members,
bool hasWrapperElement,
bool writeAccessors,
bool validate,
XmlMappingAccess access)
{
// Reset (); Disabled. See ChangeLog
XmlMemberMapping[] mapping = new XmlMemberMapping[members.Length];
for (int n=0; n<members.Length; n++)
{
XmlTypeMapMember mapMem = CreateMapMember (null, members[n], ns);
mapping[n] = new XmlMemberMapping (members[n].MemberName, ns, mapMem, false);
}
elementName = XmlConvert.EncodeLocalName (elementName);
XmlMembersMapping mps = new XmlMembersMapping (elementName, ns, hasWrapperElement, false, mapping);
mps.RelatedMaps = relatedMaps;
mps.Format = SerializationFormat.Literal;
Type[] extraTypes = includedTypes != null ? (Type[])includedTypes.ToArray(typeof(Type)) : null;
mps.Source = new MembersSerializationSource (elementName, hasWrapperElement, members, false, true, ns, extraTypes);
if (allowPrivateTypes) mps.Source.CanBeGenerated = false;
return mps;
}
