Class ScyllaPriorityQueueItemComparer<T>

A bridge comparer that adapts IScyllaPriorityQueueItem to the IComparer<T> interface required by ScyllaPriorityQueue<T>, ordering elements by their QueuePriority integer value.

Inheritance

object

ScyllaPriorityQueueItemComparer<T>

Implements

IComparer<T>

Inherited Members

object.Equals(object)

object.Equals(object, object)

object.GetHashCode()

object.GetType()

object.ReferenceEquals(object, object)

object.ToString()

Namespace: Scylla.Core.Structures

Assembly: ScyllaCore.dll

Syntax

public sealed class ScyllaPriorityQueueItemComparer<T> : IComparer<T> where T : IScyllaPriorityQueueItem

Type Parameters

Name	Description
T	The item type to compare. Must implement IScyllaPriorityQueueItem so that QueuePriority is accessible for comparison. Both class and struct types are supported.

Remarks

This comparer eliminates the need to write a custom IComparer<T> implementation for the common case where an item already carries an integer priority via IScyllaPriorityQueueItem. Use the Default singleton to avoid unnecessary allocations.

The ordering contract of this comparer is consistent with CompareTo(int): a negative result means the left item has a lower priority number, which the heap interprets as higher priority in Min mode. For Max mode, ScyllaPriorityQueue<T> internally flips the operands so that no change to this comparer is required.

Tie-breaking when two items share the same QueuePriority value is unspecified. Compare(T, T) returns zero for equal priorities, and the heap makes no guarantees about the relative dequeue order of such items.

Typical usage with a ScyllaPriorityQueue<T>:

var pq = new ScyllaPriorityQueue<MyItem>(
    order: ScyllaPriorityQueueOrder.Max,
    comparer: ScyllaPriorityQueueItemComparer<MyItem>.Default);

Or equivalently using the fluent builder:

var pq = ScyllaPriorityQueue<MyItem>.CreateBuilder()
    .WithCapacity(64)
    .MaxHeap()
    .WithComparer(ScyllaPriorityQueueItemComparer<MyItem>.Default)
    .Build();

Fields

Default

Gets the shared singleton instance of ScyllaPriorityQueueItemComparer<T> for the given type argument T.

Declaration

public static readonly ScyllaPriorityQueueItemComparer<T> Default

Field Value

Type	Description
ScyllaPriorityQueueItemComparer<T>	A stateless, allocation-free singleton comparer instance. Because this comparer holds no mutable state, it is safe to share across multiple ScyllaPriorityQueue<T> instances and across threads without synchronization.

Remarks

Prefer this property over constructing a new instance with new ScyllaPriorityQueueItemComparer<T>() to avoid unnecessary heap allocations, particularly in performance-sensitive code that creates many queues at runtime.

Methods

Compare(T, T)

Compares two items of type T by their QueuePriority integer values and returns a value indicating their relative ordering.

Declaration

public int Compare(T x, T y)

Parameters

Type	Name	Description
T	x	The first item to compare. If `null`, this item is considered less than any non-null item, and `-1` is returned.
T	y	The second item to compare. If `null`, this item is considered less than any non-null item, and `1` is returned (meaning `x` is ordered after `y`).

Returns

Type Description

Type	Description
int	A signed integer derived from CompareTo(int) applied to the two QueuePriority values: A negative value if `x`'s priority is less than `y`'s priority (or `x` is `null` and `y` is not). Zero if both items have the same priority value, or both references are identical (including both being `null`). A positive value if `x`'s priority is greater than `y`'s priority (or `y` is `null` and `x` is not). When this comparer is used with a ScyllaPriorityQueue<T> configured as Min, a negative result means `x` has higher heap priority (dequeued first). For Max, the queue internally reverses the comparison, so a positive result indicates higher heap priority.

int

A signed integer derived from CompareTo(int) applied to the two QueuePriority values:

A negative value if x's priority is less than y's priority (or x is null and y is not).
Zero if both items have the same priority value, or both references are identical (including both being null).
A positive value if x's priority is greater than y's priority (or y is null and x is not).

When this comparer is used with a ScyllaPriorityQueue<T> configured as Min, a negative result means x has higher heap priority (dequeued first). For Max, the queue internally reverses the comparison, so a positive result indicates higher heap priority.

Remarks

Reference equality is tested first as a fast-path shortcut: if both parameters refer to the exact same object instance (or are both null), the method immediately returns zero without reading QueuePriority. For value types, the null checks and reference-equality test are optimised away by the JIT compiler because value types cannot be null.