Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Configuration/System/Configuration/ConfigurationValues.cs

@@ -0,0 +1,301 @@
+//------------------------------------------------------------------------------
+// <copyright file="ConfigurationValues.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+using System;
+using System.Configuration.Internal;
+using System.Collections;
+using System.Collections.Specialized;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using System.Security.Permissions;
+using System.Xml;
+using System.Globalization;
+using System.ComponentModel;
+using System.Security;
+using System.Text;
+
+namespace System.Configuration {
+
+    internal class ConfigurationValues : NameObjectCollectionBase {
+        private BaseConfigurationRecord _configRecord;
+        private volatile bool _containsElement;
+        private volatile bool _containsInvalidValue;
+
+        internal ConfigurationValues() : base(StringComparer.Ordinal) {
+        }
+
+        // AssociateContext
+        //
+        // Associate a collection of values with a configRecord
+        //
+        internal void AssociateContext(BaseConfigurationRecord configRecord) {
+            _configRecord = configRecord;
+
+            // Associate with children
+            foreach (ConfigurationElement currentElement in ConfigurationElements) {
+                currentElement.AssociateContext(_configRecord);
+            }
+        }
+
+        internal bool Contains(string key) {
+            return (BaseGet(key) != null);
+        }
+
+        internal string GetKey(int index) {
+            return BaseGetKey(index);
+        }
+
+        /*
+        internal ConfigurationValue GetConfigValue(int index)
+        {
+            return (ConfigurationValue)BaseGet(BaseGetKey(index));
+        }
+        */
+
+        internal ConfigurationValue GetConfigValue(string key) {
+            return (ConfigurationValue)BaseGet(key);
+        }
+
+        internal ConfigurationValue GetConfigValue(int index) {
+            return (ConfigurationValue)BaseGet(index);
+        }
+
+        internal PropertySourceInfo GetSourceInfo(string key) {
+            ConfigurationValue configurationValue = GetConfigValue(key);
+            if (configurationValue != null) {
+                return configurationValue.SourceInfo;
+            }
+            else {
+                return null;
+            }
+        }
+
+        internal void ChangeSourceInfo(string key, PropertySourceInfo sourceInfo) {
+            ConfigurationValue configurationValue = GetConfigValue(key);
+            if (configurationValue != null) {
+                configurationValue.SourceInfo = sourceInfo;
+            }
+        }
+
+        private ConfigurationValue CreateConfigValue(object value, ConfigurationValueFlags valueFlags, PropertySourceInfo sourceInfo) {
+            if (value != null) {
+                if (value is ConfigurationElement) {
+                    _containsElement = true;
+                    ((ConfigurationElement)value).AssociateContext(_configRecord);
+                }
+                else if (value is InvalidPropValue) {
+                    _containsInvalidValue = true;
+                }
+            }
+
+            ConfigurationValue configValue = new ConfigurationValue(value, valueFlags, sourceInfo);
+            return configValue;
+        }
+
+        internal void SetValue(string key, object value, ConfigurationValueFlags valueFlags, PropertySourceInfo sourceInfo) {
+            ConfigurationValue configValue = CreateConfigValue(value, valueFlags, sourceInfo);
+            BaseSet(key, configValue);
+        }
+
+#if UNUSED_CODE
+        private void SetValue(int index, object value, ConfigurationValueFlags valueFlags, PropertySourceInfo sourceInfo) {
+            ConfigurationValue configValue = CreateConfigValue(value, valueFlags, sourceInfo);
+            BaseSet(index, configValue);
+        }
+#endif
+
+        internal object this[string key] {
+            get {
+                ConfigurationValue configValue = GetConfigValue(key);
+                if (configValue != null) {
+                    return configValue.Value;
+                }
+                else {
+                    return null;
+                }
+            }
+            set {
+                SetValue(key, value, ConfigurationValueFlags.Modified, null);
+            }
+        }
+
+        internal object this[int index] {
+            get {
+                ConfigurationValue configValue = GetConfigValue(index);
+                if (configValue != null) {
+                    return configValue.Value;
+                }
+                else {
+                    return null;
+                }
+            }
+
+#if UNUSED_CODE
+            set {
+                SetValue(index, value, ConfigurationValueFlags.Modified, null);
+            }
+#endif
+        }
+
+        internal void Clear() {
+            BaseClear();
+        }
+
+        internal object SyncRoot { get { return this; } }
+
+        internal ConfigurationValueFlags RetrieveFlags(string key) {
+            ConfigurationValue configurationValue = (ConfigurationValue)BaseGet(key);
+            if (configurationValue != null) {
+                return configurationValue.ValueFlags;
+            }
+            else {
+                return ConfigurationValueFlags.Default;
+            }
+        }
+
+        internal bool IsModified(string key) {
+            ConfigurationValue configurationValue = (ConfigurationValue)BaseGet(key);
+            if (configurationValue != null) {
+                return ((configurationValue.ValueFlags & ConfigurationValueFlags.Modified) != 0);
+            }
+            else {
+                return false;
+            }
+        }
+
+        internal bool IsInherited(string key) {
+            ConfigurationValue configurationValue = (ConfigurationValue)BaseGet(key);
+            if (configurationValue != null) {
+                return ((configurationValue.ValueFlags & ConfigurationValueFlags.Inherited) != 0);
+            }
+            else {
+                return false;
+            }
+
+        }
+
+        internal IEnumerable ConfigurationElements {
+            get {
+                if (_containsElement) {
+                    return new ConfigurationElementsCollection(this);
+                }
+                else {
+                    return EmptyCollectionInstance;
+                }
+            }
+        }
+
+        internal IEnumerable InvalidValues {
+            get {
+                if (_containsInvalidValue) {
+                    return new InvalidValuesCollection(this);
+                }
+                else {
+                    return EmptyCollectionInstance;
+                }
+            }
+        }
+
+        static volatile IEnumerable s_emptyCollection;
+        static IEnumerable EmptyCollectionInstance {
+            get {
+                if (s_emptyCollection == null) {
+                    s_emptyCollection = new EmptyCollection();
+                }
+
+                return s_emptyCollection;
+            }
+        }
+
+        private class EmptyCollection : IEnumerable {
+            IEnumerator _emptyEnumerator;
+
+            private class EmptyCollectionEnumerator : IEnumerator {
+                bool IEnumerator.MoveNext() {
+                    return false;
+                }
+
+                Object IEnumerator.Current {
+                    get {
+                        return null;
+                    }
+                }
+
+                void IEnumerator.Reset() {
+                }
+            }
+
+            internal EmptyCollection() {
+                _emptyEnumerator = new EmptyCollectionEnumerator();
+            }
+
+            IEnumerator IEnumerable.GetEnumerator() {
+                return _emptyEnumerator;
+            }
+        }
+
+        private class ConfigurationElementsCollection : IEnumerable {
+            ConfigurationValues _values;
+
+            internal ConfigurationElementsCollection(ConfigurationValues values) {
+                _values = values;
+            }
+
+            IEnumerator IEnumerable.GetEnumerator() {
+                if (_values._containsElement) {
+                    for (int index = 0; index < _values.Count; index++) {
+                        object value = _values[index];
+                        if (value is ConfigurationElement) {
+                            yield return value;
+                        }
+                    }
+                }
+            }
+        }
+
+        private class InvalidValuesCollection : IEnumerable {
+            ConfigurationValues _values;
+
+            internal InvalidValuesCollection(ConfigurationValues values) {
+                _values = values;
+            }
+
+            IEnumerator IEnumerable.GetEnumerator() {
+                if (_values._containsInvalidValue) {
+                    for (int index = 0; index < _values.Count; index++) {
+                        object value = _values[index];
+                        if (value is InvalidPropValue) {
+                            yield return value;
+                        }
+                    }
+                }
+            }
+        }
+
+        /* 
+        internal bool IsLocked(string key)
+        {
+            ConfigurationValue configurationValue = (ConfigurationValue)BaseGet(key);
+            if (configurationValue != null)
+                return ((configurationValue.ValueFlags & ConfigurationValueFlags.Locked) != 0);
+            else
+                return false;
+
+        }
+        internal bool IsReadOnly(string key)
+        {
+            ConfigurationValue configurationValue = (ConfigurationValue)BaseGet(key);
+            if (configurationValue != null)
+                return ((configurationValue.ValueFlags & ConfigurationValueFlags.ReadOnly) != 0);
+            else
+                return false;
+
+        }
+        */
+
+    }
+}