graph chart引入&骑行结果弹窗

Assets/Chart And Graph/Script/DataSource/ChartDataSourceBaseCollection.cs

@@ -0,0 +1,215 @@
+#define Graph_And_Chart_PRO
+using ChartAndGraph.DataSource;
+using ChartAndGraph.Exceptions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ChartAndGraph
+{
+    /// <summary>
+    /// base class for all data source collections. (row and column collections)
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public abstract class ChartDataSourceBaseCollection<T> : ICollection<T> where T : class,IDataItem
+    {
+        Dictionary<string, T> mNameToItem = new Dictionary<string, T>();
+        List<T> mItems = new List<T>();
+
+        /// <summary>
+        /// Used for messages and exceptions. this can be "column" if the derived class represents a column collestion
+        /// </summary>
+        protected abstract string ItemTypeName {get;}
+
+        /// <summary>
+        /// Adds an item to the last index of the collection. throws and exception if an item by that name already exists
+        /// </summary>
+        /// <param name="item">the new item to add</param>
+        public void Add(T item)
+        {
+            Insert(mItems.Count, item); // call insert
+        }
+
+        public void SwitchPositions(string first, string second)
+        {
+            int firstIndex, secondIndex;
+            if (TryGetIndexByName(first, out firstIndex) == false)
+                throw new ChartItemNotExistException(String.Format("A {0} by the name {1} does not exist in the collection", ItemTypeName, first));
+            if (TryGetIndexByName(second, out secondIndex) == false)
+                throw new ChartItemNotExistException(String.Format("A {0} by the name {1} does not exist in the collection", ItemTypeName, second));
+            SwitchPositions(firstIndex, secondIndex);
+        }
+
+        public void SwitchPositions(int first,int second)
+        {
+            T tmp = mItems[first];
+            mItems[first] = mItems[second];
+            mItems[second] = tmp;
+            if(ItemsReplaced != null)
+                ItemsReplaced(mItems[first].Name, first, mItems[second].Name, second);
+        }
+
+        public void Move(string name,int newPosition)
+        {
+            if (newPosition >= Count || newPosition<0)
+                throw new IndexOutOfRangeException();
+            int currentPosition;
+            if(TryGetIndexByName(name, out currentPosition) == false)
+                throw new ChartItemNotExistException(String.Format("A {0} by the name {1} does not exist in the collection", ItemTypeName, name));
+            int advance = Math.Sign(newPosition - currentPosition);
+            if (advance == 0) // same position
+                return;
+            for(int i=currentPosition; i!=newPosition; i+=advance)
+                SwitchPositions(i, i + advance);
+        }
+        public bool TryGetIndexByName(string name,out int result)
+        {
+            for(int i=0; i<mItems.Count; ++i)
+            {
+                if (mItems[i].Name == name)
+                {
+                    result = i;
+                    return true;
+                }
+            }
+            result = -1;
+            return false;
+        }
+        /// <summary>
+        /// inserts and item at the specified index of the collection. throws and exception if an item by that name already exists
+        /// </summary>
+        /// <param name="item">the new item to add</param>
+        public void Insert(int index, T item)
+        {
+            if( item == null)
+                throw new ArgumentNullException("item argument can't be null");
+            if (item.Name != null)
+            {
+                if (mNameToItem.ContainsKey(item.Name))
+                    throw new ChartDuplicateItemException(String.Format("A {0} by that name already exists in the data source", ItemTypeName));
+            }
+            // check if it already contained in the collection
+            if (mItems.Contains(item) == true)
+                throw new ChartDuplicateItemException(String.Format("The {0} is already added to the collection", ItemTypeName));
+            // insert the item
+            mItems.Insert(index, item);
+            item.NameChanged += NameChangedHandler;
+            if (item.Name != null) // make sure the name to index points to it
+                mNameToItem.Add(item.Name, item);
+            if (OrderChanged != null)
+                OrderChanged(this, EventArgs.Empty);
+        }
+
+#pragma warning disable 0067
+        public event Action<string, IDataItem> NameChanged;
+        public event EventHandler OrderChanged;
+        public event Action<T> ItemRemoved;
+        public event Action<string, int, string, int> ItemsReplaced;
+
+#pragma warning restore 0067
+
+        public T this[int index]
+        {
+            get
+            {
+                return mItems[index];
+            }
+        }
+
+        public T this[string name]
+        {
+            get
+            {
+                T res;
+                if (mNameToItem.TryGetValue(name, out res) == false)
+                    throw new ChartItemNotExistException(String.Format("A {0} by the name {1} does not exist in the collection", ItemTypeName, name));
+                return res;
+            }
+        }
+
+        private void NameChangedHandler(string prevName,IDataItem item)
+        {
+            if (prevName == item.Name) // ignore identical names
+                return;
+            if (mNameToItem.ContainsKey(item.Name)) // check duplicate names
+            {
+                item.CancelNameChange();
+                throw new ChartDuplicateItemException(String.Format("A {0} by that name already exists in the data source", ItemTypeName));
+            }
+
+            if(prevName != null && mNameToItem.Remove(prevName) == false)
+            {
+                item.CancelNameChange();
+                throw new ChartException(String.Format("Renaming {0} failed", ItemTypeName));
+            }
+            if(item.Name != null)
+                mNameToItem.Add(item.Name, (T)item);
+            if (NameChanged != null)
+                NameChanged(prevName, item);
+        }
+
+        /// <summary>
+        /// clear the collection
+        /// </summary>
+        public void Clear()
+        {
+            foreach (T item in mItems)
+            {
+                item.NameChanged -= NameChangedHandler;
+                if (ItemRemoved != null)
+                    ItemRemoved(item);
+            }
+            mItems.Clear(); // call the corresponding list method
+            mNameToItem.Clear(); // and clear the name to index dictionary
+            if (OrderChanged != null)
+                OrderChanged(this, EventArgs.Empty);
+        }
+
+        public bool Contains(T item)
+        {
+            return mItems.Contains(item); // call the corresponding list method
+        }
+
+        public void CopyTo(T[] array, int arrayIndex)
+        {
+            mItems.CopyTo(array, arrayIndex); // call the corresponding list method
+        }
+
+        public int Count
+        {
+            get { return mItems.Count; } // call the corresponding list method
+        }
+
+        public bool IsReadOnly
+        {
+            get { return false;}
+        }
+
+        public bool Remove(T item)
+        {
+            if(mItems.Remove(item) == true) // remove the item from the list
+            {
+                if(item.Name != null)   // remove name to index
+                    mNameToItem.Remove(item.Name);
+                item.NameChanged -= NameChangedHandler; // remove event handler for name change
+                if (ItemRemoved != null)
+                    ItemRemoved(item);
+                if (OrderChanged != null)
+                    OrderChanged(this, EventArgs.Empty);
+                return true;
+            }
+            return false;
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            return mItems.GetEnumerator(); // call the corresponding list method
+        }
+
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return mItems.GetEnumerator(); // call the corresponding list method
+        }
+    }
+}