internal void InsertItemInPriorityChain(PriorityItem <T> item, PriorityChain <T> chain, PriorityItem <T> after) { Debug.Assert(chain != null, "PriorityQueue.InsertItemInPriorityChain:" + " a chain must be provided."); Debug.Assert(item.Chain == null && item.PriorityPrev == null && item.PriorityNext == null, "PriorityQueue.InsertItemInPriorityChain:" + " item must not already be in a priority chain."); item.Chain = chain; if (after == null) { // Note: passing null for after means insert at the head. if (chain.Head != null) { Debug.Assert(chain.Tail != null, "PriorityQueue.InsertItemInPriorityChain:" + " both the head and the tail should not be null."); chain.Head.PriorityPrev = item; item.PriorityNext = chain.Head; chain.Head = item; } else { Debug.Assert(chain.Tail == null, "PriorityQueue.InsertItemInPriorityChain:" + " both the head and the tail should be null."); chain.Head = chain.Tail = item; } } else { item.PriorityPrev = after; if (after.PriorityNext != null) { item.PriorityNext = after.PriorityNext; after.PriorityNext.PriorityPrev = item; after.PriorityNext = item; } else { Debug.Assert(item.Chain.Tail == after, "PriorityQueue.InsertItemInPriorityChain:" + " the chain's tail should be the item we " + "are inserting after."); after.PriorityNext = item; chain.Tail = item; } } chain.Count++; }
public void ChangeItemPriority(PriorityItem <T> item, WorkPriority priority) // NOTE: should be Priority { // Remove the item from its current priority and insert it into // the new priority chain. Note that this does not change the // sequential ordering. // Step 1: Remove the item from the priority chain. RemoveItemFromPriorityChain(item); // Step 2: Insert the item into the new priority chain. // Find the existing chain for this priority, or create a new one // if one does not exist. PriorityChain <T> chain = GetChain(priority); InsertItemInPriorityChain(item, chain); }
public void RemoveItem(PriorityItem <T> item) { Debug.Assert(item != null, "PriorityQueue.RemoveItem: invalid item."); Debug.Assert(item.Chain != null, "PriorityQueue.RemoveItem: a chain should exist."); PriorityChain <T> chain = item.Chain; // Step 1: Remove the item from its priority chain. RemoveItemFromPriorityChain(item); // Step 2: Remove the item from the sequential chain. RemoveItemFromSequentialChain(item); // Note: we do not clean up empty chains on purpose to reduce churn. }
public PriorityItem <T> Enqueue(WorkPriority priority, T data) // NOTE: should be Priority { // Find the existing chain for this priority, or create a new one // if one does not exist. PriorityChain <T> chain = GetChain(priority); // Wrap the item in a PriorityItem so we can put it in our // linked list. PriorityItem <T> priorityItem = new PriorityItem <T>(data); // Step 1: Append this to the end of the "sequential" linked list. InsertItemInSequentialChain(priorityItem, _tail); // Step 2: Append the item into the priority chain. InsertItemInPriorityChain(priorityItem, chain, chain.Tail); return(priorityItem); }
private PriorityChain <T> GetChain(WorkPriority priority) // NOTE: should be Priority { PriorityChain <T> chain = null; int count = _priorityChains.Count; if (count > 0) { if (priority == (WorkPriority)_priorityChains.Keys[0]) { chain = _priorityChains.Values[0]; } else if (priority == (WorkPriority)_priorityChains.Keys[count - 1]) { chain = _priorityChains.Values[count - 1]; } else if ((priority > (WorkPriority)_priorityChains.Keys[0]) && (priority < (WorkPriority)_priorityChains.Keys[count - 1])) { _priorityChains.TryGetValue((int)priority, out chain); } } if (chain == null) { if (_cacheReusableChains.Count > 0) { chain = _cacheReusableChains.Pop(); chain.Priority = priority; } else { chain = new PriorityChain <T>(priority); } _priorityChains.Add((int)priority, chain); } return(chain); }
public T Peek() { T data = default(T); // Get the max-priority chain. int count = _priorityChains.Count; if (count > 0) { PriorityChain <T> chain = _priorityChains.Values[count - 1]; Debug.Assert(chain != null, "PriorityQueue.Peek: a chain should exist."); PriorityItem <T> item = chain.Head; Debug.Assert(item != null, "PriorityQueue.Peek: a priority item should exist."); data = item.Data; } return(data); }
private void InsertItemInPriorityChain(PriorityItem <T> item, PriorityChain <T> chain) { // Scan along the sequential chain, in the previous direction, // looking for an item that is already in the new chain. We will // insert ourselves after the item we found. We can short-circuit // this search if the new chain is empty. if (chain.Head == null) { Debug.Assert(chain.Tail == null, "PriorityQueue.InsertItemInPriorityChain:" + " both the head and the tail should be null."); InsertItemInPriorityChain(item, chain, null); } else { Debug.Assert(chain.Tail != null, "PriorityQueue.InsertItemInPriorityChain:" + " both the head and the tail should not be null."); PriorityItem <T> after = null; // Search backwards along the sequential chain looking for an // item already in this list. for (after = item.SequentialPrev; after != null; after = after.SequentialPrev) { if (after.Chain == chain) { break; } } InsertItemInPriorityChain(item, chain, after); } }
public T Dequeue() { // Get the max-priority chain. int count = _priorityChains.Count; if (count > 0) { PriorityChain <T> chain = _priorityChains.Values[count - 1]; Debug.Assert(chain != null, "PriorityQueue.Dequeue: a chain should exist."); PriorityItem <T> item = chain.Head; Debug.Assert(item != null, "PriorityQueue.Dequeue: a priority item should exist."); RemoveItem(item); return(item.Data); } else { throw new InvalidOperationException(); } }