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 void ExportMembersMapping(XmlMembersMapping xmlMembersMapping)
{
CodeTypeDeclaration dummyClass = new CodeTypeDeclaration();
ExportMembersMapCode(dummyClass, (ClassMap)xmlMembersMapping.ObjectMap, xmlMembersMapping.Namespace, null);
}
void ExportMembersMapping(XmlMembersMapping xmlMembersMapping, bool exportEnclosingType)
{
ClassMap cmap = (ClassMap)xmlMembersMapping.ObjectMap;
if (xmlMembersMapping.HasWrapperElement && exportEnclosingType)
{
XmlSchema schema = GetSchema(xmlMembersMapping.Namespace);
XmlSchemaComplexType stype = new XmlSchemaComplexType();
XmlSchemaSequence particle;
XmlSchemaAnyAttribute anyAttribute;
ExportMembersMapSchema(schema, cmap, null, stype.Attributes, out particle, out anyAttribute);
stype.Particle = particle;
stype.AnyAttribute = anyAttribute;
if (encodedFormat)
{
stype.Name = xmlMembersMapping.ElementName;
schema.Items.Add(stype);
}
else
{
XmlSchemaElement selem = new XmlSchemaElement();
selem.Name = xmlMembersMapping.ElementName;
selem.SchemaType = stype;
schema.Items.Add(selem);
}
}
else
{
ICollection members = cmap.ElementMembers;
if (members != null)
{
foreach (XmlTypeMapMemberElement member in members)
{
if (member is XmlTypeMapMemberAnyElement && member.TypeData.IsListType)
{
XmlSchema mschema = GetSchema(xmlMembersMapping.Namespace);
XmlSchemaParticle par = GetSchemaArrayElement(mschema, member.ElementInfo);
if (par is XmlSchemaAny)
{
XmlSchemaComplexType ct = FindComplexType(mschema.Items, "any");
if (ct != null)
{
continue;
}
ct = new XmlSchemaComplexType();
ct.Name = "any";
ct.IsMixed = true;
XmlSchemaSequence seq = new XmlSchemaSequence();
ct.Particle = seq;
seq.Items.Add(par);
mschema.Items.Add(ct);
continue;
}
}
XmlTypeMapElementInfo einfo = (XmlTypeMapElementInfo)member.ElementInfo [0];
XmlSchema schema;
if (encodedFormat)
{
schema = GetSchema(xmlMembersMapping.Namespace);
ImportNamespace(schema, XmlSerializer.EncodingNamespace);
}
else
{
schema = GetSchema(einfo.Namespace);
}
XmlSchemaElement exe = FindElement(schema.Items, einfo.ElementName);
XmlSchemaElement elem;
XmlSchemaObjectContainer container = null;
// In encoded format, the schema elements are not needed
if (!encodedFormat)
{
container = new XmlSchemaObjectContainer(schema);
}
Type memType = member.GetType();
if (member is XmlTypeMapMemberFlatList)
{
throw new InvalidOperationException("Unwrapped arrays not supported as parameters");
}
else if (memType == typeof(XmlTypeMapMemberElement))
{
elem = (XmlSchemaElement)GetSchemaElement(schema,
einfo, member.DefaultValue, false, container);
}
else
{
elem = (XmlSchemaElement)GetSchemaElement(schema,
einfo, false, container);
}
if (exe != null)
{
if (exe.SchemaTypeName.Equals(elem.SchemaTypeName))
{
schema.Items.Remove(elem);
}
else
{
string s = "The XML element named '" + einfo.ElementName + "' ";
s += "from namespace '" + schema.TargetNamespace + "' references distinct types " + elem.SchemaTypeName.Name + " and " + exe.SchemaTypeName.Name + ". ";
s += "Use XML attributes to specify another XML name or namespace for the element or types.";
throw new InvalidOperationException(s);
}
}
}
}
}
CompileSchemas();
}
public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping)
{
ExportMembersMapping(xmlMembersMapping, true);
}
public string ExportAnyType(XmlMembersMapping members)
{
throw new NotImplementedException();
}
public XmlQualifiedName ExportTypeMapping(XmlMembersMapping xmlMembersMapping)
{
throw new NotImplementedException();
}
public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping)
{
codeGenerator.ExportMembersMapping(xmlMembersMapping);
}
protected virtual object ReadMessage(XmlMembersMapping typeMap)
{
object[] parameters = new object[typeMap.Count];
if (typeMap.HasWrapperElement)
{
// bug #79988: out parameters need to be initialized if they
// are value types
ArrayList members = ((ClassMap)typeMap.ObjectMap).AllMembers;
for (int n = 0; n < members.Count; n++)
{
XmlTypeMapMember mem = (XmlTypeMapMember)members [n];
if (!mem.IsReturnValue && mem.TypeData.IsValueType)
{
SetMemberValueFromAttr(mem, parameters, CreateInstance(
mem.TypeData.Type), true);
}
}
if (_format == SerializationFormat.Encoded)
{
while (Reader.NodeType == Mono.System.Xml.XmlNodeType.Element)
{
string root = Reader.GetAttribute("root", XmlSerializer.EncodingNamespace);
if (root == null || Mono.System.Xml.XmlConvert.ToBoolean(root))
{
break;
}
ReadReferencedElement();
Reader.MoveToContent();
}
}
while (Reader.NodeType != Mono.System.Xml.XmlNodeType.EndElement &&
// it could be an empty root element
Reader.ReadState == ReadState.Interactive)
{
if (Reader.IsStartElement(typeMap.ElementName, typeMap.Namespace) ||
_format == SerializationFormat.Encoded)
{
ReadAttributeMembers((ClassMap)typeMap.ObjectMap, parameters, true);
if (Reader.IsEmptyElement)
{
Reader.Skip();
Reader.MoveToContent();
continue;
}
Reader.ReadStartElement();
ReadMembers((ClassMap)typeMap.ObjectMap, parameters, true, false);
ReadEndElement();
break;
}
else
{
UnknownNode(null);
}
Reader.MoveToContent();
}
}
else
{
ReadMembers((ClassMap)typeMap.ObjectMap, parameters, true, _format == SerializationFormat.Encoded);
}
if (_format == SerializationFormat.Encoded)
{
ReadReferencedElements();
}
return(parameters);
}
public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping,
bool exportEnclosingType)
{
_exporter.ExportMembersMapping(xmlMembersMapping, exportEnclosingType);
}
public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping)
{
_exporter.ExportMembersMapping(xmlMembersMapping, false);
}