mcs/class/System/System.Configuration/ConfigurationElement.cs

   1 //
   2 // System.Configuration.ConfigurationElement.cs
   3 //
   4 // Authors:
   5 //      Duncan Mak (duncan@ximian.com)
   6 //  Lluis Sanchez Gual (lluis@novell.com)
   7 //
   8 // Permission is hereby granted, free of charge, to any person obtaining
   9 // a copy of this software and associated documentation files (the
  10 // "Software"), to deal in the Software without restriction, including
  11 // without limitation the rights to use, copy, modify, merge, publish,
  12 // distribute, sublicense, and/or sell copies of the Software, and to
  13 // permit persons to whom the Software is furnished to do so, subject to
  14 // the following conditions:
  15 //
  16 // The above copyright notice and this permission notice shall be
  17 // included in all copies or substantial portions of the Software.
  18 //
  19 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  20 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  22 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  23 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  24 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  25 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26 //
  27 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  28 //
  29
  30 #if NET_2_0 && XML_DEP
  31 #if XML_DEP
  32 using System.Collections;
  33 using System.Xml;
  34 using System.Reflection;
  35 using System.IO;
  36 using System.ComponentModel;
  37
  38 namespace System.Configuration
  39 {
  40         public abstract class ConfigurationElement
  41         {
  42                 static Hashtable elementMaps = new Hashtable ();
  43                 Hashtable values;
  44                 string[] readProperties;
  45                 string rawXml;
  46                 bool modified;
  47                 ElementMap map;
  48
  49                 protected ConfigurationElement ()
  50                 {
  51                         map = GetMap (GetType());
  52                 }
  53
  54                 internal string RawXml {
  55                         get { return rawXml; }
  56                         set { rawXml = value; }
  57                 }
  58
  59                 protected internal virtual ConfigurationPropertyCollection CollectionKeyProperties {
  60                         get {
  61                                 return map.KeyProperties;
  62                         }
  63                 }
  64
  65                 protected internal object this [ConfigurationProperty property] {
  66                         get {
  67                                 if (values == null || !values.ContainsKey (property)) {
  68                                         if (property.IsElement) {
  69                                                 object elem = Activator.CreateInstance (property.Type);
  70                                                 this [property] = elem;
  71                                                 return elem;
  72                                         }
  73                                         else
  74                                                 return property.DefaultValue;
  75                                 }
  76                                 else
  77                                         return values [property];
  78                         }
  79
  80                         set {
  81                                 if (object.Equals (value, property.DefaultValue)) {
  82                                         if (values == null) return;
  83                                         values.Remove (property);
  84                                 }
  85                                 else {
  86                                         if (values == null) values = new Hashtable ();
  87                                         values [property] = value;
  88                                 }
  89                                 modified = true;
  90                         }
  91                 }
  92
  93                 protected internal object this [string property_name] {
  94                         get {
  95                                 ConfigurationProperty prop = map.Properties [property_name];
  96                                 if (prop == null) throw new InvalidOperationException ("Property '" + property_name + "' not found in configuration section");
  97                                 return this [prop];
  98                         }
  99
 100                         set {
 101                                 ConfigurationProperty prop = map.Properties [property_name];
 102                                 if (prop == null) throw new InvalidOperationException ("Property '" + property_name + "' not found in configuration section");
 103                                 this [prop] = value;
 104                         }
 105                 }
 106
 107                 protected internal virtual ConfigurationPropertyCollection Properties {
 108                         get {
 109                                 return map.Properties;
 110                         }
 111                 }
 112
 113                 [MonoTODO]
 114                 public override bool Equals (object compareTo)
 115                 {
 116                         return base.Equals (compareTo);
 117                 }
 118
 119                 [MonoTODO]
 120                 public override int GetHashCode ()
 121                 {
 122                         return base.GetHashCode ();
 123                 }
 124
 125                 public bool HasValue (string key)
 126                 {
 127                         if (values == null) return false;
 128                         ConfigurationProperty prop = map.Properties [key];
 129                         if (prop == null) return false;
 130                         return values.ContainsKey (prop);
 131                 }
 132
 133                 internal bool HasValues ()
 134                 {
 135                         return values != null && values.Count > 0;
 136                 }
 137
 138                 [MonoTODO]
 139                 public string PropertyFileName ()
 140                 {
 141                         throw new NotImplementedException ();
 142                 }
 143
 144                 [MonoTODO]
 145                 public int PropertyLineNumber ()
 146                 {
 147                         throw new NotImplementedException ();
 148                 }
 149
 150                 [MonoTODO]
 151                 protected internal virtual void Deserialize (XmlReader reader, bool serializeCollectionKey)
 152                 {
 153                         Hashtable readProps = new Hashtable ();
 154
 155                         reader.MoveToContent ();
 156                         if (!map.HasProperties) {
 157                                 reader.Skip ();
 158                                 return;
 159                         }
 160
 161                         while (reader.MoveToNextAttribute ())
 162                         {
 163                                 ConfigurationProperty prop = map.Properties [reader.LocalName];
 164                                 if (prop == null) {
 165                                         if (!HandleUnrecognizedAttribute (reader.LocalName, reader.Value))
 166                                                 throw new ConfigurationException ("Unrecognized attribute '" + reader.LocalName + "'.");
 167                                         continue;
 168                                 }
 169
 170                                 if (readProps.Contains (prop))
 171                                         throw new ConfigurationException ("The attribute '" + prop.Name + "' may only appear once in this element.");
 172
 173                                 object val = prop.ConvertFromString (reader.Value);
 174                                 if (!object.Equals (val, prop.DefaultValue))
 175                                         this [prop] = val;
 176                                 readProps [prop] = prop.Name;
 177                         }
 178
 179                         reader.MoveToElement ();
 180                         if (reader.IsEmptyElement) {
 181                                 reader.Skip ();
 182                         }
 183                         else {
 184                                 reader.ReadStartElement ();
 185                                 reader.MoveToContent ();
 186
 187                                 while (reader.NodeType != XmlNodeType.EndElement)
 188                                 {
 189                                         if (reader.NodeType != XmlNodeType.Element) {
 190                                                 reader.Skip ();
 191                                                 continue;
 192                                         }
 193
 194                                         ConfigurationProperty prop = map.Properties [reader.LocalName];
 195                                         if (prop == null) {
 196                                                 if (!HandleUnrecognizedElement (reader.LocalName, reader))
 197                                                         throw new ConfigurationException ("Unrecognized element '" + reader.LocalName + "'.");
 198                                                 continue;
 199                                         }
 200
 201                                         if (!prop.IsElement)
 202                                                 throw new ConfigurationException ("Property '" + prop.Name + "' is not a ConfigurationElement.");
 203
 204                                         if (readProps.Contains (prop))
 205                                                 throw new ConfigurationException ("The element <" + prop.Name + "> may only appear once in this section.");
 206
 207                                         ConfigurationElement val = this [prop] as ConfigurationElement;
 208                                         val.Deserialize (reader, serializeCollectionKey);
 209                                         readProps [prop] = prop.Name;
 210                                 }
 211                         }
 212
 213                         modified = false;
 214
 215                         if (readProps.Count > 0) {
 216                                 readProperties = new string [readProps.Count];
 217                                 readProps.Values.CopyTo ((object[])readProperties, 0);
 218                         }
 219                 }
 220
 221                 protected virtual bool HandleUnrecognizedAttribute (string name, string value)
 222                 {
 223                         return false;
 224                 }
 225
 226                 protected virtual bool HandleUnrecognizedElement (string element, XmlReader reader)
 227                 {
 228                         return false;
 229                 }
 230
 231                 [MonoTODO]
 232                 protected internal virtual void InitializeDefault ()
 233                 {
 234                         values = null;
 235                 }
 236
 237                 protected internal virtual bool IsModified ()
 238                 {
 239                         return modified;
 240                 }
 241
 242                 [MonoTODO]
 243                 protected internal virtual void ReadXml (XmlReader reader, object context)
 244                 {
 245                         Deserialize (reader, false);
 246                 }
 247
 248                 [MonoTODO]
 249                 protected internal virtual void Reset (ConfigurationElement parent_element, object context)
 250                 {
 251                         if (parent_element != null) {
 252                                 if (!map.HasProperties) return;
 253                                 values = null;
 254                                 foreach (ConfigurationProperty prop in map.Properties) {
 255                                         if (parent_element.HasValue (prop.Name))
 256                                                 this [prop] = parent_element [prop.Name];
 257                                 }
 258                         }
 259                         else
 260                                 InitializeDefault ();
 261                 }
 262
 263                 protected internal virtual void ResetModified ()
 264                 {
 265                         modified = false;
 266                 }
 267
 268                 [MonoTODO ("Return value?")]
 269                 protected internal virtual bool Serialize (XmlWriter writer, bool serializeCollectionKey)
 270                 {
 271                         if (values == null || !map.HasProperties) return true;
 272
 273                         ArrayList elems = new ArrayList ();
 274                         foreach (DictionaryEntry entry in values)
 275                         {
 276                                 ConfigurationProperty prop = (ConfigurationProperty) entry.Key;
 277                                 if (serializeCollectionKey && !prop.IsKey) continue;
 278                                 if (prop.IsElement) continue;
 279
 280                                 if (!object.Equals (entry.Value, prop.DefaultValue))
 281                                         writer.WriteAttributeString (prop.Name, prop.ConvertToString (entry.Value));
 282                         }
 283                         if (serializeCollectionKey) return true;
 284
 285                         foreach (DictionaryEntry entry in values)
 286                         {
 287                                 ConfigurationProperty prop = (ConfigurationProperty) entry.Key;
 288                                 if (!prop.IsElement) continue;
 289
 290                                 ConfigurationElement val = entry.Value as ConfigurationElement;
 291                                 if (val != null && val.HasValues ())
 292                                         val.SerializeToXmlElement (writer, prop.Name);
 293                         }
 294                         return true;
 295                 }
 296
 297                 [MonoTODO]
 298                 protected internal virtual bool SerializeAttributeOnRemove (
 299                                 ConfigurationProperty property)
 300                 {
 301                         throw new NotImplementedException ();
 302                 }
 303
 304                 protected internal virtual bool SerializeToXmlElement (
 305                                 XmlWriter writer, string elementName)
 306                 {
 307                         writer.WriteStartElement (elementName);
 308                         Serialize (writer, false);
 309                         writer.WriteEndElement ();
 310                         return true;
 311                 }
 312
 313                 protected internal virtual void UnMerge (
 314                                 ConfigurationElement source, ConfigurationElement parent,
 315                                 bool serializeCollectionKey, object context,
 316                                 ConfigurationUpdateMode updateMode)
 317                 {
 318                         if (source.map != parent.map)
 319                                 throw new ConfigurationException ("Can't unmerge two elements of different type");
 320
 321                         ElementMap map = source.map;
 322                         if (!map.HasProperties) return;
 323
 324                         foreach (ConfigurationProperty prop in map.Properties)
 325                         {
 326                                 if (!source.HasValue (prop.Name)) continue;
 327
 328                                 object sourceValue = source [prop];
 329                                 if      (!parent.HasValue (prop.Name) || updateMode == ConfigurationUpdateMode.Full) {
 330                                         this [prop] = sourceValue;
 331                                         continue;
 332                                 }
 333                                 else if (sourceValue != null) {
 334                                         object parentValue = parent [prop];
 335                                         if (prop.IsElement) {
 336                                                 if (parentValue != null) {
 337                                                         ConfigurationElement copy = (ConfigurationElement) Activator.CreateInstance (prop.Type);
 338                                                         copy.UnMerge ((ConfigurationElement) sourceValue, (ConfigurationElement) parentValue, serializeCollectionKey, context, updateMode);
 339                                                         this [prop] = copy;
 340                                                 }
 341                                                 else
 342                                                         this [prop] = sourceValue;
 343                                         }
 344                                         else {
 345                                                 if (!object.Equals (sourceValue, parentValue) ||
 346                                                         (updateMode == ConfigurationUpdateMode.Modified && source.IsReadFromConfig (prop.Name)))
 347                                                         this [prop] = sourceValue;
 348                                         }
 349                                 }
 350                         }
 351                 }
 352
 353                 bool IsReadFromConfig (string propName)
 354                 {
 355                         return readProperties != null && Array.IndexOf (readProperties, propName) != -1;
 356                 }
 357
 358                 [MonoTODO]
 359                 protected virtual void ValidateRequiredProperties (
 360                                 ConfigurationPropertyCollection properties,
 361                                 bool serialize_collection_key)
 362                 {
 363                         throw new NotImplementedException ();
 364                 }
 365
 366                 protected internal virtual string WriteXml (
 367                                 ConfigurationElement parent,
 368                                 object context, string name,
 369                                 ConfigurationUpdateMode updateMode)
 370                 {
 371                         ConfigurationElement elem;
 372                         if (parent != null) {
 373                                 elem = (ConfigurationElement) Activator.CreateInstance (GetType());
 374                                 elem.UnMerge (this, parent, false, context, updateMode);
 375                         }
 376                         else
 377                                 elem = this;
 378
 379                         StringWriter sw = new StringWriter ();
 380                         XmlTextWriter tw = new XmlTextWriter (sw);
 381                         tw.Formatting = Formatting.Indented;
 382                         elem.SerializeToXmlElement (tw, name);
 383                         tw.Close ();
 384                         return sw.ToString ();
 385                 }
 386
 387                 internal static ElementMap GetMap (Type t)
 388                 {
 389                         lock (elementMaps) {
 390                                 ElementMap map = elementMaps [t] as ElementMap;
 391                                 if (map != null) return map;
 392
 393                                 if (typeof(ConfigurationElementCollection).IsAssignableFrom (t))
 394                                         map = new CollectionElementMap (t);
 395                                 else
 396                                         map = new ElementMap (t);
 397                                 elementMaps [t] = map;
 398                                 return map;
 399                         }
 400                 }
 401         }
 402
 403         internal class ElementMap
 404         {
 405                 ConfigurationPropertyCollection properties;
 406                 ConfigurationPropertyCollection keyProperties;
 407
 408                 public ElementMap (Type t)
 409                 {
 410                         ReflectProperties (t);
 411                 }
 412
 413                 protected void ReflectProperties (Type t)
 414                 {
 415                         PropertyInfo[] props = t.GetProperties ();
 416                         foreach (PropertyInfo prop in props)
 417                         {
 418                                 ConfigurationPropertyAttribute at = (ConfigurationPropertyAttribute) Attribute.GetCustomAttribute (prop, typeof(ConfigurationPropertyAttribute)) as ConfigurationPropertyAttribute;
 419                                 if (at == null) continue;
 420                                 string name = at.Name != null ? at.Name : prop.Name;
 421
 422                                 ConfigurationValidationAttribute validator = (ConfigurationValidationAttribute) Attribute.GetCustomAttribute (t, typeof(ConfigurationValidationAttribute)) as ConfigurationValidationAttribute;
 423                                 TypeConverter converter = TypeDescriptor.GetConverter (prop.PropertyType);
 424                                 ConfigurationProperty cp = new ConfigurationProperty (name, prop.PropertyType, at.DefaultValue, converter, validator, at.Flags);
 425
 426                                 if (properties == null) properties = new ConfigurationPropertyCollection ();
 427                                 properties.Add (cp);
 428                         }
 429                 }
 430
 431                 public bool HasProperties
 432                 {
 433                         get { return properties != null && properties.Count > 0; }
 434                 }
 435
 436                 public ConfigurationPropertyCollection Properties
 437                 {
 438                         get {
 439                                 if (properties == null) properties = new ConfigurationPropertyCollection ();
 440                                 return properties;
 441                         }
 442                 }
 443
 444                 public ConfigurationPropertyCollection KeyProperties {
 445                         get {
 446                                 if (keyProperties == null) {
 447                                         keyProperties = new ConfigurationPropertyCollection ();
 448
 449                                         if (properties != null)
 450                                                 foreach (ConfigurationProperty p in properties)
 451                                                         if (p.IsKey) keyProperties.Add (p);
 452                                 }
 453                                 return keyProperties;
 454                         }
 455                 }
 456         }
 457
 458         internal class CollectionElementMap: ElementMap
 459         {
 460                 public CollectionElementMap (Type t): base (t)
 461                 {
 462                 }
 463         }
 464 }
 465
 466 #endif
 467 #endif