Write some special names back when writing xaml to XmlWriter.
authorAtsushi Eno <atsushi@ximian.com>
Mon, 25 Oct 2010 08:57:58 +0000 (17:57 +0900)
committerAtsushi Eno <atsushi@ximian.com>
Mon, 25 Oct 2010 08:57:58 +0000 (17:57 +0900)
mcs/class/System.Xaml/System.Xaml/XamlLanguage.cs
mcs/class/System.Xaml/System.Xaml/XamlSchemaContext.cs
mcs/class/System.Xaml/System.Xaml/XamlType.cs
mcs/class/System.Xaml/System.Xaml/XamlXmlWriter.cs
mcs/class/System.Xaml/Test/System.Xaml/XamlXmlWriterTest.cs

index 5bdaad51aa0d106a2816d13baa701530545e1a4a..c3c2c877fa75a148d584a6636e352d4210ffb563 100644 (file)
@@ -39,6 +39,42 @@ namespace System.Xaml
                public const string Xml1998Namespace = "http://www.w3.org/XML/1998/namespace";
                internal const string Xmlns2000Namespace = "http://www.w3.org/2000/xmlns/";
 
+               // FIXME: I'm not sure if these "special names" should be resolved like this. I couldn't find any rule so far.
+               internal static readonly SpecialTypeNameList SpecialNames;
+
+               internal class SpecialTypeNameList : List<SpecialTypeName>
+               {
+                       internal SpecialTypeNameList ()
+                       {
+                               Add (new SpecialTypeName ("Array", XamlLanguage.Array));
+                               Add (new SpecialTypeName ("Member", XamlLanguage.Member));
+                               Add (new SpecialTypeName ("Null", XamlLanguage.Null));
+                               Add (new SpecialTypeName ("Property", XamlLanguage.Property));
+                               Add (new SpecialTypeName ("Static", XamlLanguage.Static));
+                               Add (new SpecialTypeName ("Type", XamlLanguage.Type));
+                       }
+
+                       public XamlType Find (string name, string ns)
+                       {
+                               if (ns != XamlLanguage.Xaml2006Namespace)
+                                       return null;
+                               var stn = this.FirstOrDefault (s => s.Name == name);
+                               return stn != null ? stn.Type : null;
+                       }
+               }
+
+               internal class SpecialTypeName
+               {
+                       public SpecialTypeName (string name, XamlType type)
+                       {
+                               Name = name;
+                               Type = type;
+                       }
+                       
+                       public string Name { get; private set; }
+                       public XamlType Type { get; private set; }
+               }
+
                static readonly XamlSchemaContext sctx = new XamlSchemaContext (new Assembly [] {typeof (XamlType).Assembly});
 
                static XamlType XT<T> ()
@@ -52,6 +88,7 @@ namespace System.Xaml
                static XamlLanguage ()
                {
                        InitializingTypes = true;
+
                        // types
 
                        Array = XT<ArrayExtension> ();
@@ -117,6 +154,8 @@ namespace System.Xaml
                        AllDirectives = new ReadOnlyCollection<XamlDirective> (new XamlDirective [] {Arguments, AsyncRecords, Base, Class, ClassAttributes, ClassModifier, Code, ConnectionId, FactoryMethod, FieldModifier, Initialization, Items, Key, Lang, Members, Name, PositionalParameters, Space, Subclass, SynchronousMode, Shared, TypeArguments, Uid, UnknownContent});
 
                        InitializingDirectives = false;
+
+                       SpecialNames = new SpecialTypeNameList ();
                }
 
                static readonly string [] xaml_nss = new string [] {Xaml2006Namespace};
@@ -215,28 +254,6 @@ namespace System.Xaml
                        }
                }
 
-               internal static XamlType GetSpecialXaml2006Type (string name)
-               {
-                       // FIXME: I'm not really sure if these *special* names 
-                       // should be resolved here and there. There just does
-                       // not seem to be any other appropriate places.
-                       switch (name) {
-                       case "Array":
-                               return XamlLanguage.Array;
-                       case "Member":
-                               return XamlLanguage.Member;
-                       case "Null":
-                               return XamlLanguage.Null;
-                       case "Property":
-                               return XamlLanguage.Property;
-                       case "Static":
-                               return XamlLanguage.Static;
-                       case "Type":
-                               return XamlLanguage.Type;
-                       }
-                       return null;
-               }
-
                static readonly int clr_ns_len = "clr-namespace:".Length;
                static readonly int clr_ass_len = "assembly=".Length;
 
@@ -246,7 +263,7 @@ namespace System.Xaml
                        string name = xmlLocalName;
 
                        if (ns == XamlLanguage.Xaml2006Namespace) {
-                               var xt = GetSpecialXaml2006Type (name);
+                               var xt = SpecialNames.Find (name, ns);
                                if (xt == null)
                                        xt = AllTypes.FirstOrDefault (t => t.Name == xmlLocalName);
                                if (xt == null)
index 82f121e1aec398cb0c67716c29138f77a7fd1953..4ddd3ddcd43b4b023e332f97957619cb26d9da16 100644 (file)
@@ -194,7 +194,7 @@ namespace System.Xaml
 
                        XamlType ret;
                        if (xamlNamespace == XamlLanguage.Xaml2006Namespace) {
-                               ret = XamlLanguage.GetSpecialXaml2006Type (name);
+                               ret = XamlLanguage.SpecialNames.Find (name, xamlNamespace);
                                if (ret == null)
                                        ret = XamlLanguage.AllTypes.FirstOrDefault (t => TypeMatches (t, xamlNamespace, name, typeArguments));
                                if (ret != null)
index afc06be3e803e21359fd6f81f7e5dfaefb3ae674..39c90a3f2fcd37e9f5989b80f1ddbc582dbb6d97 100644 (file)
@@ -232,6 +232,13 @@ namespace System.Xaml
                        get { return LookupValueSerializer (); }
                }
 
+               internal string InternalXmlName {
+                       get {
+                               var stn = XamlLanguage.SpecialNames.FirstOrDefault (s => s.Type == this);
+                               return stn != null ? stn.Name : Name;
+                       }
+               }
+
                public static bool operator == (XamlType left, XamlType right)
                {
                        return IsNull (left) ? IsNull (right) : left.Equals (right);
index e2eee528dad3076dd6d8df78e6742383f689cd45..1bdc66649b20a4f9d05cae5ede63b50b8212f62e 100644 (file)
@@ -246,7 +246,7 @@ namespace System.Xaml
                void DoWriteStartObject (XamlType xamlType)
                {
                        string prefix = GetPrefix (xamlType.PreferredXamlNamespace);
-                       w.WriteStartElement (prefix, xamlType.Name, xamlType.PreferredXamlNamespace);
+                       w.WriteStartElement (prefix, xamlType.InternalXmlName, xamlType.PreferredXamlNamespace);
                        WriteAndClearNamespaces ();
                }
                
index ab844427d2761bcfdf54cff365db456e5c66229d..2e9d29938c701f338e5d781930f9c59811bce960 100644 (file)
@@ -663,14 +663,12 @@ namespace MonoTests.System.Xaml
                }
 
                [Test]
-               [Category ("NotWorking")]
                public void Write_Null ()
                {
                        Assert.AreEqual (ReadXml ("NullExtension.xml"), XamlServices.Save (null), "#1");
                }
 
                [Test]
-               [Category ("NotWorking")]
                public void Write_NullExtension ()
                {
                        Assert.AreEqual (ReadXml ("NullExtension.xml"), XamlServices.Save (new NullExtension ()), "#1");