Struct AllocatorKeyV32 

pub struct AllocatorKeyV32 {
    pub device_range: Extent,
}

Fields

device_range: Extent

Implementations

impl AllocatorKeyV32

pub fn lower_bound_for_merge_into(&self) -> AllocatorKey

Returns a search key for merge_into that finds any touching predecessor to coalesce with.

Extents in the tree are sorted by cmp_upper_bound as (end, -start):

Tree:       [  Predecessor  ) [ Key to insert )
Offsets:    X              10                20

Search key:                 | (10..10)

Searching with 10..10 has end=10, len=0. Because shorter extents sort earlier when ends match, 10..10 sorts before any valid extent X..10 (len > 0). This positions the iterator at X..10 so it can be merged with 10..20.

Trait Implementations

impl Clone for AllocatorKeyV32

fn clone(&self) -> AllocatorKeyV32

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AllocatorKeyV32

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AllocatorKeyV32

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for AllocatorKeyV32

impl Hash for AllocatorKeyV32

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<I: LayerIterator<AllocatorKey, AllocatorValue>> LayerIterator<AllocatorKeyV32, AllocatorValueV32> for CoalescingIterator<I>

async fn advance(&mut self) -> Result<(), Error>

Advances the iterator (static dispatch, unboxed future).

fn advance_dyn<'a>( &'a mut self, ) -> Result<Option<BoxFuture<'a, Result<(), Error>>>, Error>

Advances the iterator for dynamic dispatch (trait objects). If the iterator advances synchronously, returns Ok(None).

fn get(&self) -> Option<ItemRef<'_, AllocatorKey, AllocatorValue>>

Returns the current item. This will be None if called when the iterator is first crated i.e. before either seek or advance has been called, and None if the iterator has reached the end of the layer.

fn filter<P>( self, predicate: P, ) -> impl Future<Output = Result<FilterLayerIterator<Self, P, K, V>, Error>> + Send

where P: for<'b> Fn(ItemRef<'b, K, V>) -> bool + Send + Sync, Self: Sized, K: Send + Sync, V: Send + Sync,

Creates an iterator that only yields items from the underlying iterator for which predicate returns true.

impl Ord for AllocatorKeyV32

fn cmp(&self, other: &AllocatorKeyV32) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for AllocatorKeyV32

fn eq(&self, other: &AllocatorKeyV32) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for AllocatorKeyV32

fn partial_cmp(&self, other: &AllocatorKeyV32) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for AllocatorKeyV32

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl SerializeKey for AllocatorKeyV32

type Output<'a, B: Buffer + 'a> = <Extent as SerializeKey>::Output<'a, B>

The serializer state returned after writing this type (KeySerializer for non-terminal types, or KeySerializerFinalized for variable-length trailing types).

fn serialize_key_to<'a, B: Buffer>( &self, serializer: KeySerializer<'a, B>, ) -> Self::Output<'a, B>

Encodes key representation sequentially into serialization stream.

fn deserialize_key_from(deserializer: &mut KeyDeserializer<'_>) -> Result<Self>

Decodes serializations sequentially from underlying raw bytes.

fn serialize_key_into<B: Buffer>(&self, buffer: &mut B)

Serializes this key directly into buffer with its length prefix and no delta base.

fn serialize_key_with_base_into<B: Buffer>(&self, buffer: &mut B, base: u64)

where Self: SortByU64,

Serializes this key directly into buffer with its length prefix and delta base subtracted from the leading u64.

impl StructuralPartialEq for AllocatorKeyV32

impl TypeFingerprint for AllocatorKeyV32

fn fingerprint() -> String

impl Versioned for AllocatorKeyV32

fn max_serialized_size() -> Option<u64>

Maximum size of a serialized version of this type. Serialization and deserialization will fail if the limit is exceeded. If None, there is no limit. None is preferred over u64::MAX because serializing and deserializing with a limit has runtime overhead.

fn deserialize_from<R>(reader: &mut R, _version: Version) -> Result<Self>

where R: Read + ?Sized, for<'de> Self: Deserialize<'de>,

fn serialize_into<W>(&self, writer: &mut W) -> Result<()>

where W: Write, Self: Serialize,

impl VersionedLatest for AllocatorKeyV32

fn deserialize_from_version<R>(reader: &mut R, version: Version) -> Result<Self>

where R: Read, Self: Sized,

Deserializes from a given version format and upgrades to the latest version.

fn deserialize_with_version<R>(reader: &mut R) -> Result<(Self, Version)>

where R: Read, Self: Sized,

Like deserialize_from_version but reads Version from reader first, then uses it to deserialize self.

fn serialize_with_version<W>(&self, writer: &mut W) -> Result<()>

where W: Write, Self: Sized,

Like serialize_into but serialized Version first, then self.