linux-packaging-mono/mcs/class/referencesource/System.Configuration/System/Configuration/ProviderSettings.cs

//------------------------------------------------------------------------------
// <copyright file="ProviderSettings.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------

namespace System.Configuration
{
    using System;
    using System.Xml;
    using System.Configuration;
    using System.Collections.Specialized;
    using System.Collections;
    using System.IO;
    using System.Text;
    using System.Globalization;

    public sealed class ProviderSettings : ConfigurationElement
    {
        private readonly ConfigurationProperty _propName =
            new ConfigurationProperty(  "name",
                                        typeof( string ),
                                        null,   // no reasonable default
                                        null,   // use default converter
                                        ConfigurationProperty.NonEmptyStringValidator,
                                        ConfigurationPropertyOptions.IsRequired | ConfigurationPropertyOptions.IsKey);
        private readonly ConfigurationProperty _propType = new ConfigurationProperty("type", typeof(String), "",
                                                                                     ConfigurationPropertyOptions.IsRequired | ConfigurationPropertyOptions.IsTypeStringTransformationRequired);
        private ConfigurationPropertyCollection _properties;
        private NameValueCollection _PropertyNameCollection = null;
        public ProviderSettings()
        {
            _properties = new ConfigurationPropertyCollection();
            _properties.Add(_propName);
            _properties.Add(_propType);
            _PropertyNameCollection = null;
        }
        public ProviderSettings(String name, String type) : this()
        {
            Name = name;
            Type = type;
        }

        protected internal override ConfigurationPropertyCollection Properties
        {
            get
            {
                UpdatePropertyCollection();
                return _properties;
            }
        }

        protected internal override void Unmerge(ConfigurationElement sourceElement,
                                                ConfigurationElement parentElement,
                                                ConfigurationSaveMode saveMode)
        {
            ProviderSettings parentProviders = parentElement as ProviderSettings;
            if (parentProviders != null)
                parentProviders.UpdatePropertyCollection(); // before reseting make sure the bag is filled in

            ProviderSettings sourceProviders = sourceElement as ProviderSettings;
            if (sourceProviders != null)
                sourceProviders.UpdatePropertyCollection(); // before reseting make sure the bag is filled in

            base.Unmerge(sourceElement, parentElement, saveMode);
            UpdatePropertyCollection();
        }

        protected internal override void Reset(ConfigurationElement parentElement)
        {
            ProviderSettings parentProviders = parentElement as ProviderSettings;
            if (parentProviders != null)
                parentProviders.UpdatePropertyCollection(); // before reseting make sure the bag is filled in

            base.Reset(parentElement);
        }

        internal bool UpdatePropertyCollection()
        {
            bool bIsModified = false;
            ArrayList removeList = null;

            if (_PropertyNameCollection != null)
            {
                // remove any data that has been delete from the collection
                foreach (ConfigurationProperty prop in _properties)
                {
                    if (prop.Name != "name" && prop.Name != "type")
                    {
                        if (_PropertyNameCollection.Get(prop.Name) == null)
                        {
                            // _properties.Remove(prop.Name);
                            if (removeList == null)
                                removeList = new ArrayList();

                            if ((Values.GetConfigValue(prop.Name).ValueFlags & ConfigurationValueFlags.Locked) == 0) {
                                removeList.Add(prop.Name);
                                bIsModified = true;
                            }
                        }
                    }
                }

                if (removeList != null)
                {
                    foreach (string propName in removeList)
                    {
                        _properties.Remove(propName);
                    }
                }

                // then copy any data that has been changed in the collection
                foreach (string Key in _PropertyNameCollection)
                {
                    string valueInCollection = _PropertyNameCollection[Key];
                    string valueInBag = GetProperty(Key);

                    if (valueInBag == null || valueInCollection != valueInBag) // add new property
                    {
                        SetProperty(Key, valueInCollection);
                        bIsModified = true;
                    }
                }
            }
            _PropertyNameCollection = null;
            return bIsModified;
        }

        protected internal override bool IsModified()
        {
            return UpdatePropertyCollection() || base.IsModified();
        }

        [ConfigurationProperty("name", IsRequired = true, IsKey=true)]
        public String Name
        {
            get
            {
                return (String)base[_propName];
            }
            set
            {
                base[_propName] = value;
            }
        }

        [ConfigurationProperty("type", IsRequired = true)]
        public String Type
        {
            get
            {
                return (String)base[_propType];
            }
            set
            {
                base[_propType] = value;
            }
        }

        public NameValueCollection Parameters
        {
            get
            {
                if (_PropertyNameCollection == null)
                {
                    lock (this)
                    {
                        if (_PropertyNameCollection == null)
                        {
                            _PropertyNameCollection = new NameValueCollection(StringComparer.Ordinal);

                            foreach (object de in _properties)
                            {
                                ConfigurationProperty prop = (ConfigurationProperty)de;
                                if (prop.Name != "name" && prop.Name != "type")
                                    _PropertyNameCollection.Add(prop.Name, (string)base[prop]);
                            }
                        }
                    }
                }
                return (NameValueCollection)_PropertyNameCollection;
            }
        }


        private string GetProperty(string PropName)
        {
            if (_properties.Contains(PropName))
            {
                ConfigurationProperty prop = _properties[PropName];
                if(prop != null)
                    return (string)base[prop];
            }
            return null;
        }

        private bool SetProperty(string PropName,string value)
        {
            ConfigurationProperty SetPropName = null;
            if (_properties.Contains(PropName))
                SetPropName = _properties[PropName];
            else
            {
                SetPropName = new ConfigurationProperty(PropName, typeof(string), null);
                _properties.Add(SetPropName);
            }
            if (SetPropName != null)
            {
                base[SetPropName] = value;
//                Parameters[PropName] = value;
                return true;
            }
            else
                return false;
        }

        protected override bool OnDeserializeUnrecognizedAttribute(String name, String value)
        {
            ConfigurationProperty _propName = new ConfigurationProperty(name, typeof(string), value);
            _properties.Add(_propName);
            base[_propName] = value; // Add them to the property bag
            Parameters[name] = value;
            return true;
        }

    }
}