//******************************************************************************************************//  ImmutableList`1.cs - Gbtc////  Copyright © 2016, Grid Protection Alliance.  All Rights Reserved.////  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See//  the NOTICE file distributed with this work for additional information regarding copyright ownership.//  The GPA licenses this file to you under the Eclipse Public License -v 1.0 (the "License"); you may//  not use this file except in compliance with the License. You may obtain a copy of the License at:////      http://www.opensource.org/licenses/eclipse-1.0.php////  Unless agreed to in writing, the subject software distributed under the License is distributed on an//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the//  License for the specific language governing permissions and limitations.////  Code Modification History://  ----------------------------------------------------------------------------------------------------//  10/24/2016 - Steven E. Chisholm//       Generated original version of source code. //       ////****************************************************************************************************** using System;using System.Collections;using System.Collections.Generic; namespace GSF.Immutable{    /// <summary>    /// A list that can be modified until <see cref="ImmutableObjectBase{T}.IsReadOnly"/> is set to true. Once this occurs,    /// the list itself can no longer be modified.  Remember, this does not cause objects contained in this class to be Immutable     /// unless they implement <see cref="IImmutableObject"/>.    /// </summary>    /// <typeparam name="T"></typeparam>    public class ImmutableList<T>        : ImmutableObjectBase<ImmutableList<T>>, IList<T>    {        private readonly bool m_isISupportsReadonlyType;        private List<T> m_list;        private Func<T, T> m_formatter;         /// <summary>        /// Creates a new <see cref="ImmutableList{TKey}"/>.        /// </summary>        /// <param name="formatter">Allows items to be formatted when inserted into a list.</param>        public ImmutableList(Func<T, T> formatter = null)        {            m_formatter = formatter;            m_isISupportsReadonlyType = typeof(IImmutableObject).IsAssignableFrom(typeof(T));            m_list = new List<T>();        }         /// <summary>        /// Creates a new <see cref="ImmutableList{TKey}"/>.        /// </summary>        public ImmutableList(int capacity, Func<T, T> formatter = null)        {            m_formatter = formatter;            m_isISupportsReadonlyType = typeof(IImmutableObject).IsAssignableFrom(typeof(T));            m_list = new List<T>(capacity);        }         /// <summary>Returns an enumerator that iterates through the collection.</summary>        /// <returns>A <see cref="T:System.Collections.Generic.IEnumerator`1" /> that can be used to iterate through the collection.</returns>        /// <filterpriority>1</filterpriority>        public IEnumerator<T> GetEnumerator()        {            return m_list.GetEnumerator();        }         /// <summary>Returns an enumerator that iterates through a collection.</summary>        /// <returns>An <see cref="T:System.Collections.IEnumerator" /> object that can be used to iterate through the collection.</returns>        /// <filterpriority>2</filterpriority>        IEnumerator IEnumerable.GetEnumerator()        {            return ((IEnumerable)m_list).GetEnumerator();        }         /// <summary>Adds an item to the <see cref="T:System.Collections.Generic.ICollection`1" />.</summary>        /// <param name="item">The object to add to the <see cref="T:System.Collections.Generic.ICollection`1" />.</param>        /// <exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.ICollection`1" /> is read-only.</exception>        public void Add(T item)        {            TestForEditable();            if (m_formatter == null)            {                m_list.Add(item);            }            else            {                m_list.Add(m_formatter(item));            }        }         /// <summary>        /// Adds the elements of the specified collection to the end of the <see cref="T:System.Collections.Generic.List`1"/>.        /// </summary>        /// <param name="collection">The collection whose elements should be added to the end of the <see cref="T:System.Collections.Generic.List`1"/>.         /// The collection itself cannot be null, but it can contain elements that are null</param>        public void AddRange(IEnumerable<T> collection)        {            TestForEditable();            if (m_formatter != null)            {                foreach (var item in collection)                {                    m_list.Add(m_formatter(item));                }                return;            }            m_list.AddRange(collection);        }         /// <summary>Removes all items from the collection.</summary>        public void Clear()        {            TestForEditable();            m_list.Clear();        }         /// <summary>Determines whether the <see cref="T:System.Collections.Generic.ICollection`1" /> contains a specific value.</summary>        /// <returns>true if <paramref name="item" /> is found in the <see cref="T:System.Collections.Generic.ICollection`1" />; otherwise, false.</returns>        /// <param name="item">The object to locate in the <see cref="T:System.Collections.Generic.ICollection`1" />.</param>        public bool Contains(T item)        {            return m_list.Contains(item);        }         /// <summary>Copies the elements of the <see cref="T:System.Collections.Generic.ICollection`1" /> to an <see cref="T:System.Array" />, starting at a particular <see cref="T:System.Array" /> index.</summary>        /// <param name="array">The one-dimensional <see cref="T:System.Array" /> that is the destination of the elements copied from <see cref="T:System.Collections.Generic.ICollection`1" />. The <see cref="T:System.Array" /> must have zero-based indexing.</param>        /// <param name="arrayIndex">The zero-based index in <paramref name="array" /> at which copying begins.</param>        public void CopyTo(T[] array, int arrayIndex)        {            m_list.CopyTo(array, arrayIndex);        }         /// <summary>Removes the first occurrence of a specific object from the <see cref="T:System.Collections.Generic.ICollection`1" />.</summary>        /// <returns>true if <paramref name="item" /> was successfully removed from the <see cref="T:System.Collections.Generic.ICollection`1" />; otherwise, false. This method also returns false if <paramref name="item" /> is not found in the original <see cref="T:System.Collections.Generic.ICollection`1" />.</returns>        /// <param name="item">The object to remove from the <see cref="T:System.Collections.Generic.ICollection`1" />.</param>        public bool Remove(T item)        {            TestForEditable();            return m_list.Remove(item);        }         /// <summary>Gets the number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1" />.</summary>        /// <returns>The number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1" />.</returns>        public int Count        {            get            {                return m_list.Count;            }        }         /// <summary>        /// Requests that member fields be set to readonly.         /// </summary>        protected override void SetMembersAsReadOnly()        {            if (m_isISupportsReadonlyType)            {                for (int x = 0; x < m_list.Count; x++)                {                    var item = ((IImmutableObject)m_list[x]);                    if (item != null)                    {                        item.IsReadOnly = true;                    }                }            }        }         /// <summary>        /// Request that member fields be cloned and marked as editable.        /// </summary>        protected override void CloneMembersAsEditable()        {            if (m_isISupportsReadonlyType)            {                List<T> oldList = m_list;                m_list = new List<T>(oldList.Count);                for (int x = 0; x < oldList.Count; x++)                {                    var item = ((IImmutableObject)oldList[x]);                    if (item == null)                    {                        m_list.Add(default(T));                    }                    else                    {                        m_list.Add((T)item.CloneEditable());                    }                }            }            else            {                m_list = new List<T>(m_list);            }        }         /// <summary>Determines the index of a specific item in the <see cref="T:System.Collections.Generic.IList`1" />.</summary>        /// <returns>The index of <paramref name="item" /> if found in the list; otherwise, -1.</returns>        /// <param name="item">The object to locate in the <see cref="T:System.Collections.Generic.IList`1" />.</param>        public int IndexOf(T item)        {            return m_list.IndexOf(item);        }         /// <summary>Inserts an item to the <see cref="T:System.Collections.Generic.IList`1" /> at the specified index.</summary>        /// <param name="index">The zero-based index at which <paramref name="item" /> should be inserted.</param>        /// <param name="item">The object to insert into the <see cref="T:System.Collections.Generic.IList`1" />.</param>        public void Insert(int index, T item)        {            TestForEditable();            if (m_formatter == null)            {                m_list.Insert(index, item);            }            else            {                m_list.Insert(index, m_formatter(item));            }        }         /// <summary>Removes the <see cref="T:System.Collections.Generic.IList`1" /> item at the specified index.</summary>        /// <param name="index">The zero-based index of the item to remove.</param>        public void RemoveAt(int index)        {            TestForEditable();            m_list.RemoveAt(index);        }         /// <summary>Gets or sets the element at the specified index.</summary>        /// <returns>The element at the specified index.</returns>        /// <param name="index">The zero-based index of the element to get or set.</param>        public T this[int index]        {            get            {                return m_list[index];            }            set            {                TestForEditable();                if (m_formatter == null)                {                    m_list[index] = value;                }                else                {                    m_list[index] = m_formatter(value);                }            }        }    }}