+2004-02-11 Lluis Sanchez Gual <lluis@ximian.com>
+
+ * MapCodeGenerator.cs: Changed some methods to make them easier to reuse.
+ * TypeTranslator.cs: NMTOKENS, ENTITIES and IDREFS must be mapped to
+ string, not string[].
+ * XmlCodeExporter.cs: AddMappingMetadata(): improved attribute generation
+ for array parameters. In general, improved generation of schema Form
+ property.
+ * XmlMemberMapping.cs: Added Form property.
+ * XmlReflectionImporter.cs: Types that inherit from other types cannot be
+ simple types. Added a check for this.
+ * XmlSchemaExporter.cs: several fixes: better generation of IsMixed and
+ Form. The key used to determine if a map has been already generated must
+ include the XmlType, since there can be two xml types with the same CLR
+ type and namespace (for example, they may differ in the Form property).
+ * XmlSchemaImporter.cs: When getting the TypeData for a schema element,
+ also return the corresponding map. There can be two maps that have the
+ same TypeData, so given a TypeData is not always possible to get the
+ correct corresponding map (for example two arrays that only differ in the
+ Form of the item).
+ * XmlTypeMapping.cs: Added method to set if a map can represent a simple
+ type or not.
+
2004-02-04 Lluis Sanchez Gual <lluis@ximian.com>
* TypeTranslator.cs, XmlCustomFormatter.cs: Added support for the
codeField.Attributes = MemberAttributes.Public;
codeClass.Members.Add (codeField);
- GenerateArrayElement (codeField, member, defaultNamespace);
+ CodeAttributeDeclarationCollection attributes = new CodeAttributeDeclarationCollection ();
+ AddArrayAttributes (attributes, member, defaultNamespace, false);
ListMap listMap = (ListMap) member.ListTypeMapping.ObjectMap;
- AddArrayItemAttributes (codeField, listMap, member.TypeData.ListItemTypeData, defaultNamespace, 0);
+ AddArrayItemAttributes (attributes, listMap, member.TypeData.ListItemTypeData, defaultNamespace, 0);
+
+ if (attributes.Count > 0) codeField.CustomAttributes = attributes;
+ }
+
+ public void AddArrayAttributes (CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, string defaultNamespace, bool forceUseMemberName)
+ {
+ GenerateArrayElement (attributes, member, defaultNamespace, forceUseMemberName);
}
- void AddArrayItemAttributes (CodeMemberField codeField, ListMap listMap, TypeData type, string defaultNamespace, int nestingLevel)
+ public void AddArrayItemAttributes (CodeAttributeDeclarationCollection attributes, ListMap listMap, TypeData type, string defaultNamespace, int nestingLevel)
{
foreach (XmlTypeMapElementInfo ainfo in listMap.ItemInfo)
{
if (ainfo.MappedType != null) defaultName = ainfo.MappedType.ElementName;
else defaultName = ainfo.TypeData.XmlType;
- GenerateArrayItemAttributes (codeField, listMap, type, ainfo, defaultName, defaultNamespace, nestingLevel);
+ GenerateArrayItemAttributes (attributes, listMap, type, ainfo, defaultName, defaultNamespace, nestingLevel);
if (ainfo.MappedType != null) ExportMapCode (ainfo.MappedType);
}
if (listMap.IsMultiArray)
{
XmlTypeMapping nmap = listMap.NestedArrayMapping;
- AddArrayItemAttributes (codeField, (ListMap) nmap.ObjectMap, nmap.TypeData.ListItemTypeData, defaultNamespace, nestingLevel + 1);
+ AddArrayItemAttributes (attributes, (ListMap) nmap.ObjectMap, nmap.TypeData.ListItemTypeData, defaultNamespace, nestingLevel + 1);
}
}
return new CodeAttributeArgument (name, new CodeTypeOfExpression(typeName));
}
- public CodeAttributeArgument GetEnumArg (string name, string enumType, string enumValue)
+ public static CodeAttributeArgument GetEnumArg (string name, string enumType, string enumValue)
{
return new CodeAttributeArgument (name, new CodeFieldReferenceExpression (new CodeTypeReferenceExpression(enumType), enumValue));
}
{
}
- protected virtual void GenerateArrayElement (CodeMemberField codeField, XmlTypeMapMemberElement member, string defaultNamespace)
+ protected virtual void GenerateArrayElement (CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, string defaultNamespace, bool forceUseMemberName)
{
}
- protected virtual void GenerateArrayItemAttributes (CodeMemberField codeField, ListMap listMap, TypeData type, XmlTypeMapElementInfo ainfo, string defaultName, string defaultNamespace, int nestingLevel)
+ protected virtual void GenerateArrayItemAttributes (CodeAttributeDeclarationCollection attributes, ListMap listMap, TypeData type, XmlTypeMapElementInfo ainfo, string defaultName, string defaultNamespace, int nestingLevel)
{
}
primitiveTypes.Add ("gYearMonth", new TypeData (typeof (string), "gYearMonth", true));
primitiveTypes.Add ("month", new TypeData (typeof (DateTime), "month", true));
primitiveTypes.Add ("NMTOKEN", new TypeData (typeof (string), "NMTOKEN", true));
- primitiveTypes.Add ("NMTOKENS", new TypeData (typeof (string[]), "NMTOKENS", true));
+ primitiveTypes.Add ("NMTOKENS", new TypeData (typeof (string), "NMTOKENS", true));
primitiveTypes.Add ("Name", new TypeData (typeof (string), "Name", true));
primitiveTypes.Add ("NCName", new TypeData (typeof (string), "NCName", true));
primitiveTypes.Add ("language", new TypeData (typeof (string), "language", true));
primitiveTypes.Add ("nonPositiveInteger", new TypeData (typeof (string), "nonPositiveInteger", true));
primitiveTypes.Add ("negativeInteger", new TypeData (typeof (string), "negativeInteger", true));
primitiveTypes.Add ("nonNegativeInteger", new TypeData (typeof (string), "nonNegativeInteger", true));
- primitiveTypes.Add ("ENTITIES", new TypeData (typeof (string[]), "ENTITIES", true));
+ primitiveTypes.Add ("ENTITIES", new TypeData (typeof (string), "ENTITIES", true));
primitiveTypes.Add ("ENTITY", new TypeData (typeof (string), "ENTITY", true));
primitiveTypes.Add ("hexBinary", new TypeData (typeof (byte[]), "hexBinary", true));
primitiveTypes.Add ("ID", new TypeData (typeof (string), "ID", true));
primitiveTypes.Add ("IDREF", new TypeData (typeof (string), "IDREF", true));
- primitiveTypes.Add ("IDREFS", new TypeData (typeof (string[]), "IDREFS", true));
+ primitiveTypes.Add ("IDREFS", new TypeData (typeof (string), "IDREFS", true));
primitiveTypes.Add ("NOTATION", new TypeData (typeof (string), "NOTATION", true));
primitiveTypes.Add ("token", new TypeData (typeof (string), "token", true));
primitiveTypes.Add ("normalizedString", new TypeData (typeof (string), "normalizedString", true));
else if (memType.SchemaType == SchemaTypes.Array)\r
{\r
// Array parameter\r
- att = new CodeAttributeDeclaration ("System.Xml.Serialization.XmlArray");\r
- if (forceUseMemberName || (member.ElementName != member.MemberName)) att.Arguments.Add (MapCodeGenerator.GetArg ("ElementName", member.ElementName));\r
- if (member.Namespace != ns) att.Arguments.Add (MapCodeGenerator.GetArg ("Namespace", member.Namespace));\r
- if (att.Arguments.Count > 0) metadata.Add (att);\r
+ \r
+ XmlTypeMapMemberList list = member.TypeMapMember as XmlTypeMapMemberList;\r
+ ListMap listMap = (ListMap) list.ListTypeMapping.ObjectMap;\r
+ \r
+ codeGenerator.AddArrayAttributes (metadata, list, ns, forceUseMemberName);\r
+ codeGenerator.AddArrayItemAttributes (metadata, listMap, memType.ListItemTypeData, list.Namespace, 0);\r
}\r
else if (!member.Any)\r
{\r
if (forceUseMemberName || (member.ElementName != member.MemberName)) att.Arguments.Add (MapCodeGenerator.GetArg ("ElementName", member.ElementName));\r
if (member.Namespace != ns) att.Arguments.Add (MapCodeGenerator.GetArg ("Namespace", member.Namespace));\r
if (!TypeTranslator.IsDefaultPrimitiveTpeData (memType)) att.Arguments.Add (MapCodeGenerator.GetArg ("DataType", member.TypeName));\r
+ if (member.Form == XmlSchemaForm.Unqualified) att.Arguments.Add (MapCodeGenerator.GetEnumArg ("Form", "System.Xml.Schema.XmlSchemaForm", member.Form.ToString()));\r
if (att.Arguments.Count > 0) metadata.Add (att);\r
}\r
}\r
if (einfo.ElementName != member.Name) att.Arguments.Add (GetArg (einfo.ElementName));\r
if (einfo.TypeData.FullTypeName != defaultType.FullTypeName) att.Arguments.Add (GetTypeArg ("Type", einfo.TypeData.FullTypeName));\r
if (einfo.Namespace != defaultNamespace) att.Arguments.Add (GetArg ("Namespace", einfo.Namespace));\r
+ if (einfo.Form == XmlSchemaForm.Unqualified) att.Arguments.Add (GetEnumArg ("Form", "System.Xml.Schema.XmlSchemaForm", einfo.Form.ToString()));\r
if (einfo.IsNullable) att.Arguments.Add (GetArg ("IsNullable", true));\r
if (!TypeTranslator.IsDefaultPrimitiveTpeData(einfo.TypeData)) att.Arguments.Add (GetArg ("DataType",einfo.TypeData.XmlType));\r
AddCustomAttribute (codeField, att, addAlwaysAttr);\r
AddCustomAttribute (codeField, "System.Xml.Serialization.XmlChoiceIdentifier", GetArg(member.ChoiceMember));\r
}\r
\r
- protected override void GenerateArrayElement (CodeMemberField codeField, XmlTypeMapMemberElement member, string defaultNamespace)\r
+ protected override void GenerateArrayElement (CodeAttributeDeclarationCollection attributes, XmlTypeMapMemberElement member, string defaultNamespace, bool forceUseMemberName)\r
{\r
XmlTypeMapElementInfo einfo = (XmlTypeMapElementInfo) member.ElementInfo[0];\r
CodeAttributeDeclaration att = new CodeAttributeDeclaration ("System.Xml.Serialization.XmlArray");\r
- if (einfo.ElementName != member.Name) att.Arguments.Add (GetArg ("ElementName", einfo.ElementName));\r
+ if (forceUseMemberName || (einfo.ElementName != member.Name)) att.Arguments.Add (GetArg ("ElementName", einfo.ElementName));\r
if (einfo.Namespace != defaultNamespace) att.Arguments.Add (GetArg ("Namespace", einfo.Namespace));\r
+ if (einfo.Form == XmlSchemaForm.Unqualified) att.Arguments.Add (MapCodeGenerator.GetEnumArg ("Form", "System.Xml.Schema.XmlSchemaForm", einfo.Form.ToString()));\r
if (einfo.IsNullable) att.Arguments.Add (GetArg ("IsNullable", true));\r
- AddCustomAttribute (codeField, att, false);\r
+ if (att.Arguments.Count > 0) attributes.Add (att);\r
}\r
\r
- protected override void GenerateArrayItemAttributes (CodeMemberField codeField, ListMap listMap, TypeData type, XmlTypeMapElementInfo ainfo, string defaultName, string defaultNamespace, int nestingLevel)\r
+ protected override void GenerateArrayItemAttributes (CodeAttributeDeclarationCollection attributes, ListMap listMap, TypeData type, XmlTypeMapElementInfo ainfo, string defaultName, string defaultNamespace, int nestingLevel)\r
{\r
bool needsType = (listMap.ItemInfo.Count > 1) ||\r
(ainfo.TypeData.FullTypeName != type.FullTypeName && !listMap.IsMultiArray);\r
if (ainfo.ElementName != defaultName) att.Arguments.Add (GetArg ("ElementName", ainfo.ElementName));\r
if (ainfo.Namespace != defaultNamespace && ainfo.Namespace != XmlSchema.Namespace) att.Arguments.Add (GetArg ("Namespace", ainfo.Namespace));\r
if (needsType) att.Arguments.Add (GetTypeArg ("Type", ainfo.TypeData.FullTypeName));\r
- if (ainfo.IsNullable) att.Arguments.Add (GetArg ("IsNullable", true));\r
+ if (!ainfo.IsNullable) att.Arguments.Add (GetArg ("IsNullable", false));\r
+ if (ainfo.Form == XmlSchemaForm.Unqualified) att.Arguments.Add (MapCodeGenerator.GetEnumArg ("Form", "System.Xml.Schema.XmlSchemaForm", ainfo.Form.ToString()));\r
if (att.Arguments.Count > 0 && nestingLevel > 0) att.Arguments.Add (GetArg ("NestingLevel", nestingLevel));\r
- AddCustomAttribute (codeField, att, false);\r
+ \r
+ if (att.Arguments.Count > 0) attributes.Add (att);\r
}\r
\r
protected override void GenerateTextElementAttribute (CodeMemberField codeField, XmlTypeMapElementInfo einfo, TypeData defaultType)\r
// Copyright (C) Tim Coleman, 2002
//
+using System.Xml.Schema;
+
namespace System.Xml.Serialization
{
public class XmlMemberMapping {
string _memberName;
string _namespace;
string _typeNamespace;
+ XmlSchemaForm _form;
internal XmlMemberMapping (string memberName, string defaultNamespace, XmlTypeMapMember mapMem, bool encodedFormat)
{
_namespace = info.Namespace;
if (info.MappedType != null) _typeNamespace = info.MappedType.Namespace;
else _typeNamespace = "";
+ _form = info.Form;
}
}
else
_elementName = _memberName;
_namespace = "";
}
+
+ if (_form == XmlSchemaForm.None)
+ _form = XmlSchemaForm.Qualified;
}
#region Properties
internal XmlTypeMapMember TypeMapMember {
get { return _mapMember; }
}
+
+ internal XmlSchemaForm Form {
+ get { return _form; }
+ }
#endregion // Properties
}
static readonly string errSimple = "Cannot serialize object of type '{0}'. Base " +
"type '{1}' has simpleContent and can be only extended by adding XmlAttribute " +
- "elements. Please consider changing XmlTextMember of the base class to string array";
+ "elements. Please consider changing XmlText member of the base class to string array";
+
+ static readonly string errSimple2 = "Cannot serialize object of type '{0}'. " +
+ "Consider changing type of XmlText member '{1}' from '{2}' to string or string array";
#region Constructors
{
XmlTypeMapping bmap = ImportClassMapping (type.BaseType, root, defaultNamespace);
- if (type.BaseType != typeof (object))
+ if (type.BaseType != typeof (object)) {
map.BaseMap = bmap;
+ classMap.SetCanBeSimpleType (false);
+ }
// At this point, derived classes of this map must be already registered
throw new InvalidOperationException (String.Format (errSimple, map.TypeData.TypeName, map.BaseMap.TypeData.TypeName));
}
+ if (classMap.XmlTextCollector != null && !classMap.HasSimpleContent)
+ {
+ XmlTypeMapMember mem = classMap.XmlTextCollector;
+ if (mem.TypeData.Type != typeof(string) &&
+ mem.TypeData.Type != typeof(string[]) &&
+ mem.TypeData.Type != typeof(XmlNode[]))
+
+ throw new InvalidOperationException (String.Format (errSimple2, map.TypeData.TypeName, mem.Name, mem.TypeData.TypeName));
+ }
+
return map;
}
elem.Namespace = (atts.XmlArray != null && atts.XmlArray.Namespace != null) ? atts.XmlArray.Namespace : defaultNamespace;
elem.MappedType = ImportListMapping (rmember.MemberType, null, elem.Namespace, atts, 0);
elem.IsNullable = (atts.XmlArray != null) ? atts.XmlArray.IsNullable : false;
+ elem.Form = (atts.XmlArray != null) ? atts.XmlArray.Form : XmlSchemaForm.Qualified;
+
member.ElementInfo.Add (elem);
mapMember = member;
}
ExportMembersMapSchema (schema, cmap, map.BaseMap, ext.Attributes, out particle, out anyAttribute);
ext.Particle = particle;
ext.AnyAttribute = anyAttribute;
+ stype.IsMixed = cmap.XmlTextCollector != null;
ImportNamespace (schema, map.BaseMap.XmlTypeNamespace);
ExportClassSchema (map.BaseMap);
XmlSchemaSequence seq = new XmlSchemaSequence ();
ICollection members = map.ElementMembers;
- if (members != null)
+ if (members != null && !map.HasSimpleContent)
{
foreach (XmlTypeMapMemberElement member in members)
{
Type memType = member.GetType();
if (memType == typeof(XmlTypeMapMemberFlatList))
{
- seq.Items.Add (GetSchemaArrayElement (schema, member.ElementInfo));
+ XmlSchemaParticle part = GetSchemaArrayElement (schema, member.ElementInfo);
+ if (part != null) seq.Items.Add (part);
}
else if (memType == typeof(XmlTypeMapMemberAnyElement))
{
if (defaultValue != System.DBNull.Value)
selem.DefaultValue = XmlCustomFormatter.ToXmlString (einfo.TypeData, defaultValue);
+
+ if (einfo.Form != XmlSchemaForm.Qualified)
+ selem.Form = einfo.Form;
switch (einfo.TypeData.SchemaType)
{
string GetMapKey (XmlTypeMapping map)
{
- return map.TypeData.FullTypeName + " " + map.XmlTypeNamespace;
+ return map.TypeData.FullTypeName + " " + map.XmlType + " " + map.XmlTypeNamespace;
}
void CompileSchemas ()
XmlTypeMapMemberAnyElement mapMem = new XmlTypeMapMemberAnyElement ();\r
mapMem.Name = typeName.Name;\r
mapMem.TypeData = TypeTranslator.GetTypeData(typeof(XmlNode));\r
- mapMem.ElementInfo.Add (CreateElementInfo (typeName.Namespace, mapMem, typeName.Name, mapMem.TypeData, true));\r
+ mapMem.ElementInfo.Add (CreateElementInfo (typeName.Namespace, mapMem, typeName.Name, mapMem.TypeData, true, XmlSchemaForm.None));\r
\r
XmlMemberMapping[] mm = new XmlMemberMapping [1];\r
mm[0] = new XmlMemberMapping (typeName.Name, typeName.Namespace, mapMem, encodedFormat);\r
if (elem == null) throw new InvalidOperationException ("Schema element '" + names[n] + "' not found");\r
\r
XmlQualifiedName typeQName = new XmlQualifiedName ("Message", names[n].Namespace);\r
- TypeData td = GetElementTypeData (typeQName, elem);\r
+ XmlTypeMapping tmap;\r
+ TypeData td = GetElementTypeData (typeQName, elem, out tmap);\r
\r
- mapping[n] = ImportMemberMapping (elem.Name, typeQName.Namespace, td);\r
+ mapping[n] = ImportMemberMapping (elem.Name, typeQName.Namespace, td, tmap);\r
}\r
BuildPendingMaps ();\r
return new XmlMembersMapping (mapping);\r
for (int n=0; n<members.Length; n++)\r
{\r
TypeData td = GetTypeData (members[n].MemberType, null);\r
- mapping[n] = ImportMemberMapping (members[n].MemberName, members[n].MemberType.Namespace, td);\r
+ XmlTypeMapping tmap = GetTypeMapping (td);\r
+ mapping[n] = ImportMemberMapping (members[n].MemberName, members[n].MemberType.Namespace, td, tmap);\r
}\r
BuildPendingMaps ();\r
return new XmlMembersMapping (name, ns, hasWrapperElement, false, mapping);\r
return mapping;\r
}\r
\r
- XmlMemberMapping ImportMemberMapping (string name, string ns, TypeData type)\r
+ XmlMemberMapping ImportMemberMapping (string name, string ns, TypeData type, XmlTypeMapping emap)\r
{\r
- XmlTypeMapMemberElement mapMem = new XmlTypeMapMemberElement ();\r
+ XmlTypeMapMemberElement mapMem;\r
+ \r
+ if (type.IsListType)\r
+ mapMem = new XmlTypeMapMemberList ();\r
+ else\r
+ mapMem = new XmlTypeMapMemberElement ();\r
+ \r
mapMem.Name = name;\r
mapMem.TypeData = type;\r
- mapMem.ElementInfo.Add (CreateElementInfo (ns, mapMem, name, type, true));\r
+ mapMem.ElementInfo.Add (CreateElementInfo (ns, mapMem, name, type, true, XmlSchemaForm.None, emap));\r
return new XmlMemberMapping (name, ns, mapMem, encodedFormat);\r
}\r
\r
ClassMap cmap = new ClassMap ();\r
CodeIdentifiers classIds = new CodeIdentifiers();\r
ImportParticleComplexContent (typeQName, cmap, stype.Particle, classIds, stype.IsMixed);\r
- \r
+\r
XmlTypeMapMemberFlatList list = (cmap.AllMembers.Count == 1) ? cmap.AllMembers[0] as XmlTypeMapMemberFlatList : null;\r
if (list != null && list.ChoiceMember == null)\r
{\r
arrayTypeData = itemTypeData.ListTypeData;\r
\r
map.ItemInfo = new XmlTypeMapElementInfoList();\r
- map.ItemInfo.Add (CreateElementInfo ("", null, "Item", itemTypeData, true));\r
+ map.ItemInfo.Add (CreateElementInfo ("", null, "Item", itemTypeData, true, XmlSchemaForm.None));\r
return map;\r
}\r
\r
{\r
string ns;\r
XmlSchemaElement elem = (XmlSchemaElement) item;\r
- TypeData typeData = GetElementTypeData (typeQName, elem);\r
+ XmlTypeMapping emap;\r
+ TypeData typeData = GetElementTypeData (typeQName, elem, out emap);\r
XmlSchemaElement refElem = GetRefElement (typeQName, elem, out ns);\r
\r
if (elem.MaxOccurs == 1 && !multiValue)\r
member.Name = classIds.AddUnique(CodeIdentifier.MakeValid(refElem.Name), member);\r
member.Documentation = GetDocumentation (elem);\r
member.TypeData = typeData;\r
- member.ElementInfo.Add (CreateElementInfo (ns, member, refElem.Name, typeData, refElem.IsNillable));\r
+ member.ElementInfo.Add (CreateElementInfo (ns, member, refElem.Name, typeData, refElem.IsNillable, refElem.Form, emap));\r
cmap.AddMember (member);\r
}\r
else\r
member.Name = classIds.AddUnique(CodeIdentifier.MakeValid(refElem.Name), member);\r
member.Documentation = GetDocumentation (elem);\r
member.TypeData = typeData.ListTypeData;\r
- member.ElementInfo.Add (CreateElementInfo (ns, member, refElem.Name, typeData, refElem.IsNillable));\r
+ member.ElementInfo.Add (CreateElementInfo (ns, member, refElem.Name, typeData, refElem.IsNillable, refElem.Form, emap));\r
member.ListMap.ItemInfo = member.ElementInfo;\r
cmap.AddMember (member);\r
}\r
// When comparing class types, use the most generic class in the\r
// inheritance hierarchy\r
\r
-\r
XmlTypeMapping choiceMap = GetTypeMapping (choiceType);\r
BuildPendingMap (choiceMap);\r
while (choiceMap.BaseMap != null) {\r
enumMap.ObjectMap = new EnumMap (members, false);\r
\r
choiceMember.TypeData = multiValue ? enumMap.TypeData.ListTypeData : enumMap.TypeData;\r
- choiceMember.ElementInfo.Add (CreateElementInfo (typeQName.Namespace, choiceMember, choiceMember.Name, choiceMember.TypeData, false));\r
+ choiceMember.ElementInfo.Add (CreateElementInfo (typeQName.Namespace, choiceMember, choiceMember.Name, choiceMember.TypeData, false, XmlSchemaForm.None));\r
cmap.AddMember (choiceMember);\r
}\r
\r
{\r
string ns;\r
XmlSchemaElement elem = (XmlSchemaElement) item;\r
- TypeData typeData = GetElementTypeData (typeQName, elem);\r
+ XmlTypeMapping emap;\r
+ TypeData typeData = GetElementTypeData (typeQName, elem, out emap);\r
XmlSchemaElement refElem = GetRefElement (typeQName, elem, out ns);\r
- choices.Add (CreateElementInfo (ns, member, refElem.Name, typeData, refElem.IsNillable));\r
+ choices.Add (CreateElementInfo (ns, member, refElem.Name, typeData, refElem.IsNillable, refElem.Form, emap));\r
if (elem.MaxOccurs > 1) multiValue = true;\r
}\r
else if (item is XmlSchemaAny)\r
ListMap listMap = new ListMap ();\r
\r
listMap.ItemInfo = new XmlTypeMapElementInfoList ();\r
- listMap.ItemInfo.Add (CreateElementInfo (typeQName.Namespace, null, "Item", arrayTypeData.ListItemTypeData, false));\r
+ listMap.ItemInfo.Add (CreateElementInfo (typeQName.Namespace, null, "Item", arrayTypeData.ListItemTypeData, false, XmlSchemaForm.None));\r
\r
XmlTypeMapping map = CreateArrayTypeMapping (typeQName, arrayTypeData);\r
map.ObjectMap = listMap;\r
return (Type) forcedBaseTypes [tname];\r
}\r
\r
- XmlTypeMapElementInfo CreateElementInfo (string ns, XmlTypeMapMember member, string name, TypeData typeData, bool isNillable)\r
+ XmlTypeMapElementInfo CreateElementInfo (string ns, XmlTypeMapMember member, string name, TypeData typeData, bool isNillable, XmlSchemaForm form)\r
+ {\r
+ if (typeData.IsComplexType)\r
+ return CreateElementInfo (ns, member, name, typeData, isNillable, form, GetTypeMapping (typeData));\r
+ else\r
+ return CreateElementInfo (ns, member, name, typeData, isNillable, form, null);\r
+ }\r
+ \r
+ XmlTypeMapElementInfo CreateElementInfo (string ns, XmlTypeMapMember member, string name, TypeData typeData, bool isNillable, XmlSchemaForm form, XmlTypeMapping emap)\r
{\r
XmlTypeMapElementInfo einfo = new XmlTypeMapElementInfo (member, typeData);\r
einfo.ElementName = name;\r
einfo.Namespace = ns;\r
einfo.IsNullable = isNillable;\r
- if (einfo.TypeData.IsComplexType)\r
- einfo.MappedType = GetTypeMapping (typeData);\r
+ einfo.Form = form;\r
+ if (typeData.IsComplexType)\r
+ einfo.MappedType = emap;\r
return einfo;\r
}\r
\r
}\r
}\r
\r
- TypeData GetElementTypeData (XmlQualifiedName typeQName, XmlSchemaElement elem)\r
+ TypeData GetElementTypeData (XmlQualifiedName typeQName, XmlSchemaElement elem, out XmlTypeMapping map)\r
{\r
bool sharedAnnType = false;\r
XmlQualifiedName root = null;\r
+ map = null;\r
\r
if (!elem.RefName.IsEmpty) {\r
XmlSchemaElement refElem = FindRefElement (elem);\r
sharedAnnType = true;\r
}\r
\r
- if (!elem.SchemaTypeName.IsEmpty) return GetTypeData (elem.SchemaTypeName, root);\r
- else if (elem.SchemaType == null) return TypeTranslator.GetTypeData (typeof(object));\r
- else return GetTypeData (elem.SchemaType, typeQName, elem.Name, sharedAnnType, root);\r
+ TypeData td;\r
+ if (!elem.SchemaTypeName.IsEmpty) {\r
+ td = GetTypeData (elem.SchemaTypeName, root);\r
+ map = GetRegisteredTypeMapping (elem.SchemaTypeName);\r
+ }\r
+ else if (elem.SchemaType == null) \r
+ td = TypeTranslator.GetTypeData (typeof(object));\r
+ else \r
+ td = GetTypeData (elem.SchemaType, typeQName, elem.Name, sharedAnnType, root);\r
+ \r
+ if (map == null && td.IsComplexType)\r
+ map = GetTypeMapping (td);\r
+ \r
+ return td;\r
}\r
\r
TypeData GetAttributeTypeData (XmlQualifiedName typeQName, XmlSchemaAttribute attr)\r
\r
ListMap listMap = new ListMap ();\r
listMap.ItemInfo = new XmlTypeMapElementInfoList();\r
- listMap.ItemInfo.Add (CreateElementInfo (itemMap.Namespace, null, typeData.ListItemTypeData.XmlType, typeData.ListItemTypeData, false));\r
+ listMap.ItemInfo.Add (CreateElementInfo (itemMap.Namespace, null, typeData.ListItemTypeData.XmlType, typeData.ListItemTypeData, false, XmlSchemaForm.None));\r
map.ObjectMap = listMap;\r
\r
mappedTypes [new XmlQualifiedName(map.ElementName, map.Namespace)] = map;\r
XmlTypeMapMemberNamespaces _namespaceDeclarations;\r
XmlTypeMapMember _xmlTextCollector;\r
bool _ignoreMemberNamespace;\r
+ bool _canBeSimpleType = true;\r
\r
public void AddMember (XmlTypeMapMember member)\r
{\r
{\r
get\r
{\r
- if (_elementMembers == null || _elementMembers.Count != 1) return null;\r
+ if (!_canBeSimpleType || _elementMembers == null || _elementMembers.Count != 1) return null;\r
XmlTypeMapMemberElement member = (XmlTypeMapMemberElement) _elementMembers[0];\r
if (member.ElementInfo.Count != 1) return null;\r
XmlTypeMapElementInfo einfo = (XmlTypeMapElementInfo) member.ElementInfo[0];\r
if (!einfo.IsTextElement) return null;\r
- if (einfo.TypeData.SchemaType == SchemaTypes.Primitive || einfo.TypeData.SchemaType == SchemaTypes.Enum)\r
+ if (member.TypeData.SchemaType == SchemaTypes.Primitive || member.TypeData.SchemaType == SchemaTypes.Enum)\r
return new XmlQualifiedName (einfo.TypeData.XmlType, einfo.DataTypeNamespace);\r
return null;\r
}\r
}\r
+ \r
+ public void SetCanBeSimpleType (bool can)\r
+ {\r
+ _canBeSimpleType = can;\r
+ }\r
\r
public bool HasSimpleContent\r
{\r
projects / mono.git / commitdiff