* SerializationCodeGenerator.cs: Several fixes: generate valid names for

[mono.git] / mcs / class / System.XML / System.Xml.Serialization / XmlReflectionImporter.cs

diff --git a/mcs/class/System.XML/System.Xml.Serialization/XmlReflectionImporter.cs b/mcs/class/System.XML/System.Xml.Serialization/XmlReflectionImporter.cs
index 1899b325b7a4f84b2f2d1b767aad30f785690006..59a62f8c575d0439ec0c2a04a7c2c6464d0f0817 100644 (file)
--- a/mcs/class/System.XML/System.Xml.Serialization/XmlReflectionImporter.cs
+++ b/mcs/class/System.XML/System.Xml.Serialization/XmlReflectionImporter.cs
@@ -27,7 +27,10 @@ namespace System.Xml.Serialization {
 
                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
 
@@ -90,6 +93,8 @@ namespace System.Xml.Serialization {
                        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;
                }
 
@@ -134,6 +139,8 @@ namespace System.Xml.Serialization {
 
                        map.RelatedMaps = relatedMaps;
                        map.Format = SerializationFormat.Literal;
+                       map.Source = new XmlTypeSerializationSource (type, root, attributeOverrides, defaultNamespace, includedTypes);
+                       if (allowPrivateTypes) map.Source.CanBeGenerated = false;
                        return map;
                }
 
@@ -242,8 +249,10 @@ namespace System.Xml.Serialization {
                        {
                                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
                                
@@ -253,6 +262,17 @@ namespace System.Xml.Serialization {
                                        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(object[]) && 
+                                  mem.TypeData.Type != typeof(XmlNode[]))
+                                  
+                                       throw new InvalidOperationException (String.Format (errSimple2, map.TypeData.TypeName, mem.Name, mem.TypeData.TypeName));
+                       }
+                       
                        return map;
                }
                
@@ -263,6 +283,11 @@ namespace System.Xml.Serialization {
                        
                        if (map.BaseMap != null)
                                RegisterDerivedMap (map.BaseMap, derivedMap);
+                       else {
+                               XmlTypeMapping obmap = ImportTypeMapping (typeof(object));
+                               if (obmap != map)
+                                       obmap.DerivedTypes.Add (derivedMap);
+                       }
                }
 
                string GetTypeNamespace (TypeData typeData, XmlRootAttribute root, string defaultNamespace)
@@ -488,7 +513,7 @@ namespace System.Xml.Serialization {
                        }
                }
 
-               public ICollection GetReflectionMembers (Type type)
+               ICollection GetReflectionMembers (Type type)
                {
                        ArrayList members = new ArrayList();
                        MemberInfo[] tmembers = type.GetMembers (BindingFlags.Instance | BindingFlags.Public);
@@ -632,6 +657,8 @@ namespace System.Xml.Serialization {
                                        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;
                                }
@@ -678,7 +705,7 @@ namespace System.Xml.Serialization {
                                elem.IsNullable = att.IsNullable;
                                
                                if (elem.IsNullable && elem.TypeData.IsValueType)
-                                       throw new InvalidOperationException ("IsNullable may not be 'true' for value type " + elem.TypeData.FullTypeName);
+                                       throw new InvalidOperationException ("IsNullable may not be 'true' for value type " + elem.TypeData.FullTypeName + " in member '" + defaultName + "'");
                                        
                                if (elem.TypeData.IsComplexType)
                                {
@@ -760,7 +787,15 @@ namespace System.Xml.Serialization {
                                throw new ArgumentNullException ("type");
 
                        if (includedTypes == null) includedTypes = new ArrayList ();
-                       includedTypes.Add (type);
+                       if (!includedTypes.Contains (type))
+                               includedTypes.Add (type);
+               }
+
+               public void IncludeTypes (ICustomAttributeProvider provider)
+               { 
+                       object[] ats = provider.GetCustomAttributes (typeof(XmlIncludeAttribute), true);
+                       foreach (XmlIncludeAttribute at in ats)
+                               IncludeType (at.Type);
                }
 
                #endregion // Methods