portraitqueue.cs

破解的飞信源代码

namespace Imps.Client.Core
{
    using Imps.Common;
    using System;
    using System.Collections.Generic;
    using System.Reflection;

    internal class PortraitQueue
    {
        private IComparer<PortraitQueueItem> _comparer = new PortraitQueueItemCompare();
        private List<PortraitQueueItem> _list = new List<PortraitQueueItem>();
        private object _syncObj = new object();

        public void Clear()
        {
            this._list.Clear();
        }

        public bool Contains(PortraitQueueItem item)
        {
            return this._list.Contains(item);
        }

        public void CopyTo(PortraitQueueItem[] array, int arrayIndex)
        {
            this._list.CopyTo(array, arrayIndex);
        }

        public PortraitQueueItem Dequeue()
        {
            lock (this.SyncObj)
            {
                if (this.Count <= 0)
                {
                    return null;
                }
                PortraitQueueItem item = this[0];
                this.RemoveAt(0);
                return item;
            }
        }

        public void Enqueue(PortraitQueueItem item)
        {
            if (item != null)
            {
                lock (this.SyncObj)
                {
                    List<PortraitQueueItem>.Enumerator enumerator = this._list.GetEnumerator();
                    try
                    {
                        while (enumerator.MoveNext())
                        {
                            PortraitQueueItem item2 = enumerator.get_Current();
                            if (item.Uri.EqualsSmartly(item2.Uri))
                            {
                                int priority = item2.Priority;
                                if (item.Priority > priority)
                                {
                                    item2.Priority = item.Priority;
                                }
                                this.InnerDoSort();
                                goto Label_0092;
                            }
                        }
                    }
                    finally
                    {
                        enumerator.Dispose();
                    }
                    this._list.Add(item);
                    this.InnerDoSort();
                Label_0092:;
                }
            }
        }

        public void Enqueue(PersonalInfoBase personalInfo, int priority)
        {
            if (personalInfo != null)
            {
                PortraitQueueItem item = new PortraitQueueItem(personalInfo, priority);
                this.Enqueue(item);
            }
        }

        public IEnumerator<PortraitQueueItem> GetEnumerator()
        {
            return this._list.GetEnumerator();
        }

        public int IndexOf(PortraitQueueItem item)
        {
            return this._list.IndexOf(item);
        }

        private void InnerDoSort()
        {
            if (this._comparer != null)
            {
                this._list.Sort(this._comparer);
            }
            else
            {
                this._list.Sort();
            }
        }

        public void Insert(int index, PortraitQueueItem item)
        {
            this._list.Insert(index, item);
        }

        public bool Remove(PortraitQueueItem item)
        {
            if (item == null)
            {
                return false;
            }
            lock (this.SyncObj)
            {
                int index = this._list.IndexOf(item);
                if (index >= 0)
                {
                    this._list.RemoveAt(index);
                    return true;
                }
                return false;
            }
        }

        public bool Remove(IicUri uri)
        {
            lock (this.SyncObj)
            {
                List<PortraitQueueItem>.Enumerator enumerator = this._list.GetEnumerator();
                try
                {
                    while (enumerator.MoveNext())
                    {
                        PortraitQueueItem item = enumerator.get_Current();
                        if (item.Uri.EqualsSmartly(uri))
                        {
                            return this._list.Remove(item);
                        }
                    }
                }
                finally
                {
                    enumerator.Dispose();
                }
                return false;
            }
        }

        public void RemoveAt(int index)
        {
            this._list.RemoveAt(index);
        }

        public int Count
        {
            get
            {
                return this._list.get_Count();
            }
        }

        public bool IsReadOnly
        {
            get
            {
                return false;
            }
        }

        public PortraitQueueItem this[IicUri uri]
        {
            get
            {
                lock (this.SyncObj)
                {
                    List<PortraitQueueItem>.Enumerator enumerator = this._list.GetEnumerator();
                    try
                    {
                        while (enumerator.MoveNext())
                        {
                            PortraitQueueItem item = enumerator.get_Current();
                            if (item.Uri.EqualsSmartly(uri))
                            {
                                return item;
                            }
                        }
                    }
                    finally
                    {
                        enumerator.Dispose();
                    }
                    return null;
                }
            }
        }

        public PortraitQueueItem this[int index]
        {
            get
            {
                return this._list.get_Item(index);
            }
            set
            {
                this._list.set_Item(index, value);
            }
        }

        internal IComparer<PortraitQueueItem> SortComparer
        {
            get
            {
                return this._comparer;
            }
            set
            {
                this._comparer = value;
                this.InnerDoSort();
            }
        }

        public object SyncObj
        {
            get
            {
                return this._syncObj;
            }
            set
            {
                this._syncObj = value;
            }
        }
    }
}