* roottypes.cs: Rename from tree.cs.

[mono.git] / mcs / class / System / System.Configuration / SettingsPropertyValue.cs

diff --git a/mcs/class/System/System.Configuration/SettingsPropertyValue.cs b/mcs/class/System/System.Configuration/SettingsPropertyValue.cs
index b86e5d0e7131ef46b6565d226ff5ab80001100d2..db1e781159289d0666f99395bf8b3da149b1ae4d 100644 (file)
--- a/mcs/class/System/System.Configuration/SettingsPropertyValue.cs
+++ b/mcs/class/System/System.Configuration/SettingsPropertyValue.cs
@@ -28,6 +28,11 @@
 
 #if NET_2_0
 using System;
+using System.IO;
+using System.Runtime.Serialization.Formatters.Binary;
+#if (XML_DEP)
+using System.Xml.Serialization;
+#endif
 
 namespace System.Configuration
 {
@@ -36,62 +41,124 @@ namespace System.Configuration
        {
                public SettingsPropertyValue (SettingsProperty property)
                {
-                               throw new NotImplementedException ();
+                       this.property = property;
+                       needPropertyValue = true;
                }
 
                public bool Deserialized {
                        get {
-                               throw new NotImplementedException ();
+                               return deserialized;
                        }
                        set {
-                               throw new NotImplementedException ();
+                               deserialized = true;
                        }
                }
 
                public bool IsDirty {
                        get {
-                               throw new NotImplementedException ();
+                               return dirty;
                        }
                        set {
-                               throw new NotImplementedException ();
+                               dirty = value;
                        }
                }
 
                public string Name {
                        get {
-                               throw new NotImplementedException ();
+                               return property.Name;
                        }
                }
 
                public SettingsProperty Property {
                        get {
-                               throw new NotImplementedException ();
+                               return property;
                        }
                }
 
                public object PropertyValue {
                        get {
-                               throw new NotImplementedException ();
+                               if (needPropertyValue) {
+                                       needPropertyValue = false;
+                                       propertyValue = property.DefaultValue;
+                                       defaulted = true;
+                               }
+
+#if notyet
+                               /* LAMESPEC: the msdn2 docs say that
+                                * for object types this
+                                * pessimistically sets Dirty == true.
+                                * tests, however, point out that that
+                                * is not the case. */
+                               if (!property.PropertyType.IsValueType)
+                                       dirty = true;
+#endif
+
+                               return propertyValue;
                        }
                        set {
-                               throw new NotImplementedException ();
+                               propertyValue = value;
+                               dirty = true;
+                               needPropertyValue = false;
+                               needSerializedValue = true;
+                               defaulted = false;
                        }
                }
 
+               [MonoTODO ("string type converter?")]
                public object SerializedValue {
                        get {
-                               throw new NotImplementedException ();
+                               if (needSerializedValue) {
+                                       needSerializedValue = false;
+
+                                       switch (property.SerializeAs)
+                                       {
+                                       case SettingsSerializeAs.String:
+                                               /* the docs say use a string type converter.. this means what? */
+                                               serializedValue = propertyValue.ToString();
+                                               break;
+#if (XML_DEP)
+                                       case SettingsSerializeAs.Xml:
+                                               XmlSerializer serializer = new XmlSerializer (propertyValue.GetType());
+                                               StringWriter w = new StringWriter();
+
+                                               serializer.Serialize (w, propertyValue);
+                                               serializedValue = w.ToString();
+                                               break;
+#endif
+                                       case SettingsSerializeAs.Binary:
+                                               BinaryFormatter bf = new BinaryFormatter ();
+                                               MemoryStream ms = new MemoryStream ();
+                                               bf.Serialize (ms, propertyValue);
+                                               serializedValue = ms.ToArray();
+                                               break;
+                                       default:
+                                               serializedValue = null;
+                                               break;
+                                       }
+
+                               }
+
+                               return serializedValue;
                        }
                        set {
-                               throw new NotImplementedException ();
+                               serializedValue = value;
                        }
                }
 
                public bool UsingDefaultValue {
                        get {
-                               throw new NotImplementedException ();
+                               return defaulted;
                        }
                }
+
+               SettingsProperty property;
+               object propertyValue;
+               object serializedValue;
+               bool needSerializedValue;
+               bool needPropertyValue;
+               bool dirty;
+               bool defaulted;
+               bool deserialized;
        }
 
 }