/// <inheritdoc/>
            public bool TryDequeue(out HexKeyValuePair <TKey, TValue> result)
            {
                if (_items.Count == 0)
                {
                    result = default(HexKeyValuePair <TKey, TValue>);
                    return(false);
                }

                result = _items[0];

                // Remove the first item if there will only be 0 or 1 items left after doing so.
                if (_items.Count <= 2)
                {
                    _items.RemoveAt(0);
                }
                else
                {
                    // Remove the first item and move the last item to the front.
                    _items[0] = _items[_items.Count - 1];
                    _items.RemoveAt(_items.Count - 1);

                    MinHeapifyDown(0);
                }
                return(true);
            }
            public bool PathFound(HexKeyValuePair <int, DirectedPath> item)
            {
                var path = item.Value;
                var hex  = path.PathStep.Hex;

                if (_closed.Contains(hex.Coords))
                {
                    return(false);
                }

                _open.Add(item.Value.PathStep.Hex.Coords, item.Value);

                TraceFlags.FindPathDequeue.Trace(
                    "Dequeue Path at {0} w/ cost={1,4} at {2}; estimate={3,4}:{4,4}.",
                    item.Value.PathStep.Hex.Coords, item.Value.TotalCost, item.Value.HexsideExit,
                    item.Key >> 16, item.Key & 0xFFFF);

                if (hex.Coords.Equals(_start.Coords))
                {
                    Path = path;
                    return(true);
                }

                _closed.Add(hex.Coords);

                FastHexsideList.ForEach((Action <Hexside>)(hexside => Invoke(path, hexside)));
                return(false);
            }
                /// <inheritdoc/>
                public HexKeyValuePair <TKey, TValue> ExtractFirst()
                {
                    if (_items.Count == 0)
                    {
                        throw new InvalidOperationException("The heap is empty.");
                    }

                    // save first item for return later.
                    HexKeyValuePair <TKey, TValue> toReturn = _items[0];

                    // Remove the first item if there will only be 0 or 1 items left after doing so.
                    if (_items.Count <= 2)
                    {
                        _items.RemoveAt(0);
                    }
                    else
                    {
                        // Remove the first item and move the last item to the front.
                        _items[0] = _items[_items.Count - 1];
                        _items.RemoveAt(_items.Count - 1);

                        MinHeapifyDownn(0);
                    }

                    // Return the item from the heap
                    return(toReturn);
                }
 public bool TryPeek(out HexKeyValuePair <TKey, TValue> result)
 {
     if (_minHeap.Any())
     {
         result = _minHeap.Peek();
         return(true);
     }
     result = new HexKeyValuePair <TKey, TValue>();
     return(false);
 }
 public bool TryDequeue(out HexKeyValuePair <TKey, TValue> result)
 {
     if (_minHeap.Any())
     {
         result = _minHeap.ExtractFirst();
         return(true);
     }
     result = new HexKeyValuePair <TKey, TValue>();
     return(false);
 }
            /// <inheritdoc/>
            public bool TryPeek(out HexKeyValuePair <TKey, TValue> result)
            {
                if (_items.Count == 0)
                {
                    result = default(HexKeyValuePair <TKey, TValue>);
                    return(false);
                }

                result = _items[0];
                return(true);
            }
            /// <inheritdoc/>
            public void Enqueue(HexKeyValuePair <TKey, TValue> item)
            {
                _items.Add(item);
                var child  = Count - 1;
                var parent = (child - 1) / 2;

                while (child > 0 && _items[parent] > _items[child])
                {
                    var heap = _items[parent];  _items[parent] = _items[child];  _items[child] = heap;
                    child  = parent;
                    parent = (child - 1) / 2;
                }
            }
                /// <inheritdoc/>
                public void Add(HexKeyValuePair <TKey, TValue> item)
                {
                    _items.Add(item);
                    var child  = Count - 1;
                    var parent = (child - 1) >> 1;

                    while (child > 0 && _items[parent].CompareTo(_items[child]) > 0)
                    {
                        var heap = _items[parent];   _items[parent] = _items[child];   _items[child] = heap;// swap
                        child  = parent;
                        parent = (child - 1) >> 1;
                    }
                }
 public bool Remove(HexKeyValuePair <TKey, TValue> item)
 {
     throw new InvalidOperationException("Remove");
 }
 public bool Contains(HexKeyValuePair <TKey, TValue> item)
 {
     return(_list.Contains(item));
 }
 public void Add(HexKeyValuePair <TKey, TValue> item)
 {
     _list.Add(item);
 }
 bool ICollection <HexKeyValuePair <TKey, TValue> > .Remove(HexKeyValuePair <TKey, TValue> item)
 {
     throw new InvalidOperationException("Remove");
 }
 bool ICollection <HexKeyValuePair <TKey, TValue> > .Contains(HexKeyValuePair <TKey, TValue> item)
 {
     return(_list.Contains(item));
 }
 public void Enqueue(HexKeyValuePair <TKey, TValue> item)
 {
     _minHeap.Add(new HexKeyValuePair <TKey, TValue>(item.Key, item.Value));
 }