public bool TryEnqueue(T item, QueueSide queueSide)
{
int num;
if (this.itemToDequeIndex.ContainsKey(item))
{
return(false);
}
if (queueSide != QueueSide.Back)
{
if (queueSide != QueueSide.Front)
{
throw ExceptionUtil.InvalidEnumArgumentException <QueueSide>(queueSide, "queueSide");
}
}
else
{
num = this.deque.AddLast(item);
goto Label_0043;
}
num = this.deque.AddFirst(item);
Label_0043:
this.itemToDequeIndex.Add(item, num);
return(true);
}
public void EnqueueRange(IEnumerable <T> items, QueueSide queueSide)
{
foreach (T local in items)
{
this.TryEnqueue(local, queueSide);
}
}
public IAsync Enqueue(QueueSide qSide, Action callback)
{
Validate.Begin().IsNotNull <Action>(callback, "callback").IsTrue(((qSide == QueueSide.Front) || (qSide == QueueSide.Back)), "qSide is not a valid member of the QueueSide enumeration").Check();
IAsyncSource source = Async.NewSource();
if (this.pleaseAbort)
{
source.Throw(new OperationCanceledException("The work queue has shut down."));
}
else
{
object sync = this.Sync;
lock (sync)
{
Action item = delegate {
callback.Try().Into(source);
};
Action action2 = delegate {
source.Throw(new OperationCanceledException("The dispatcher has shut down."));
};
if (qSide == QueueSide.Front)
{
this.runFnQ.EnqueueFront(item);
this.cancelFnQ.EnqueueFront(action2);
}
else
{
this.runFnQ.Enqueue(item);
this.cancelFnQ.Enqueue(action2);
}
ThreadPool.QueueUserWorkItem(this.threadPoolCallback);
}
}
return(source.AsReceiveOnly());
}
private bool TryEnqueueWhileLocked(TKey key, TValue value, QueueSide queueSide)
{
int num;
if (this.keyToDequeIndexMap.ContainsKey(key))
{
return(false);
}
KeyValuePair <TKey, TValue> pair = new KeyValuePair <TKey, TValue>(key, value);
if (queueSide != QueueSide.Back)
{
if (queueSide != QueueSide.Front)
{
throw new InternalErrorException();
}
}
else
{
num = this.deque.AddLast(pair);
goto Label_0046;
}
num = this.deque.AddFirst(pair);
Label_0046:
this.keyToDequeIndexMap.Add(key, num);
return(true);
}
private bool TryDequeueWhileLocked(out KeyValuePair <TKey, TValue> item, QueueSide queueSide)
{
LinkedArrayNode <KeyValuePair <TKey, TValue> > first;
if (!this.deque.Any())
{
item = new KeyValuePair <TKey, TValue>();
return(false);
}
if (queueSide != QueueSide.Back)
{
if (queueSide != QueueSide.Front)
{
throw ExceptionUtil.InvalidEnumArgumentException <QueueSide>(queueSide, "queueSide");
}
}
else
{
first = this.deque.Last;
goto Label_0047;
}
first = this.deque.First;
Label_0047:
item = first.Value;
this.deque.RemoveAt(first.Index);
this.keyToDequeIndexMap.Remove(item.Key);
return(true);
}
public IEnumerator <T> GetEnumerator(QueueSide side)
{
if (side == QueueSide.Front)
{
return(this.GetEnumerator());
}
return(this.GetReverseEnumerator());
}
public bool TryDequeue(out KeyValuePair <TKey, TValue> item, QueueSide queueSide)
{
object sync = this.sync;
lock (sync)
{
return(this.TryDequeueWhileLocked(out item, queueSide));
}
}
public TValue GetOrEnqueue(TKey key, TValue value, QueueSide queueSide)
{
object sync = this.sync;
lock (sync)
{
return(this.GetOrEnqueueWhileLocked(key, value, queueSide));
}
}
public TValue GetOrEnqueue(TKey key, Func <TKey, TValue> valueFactory, QueueSide queueSide)
{
TValue local;
Validate.IsNotNull <Func <TKey, TValue> >(valueFactory, "valueFactory");
if (this.TryGetValue(key, out local))
{
return(local);
}
TValue local2 = valueFactory(key);
return(this.GetOrEnqueue(key, local2, queueSide));
}
public bool TryEnqueue(T item, QueueSide queueSide)
{
if ((queueSide != QueueSide.Back) && (queueSide != QueueSide.Front))
{
ExceptionUtil.ThrowInvalidEnumArgumentException <QueueSide>(queueSide, "queueSide");
}
object sync = this.Sync;
lock (sync)
{
return(this.dequeSet.TryEnqueue(item, queueSide));
}
}
private TValue GetOrEnqueueWhileLocked(TKey key, TValue value, QueueSide queueSide)
{
int num;
if (this.keyToDequeIndexMap.TryGetValue(key, out num))
{
return(this.deque.GetValue(num).Value);
}
if (!this.TryEnqueueWhileLocked(key, value, queueSide))
{
ExceptionUtil.ThrowInternalErrorException();
}
return(value);
}
public T Dequeue(QueueSide queueSide)
{
if (queueSide != QueueSide.Back)
{
if (queueSide == QueueSide.Front)
{
return(this.Dequeue());
}
}
else
{
return(this.DequeueBack());
}
ExceptionUtil.ThrowInvalidEnumArgumentException <QueueSide>(queueSide, "queueSide");
return(default(T));
}
public static QueueSide Invert(QueueSide queueSide)
{
if (queueSide != QueueSide.Back)
{
if (queueSide == QueueSide.Front)
{
return(QueueSide.Back);
}
}
else
{
return(QueueSide.Front);
}
ExceptionUtil.ThrowInvalidEnumArgumentException <QueueSide>(queueSide, "queueSide");
return((QueueSide)(-2147483648));
}
public T PeekUnchecked(QueueSide queueSide, int index)
{
if (queueSide != QueueSide.Back)
{
if (queueSide == QueueSide.Front)
{
return(this.PeekUnchecked(index));
}
}
else
{
return(this.PeekBackUnchecked(index));
}
ExceptionUtil.ThrowInvalidEnumArgumentException <QueueSide>(queueSide, "queueSide");
return(default(T));
}
public void Enqueue(T item, QueueSide queueSide)
{
if (queueSide != QueueSide.Back)
{
if (queueSide == QueueSide.Front)
{
this.EnqueueFront(item);
}
else
{
ExceptionUtil.ThrowInvalidEnumArgumentException <QueueSide>(queueSide, "queueSide");
}
}
else
{
this.Enqueue(item);
}
}
public static int EnqueueRange <T>(this Deque <T> queue, IEnumerable <T> items, QueueSide queueSide)
{
int num = 0;
foreach (T local in items)
{
queue.Enqueue(local, queueSide);
num++;
}
return(num);
}
public TValue EnqueueOrUpdate(TKey key, TValue enqueueValue, Func <TKey, TValue, TValue> updateValueFactory, QueueSide queueSide)
{
TValue local;
TValue local2;
Validate.IsNotNull <Func <TKey, TValue, TValue> >(updateValueFactory, "updateValueFactory");
do
{
if (this.TryGetValue(key, out local) && this.TryEnqueue(key, enqueueValue))
{
return(enqueueValue);
}
local2 = updateValueFactory(key, local);
}while (!this.TryUpdate(key, local2, local));
return(local2);
}
