keyedcollection.cs

Fireball.CodeEditor is an source code editor control derived from the best compona SyntaxBox Control

            _readonlyColl = null;
        }

        #endregion

        #region Public Properties

        public T this[int index]
        {
            get
            {
                return _items[index];
            }
            set
            {
                _items[index] = value;
            }
        }
        public T this[string key]
        {
            get
            {
                return _items[_keys.IndexOf(key)];
            }
            set
            {
                _items[_keys.IndexOf(key)] = value;
            }
        }

        public LightCollection<T> Collection
        {
            get
            {
                return _items;
            }
        }
        public int Count
        {
            get
            {
                return _items.Count;
            }
        }
        public string[] Keys
        {
            get
            {
                return _keys.GetItems();
            }
        }
        public virtual ReadOnlyKeyedCollection<T> ReadOnlyCollection
        {
            get
            {
                if (_readonlyColl == null) _readonlyColl = new ReadOnlyKeyedCollection<T>(this);
                return _readonlyColl;
            }
        }

        #endregion

        #region Public Methods

        public virtual void Add(string key, T item)
        {
            if (_keys.Contains(key))
            {
                throw new Exception("Key already exist");
            }
            _keys.Add(key);
            int index = _items.Add(item);

            if (ItemAdd != null) ItemAdd(this, new KeyedCollectionAddEventArgs(_items[index], index, _keys[index]));
            if (CollectionChanged != null) CollectionChanged(this, new EventArgs());
        }
        public virtual void AddRange(KeyedCollection<T> items)
        {
            if (items == null) return;

            AddRange(items.Keys, items.GetItems());
        }
        public virtual void AddRange(string[] keys, T[] items)
        {
            if (keys.Length != items.Length)
            {
                throw new Exception(" ");
            }

            int startIndex = _items.Count;

            _keys.AddRange(keys);
            _items.AddRange(items);

            if (ItemAddRange != null) ItemAddRange(this, new KeyedCollectionAddRangeEventArgs(items, keys, startIndex));
            if (CollectionChanged != null) CollectionChanged(this, new EventArgs());
        }
        public virtual void Clear()
        {
            _items.Clear();
            _keys.Clear();

            if (CollectionClear != null) CollectionClear(this, new EventArgs());
            if (CollectionChanged != null) CollectionChanged(this, new EventArgs());
        }
        public virtual bool Contains(T item)
        {
            return _items.Contains(item);
        }
        public virtual bool ContainsKey(string key)
        {
            return _keys.Contains(key);
        }
        public virtual string CreateFreeKey()
        {
            string key = "";
            do
            {
                key = Guid.NewGuid().ToString().Substring(0, 8);
            }
            while (_keys.Contains(key));
            return key;
        }
        public KeyedCollection<T>.Enumerator GetEnumerator()
        {
            return new KeyedCollection<T>.Enumerator(this);
        }
        //public IEnumerator<T> GetEnumerator()
        //{
        //    return new KeyedCollection<T>.Enumerator(this);
        //}
        public virtual T[] GetItems()
        {
            if (_items.Count <= 0) return new T[0];
            return _items.GetItems();
        }
        public virtual T[] GetItems(int startIndex)
        {
            if (_items.Count <= 0) return new T[0];
            return _items.GetItems(startIndex);
        }
        public virtual T[] GetItems(int startIndex, int finalIndex)
        {
            if (_items.Count <= 0) return new T[0];
            return _items.GetItems(startIndex, finalIndex);
        }
        public virtual int IndexOfKey(string key)
        {
            return _keys.IndexOf(key);
        }
        public virtual int IndexOf(T item)
        {
            return _items.IndexOf(item);
        }
        public virtual void Insert(int index, string key, T item)
        {
            if (_keys.Contains(key))
            {
                throw new Exception("Key already exist");
            }
            _keys.Insert(index, key);
            _items.Insert(index, item);

            if (ItemAdd != null) ItemAdd(this, new KeyedCollectionAddEventArgs(_items[index], index, _keys[index]));
            if (CollectionChanged != null) CollectionChanged(this, new EventArgs());
        }
        public virtual void MoveByIndex(int index, int newIndex)
        {
            _items.MoveByIndex(index, newIndex);
            _keys.MoveByIndex(index, newIndex);

            if (ItemMove != null) ItemMove(this, new KeyedCollectionMoveEventArgs(_items[newIndex], newIndex, index, _keys[newIndex]));
            if (CollectionChanged != null) CollectionChanged(this, new EventArgs());

        }
        public virtual void Move(T item, int newIndex)
        {
            int index = this.IndexOf(item);
            MoveByIndex(index, newIndex);
        }
        public virtual void RemoveAt(int index)
        {
            T removedItem = _items[index];
            string removedKey = _keys[index];

            _items.RemoveAt(index);
            _keys.RemoveAt(index);

            if (ItemRemove != null) ItemRemove(this, new KeyedCollectionRemoveEventArgs(removedItem, removedKey, index));
            if (CollectionChanged != null) CollectionChanged(this, new EventArgs());
        }
        public virtual void RemoveByKey(string key)
        {
            int index = _keys.IndexOf(key);
            T removedItem = _items[index];
            _items.RemoveAt(index);
            _keys.RemoveAt(index);

            if (ItemRemove != null) ItemRemove(this, new KeyedCollectionRemoveEventArgs(removedItem, key, index));
            if (CollectionChanged != null) CollectionChanged(this, new EventArgs());
        }
        public virtual void Remove(T item)
        {
            int index = _items.IndexOf(item);
            T removedItem = _items[index];
            string removedKey = _keys[index];
            _items.RemoveAt(index);
            _keys.RemoveAt(index);

            if (ItemRemove != null) ItemRemove(this, new KeyedCollectionRemoveEventArgs(removedItem, removedKey, index));
            if (CollectionChanged != null) CollectionChanged(this, new EventArgs());
        }
        public virtual void Sort()
        {
            _items.Sort(_keys.GetItems());
            _keys.Sort(_keys.GetItems());
            if (CollectionChanged != null) CollectionChanged(this, new EventArgs());
        }
        public virtual void SwapByIndex(int index1, int index2)
        {
            _items.SwapByIndex(index1, index2);
            _keys.SwapByIndex(index1, index2);
            if (CollectionChanged != null) CollectionChanged(this, new EventArgs());
        }
        public virtual void Swap(T item1, T item2)
        {
            int index1 = _items.IndexOf(item1);
            int index2 = _items.IndexOf(item2);

            this.SwapByIndex(index1, index2);
        }
        public virtual void Reverse()
        {
            _items.Reverse();
            _keys.Reverse();

            if (CollectionChanged != null) CollectionChanged(this, new EventArgs());
        }
        public virtual void Reverse(int index, int length)
        {
            _items.Reverse(index, length);
            _keys.Reverse(index, length);
            if (CollectionChanged != null) CollectionChanged(this, new EventArgs());
        }
        public virtual void TrimToSize()
        {
            _items.TrimToSize();
            _keys.TrimToSize();
        }
        public bool TryGetItem(int index, out T item)
        {
            return _items.TryGetItem(index, out item);
        }
        public bool TryGetItem(string key, out T item)
        {
            item = default(T);
            if (!_keys.Contains(key)) return false;
            item = this[key];
            return true;
        }

        #endregion

        #region IEnumerable Members

        //IEnumerator IKeyedCollection<T>.GetEnumerator()
        //{
        //    return this.GetEnumerator();
        //}
        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }

        #endregion

    }
}