Struct Resizable 

pub struct Resizable<Q> { /* private fields */ }

A dynamically resizable wrapper around a BoundedCollection.

This type implements an algorithm that allows any BoundedCollection to be dynamically resized while preserving some of its properties.

Progress Guarantees:

• Lock Freedom: if the wrapped collection is lock-free, all corresponding operations on Resizable are also lock-free.
• Obstruction Freedom: if the wrapped collection exposes obstruction-free methods, all corresponding operations on Resizable are also obstruction-free.

Resizable::resize is blocking both on allocator and stale readers and writers.

Ordering and Consistency Guarantees:

• Relaxed FIFO: if the wrapped collection has FIFO ordering, Resizable has k-FIFO ordering with asymmetric delay and rank error.
• Linearizability: if the wrapped collection is linearizable, all operations on Resizable are also linearizable with respect to its relaxed FIFO specification.
• Empty-Linearizability: if the wrapped collection is linearizale, all operations on Resizable are empty-linearizable with respect to the wrapped collections specification.

If no call to resize happens, or in steady-state, Resizable has strict FIFO ordering and is strictly linearizable, given the same holds for the wrapped collection.

For more intormation on rank error and delay consult the crate level documentation.

Implementations

impl<Q> Resizable<Q>

pub fn from_parts(left: Q, right: Q) -> Self

Constructs a new Resizable from two raw BoundedCollection objects.

impl<Q> Resizable<Q>

where Q: BoundedCollection,

pub fn with_capacity(size: usize) -> Resizable<Q>

Constructs a new Resizable with capacity size.

pub fn new() -> Self

Constructs a new Resizable

impl<Q> Resizable<Q>

where Q: BoundedCollection,

pub fn resize(&self, size: usize) -> bool

Attempts to resize the capacity of the collection to size slots.

Note: This method may block (on the allocator) or fail spuriously. Further a growth event may not be considered finished in regards of an other resize being possible until some time after the call to resize.

Returns true if the resize was successfull, or false if it failed. Failure can occur due to thread contention, incomplete migration of the previous resize, i.e. staleness of the datastructure, or other implementation-specific/spurious conditions.

impl<Q> Resizable<Q>

pub fn into_parts(self) -> [Box<Q>; 2]

Deconstructs a Resizable into its components.

Returns the left and right raw collections currently used by this object.

pub fn parts_mut(&mut self) -> [&mut Q; 2]

returns mutable references to both wrapped collections.

pub fn into_current(self) -> Box<Q>

Deconstructs a Resizable into its currently active component.

Returns the raw collection currently used by this object.

pub fn current_mut(&mut self) -> &mut Q

Returns a mutable reference to the currently active raw collection.

impl<Q> Resizable<Q>

where Q: BoundedCollection,

pub fn pop_mut(&mut self) -> Option<Q::Item>

Attempts to pop an item from the collection.

This method cicumvents the logic synchronization of Resizable::try_pop.

pub fn push_mut(&mut self, item: Q::Item) -> Result<(), Q::Item>

Attmepts to push an item into the collection.

This method cicumvents the synchronization logic of Resizable::try_push.

pub fn clear(&mut self)

Clears the collection.

pub fn migrate(&mut self)

Migrates all remaining stale items in the old queue into the currently active queue, while ensuring enough capacity.

A subsequent call to Self::resize will succeed.

pub fn drain(&mut self) -> Drain<'_, Q, impl Iterator<Item = &mut Q>>

Drains all remaining items in the collection. Returns an iterator over the drained items.

All remaining items are dropped if the Drain is dropped.

Trait Implementations

impl<Q> BoundedCollection for Resizable<Q>

where Q: BoundedCollection,

type Item = <Q as BoundedCollection>::Item

The item stored in the collection.

fn try_push(&self, item: Self::Item) -> Result<(), Self::Item>

Attempts to push an item into the collection. Returns the item as an error if the collection is full.

fn try_pop(&self) -> Option<Self::Item>

Attempts to pop an item from the collection. Returns None if the collection is empty.

fn capacity(&self) -> usize

Returns the total capacity of the collection.

fn len(&self) -> usize

Returns the current length of the collection. The returned value may be stale under concurrent access and should not be used for synchronization.

fn is_empty(&self) -> bool

Indicates whether the collection is empty. The returned value may be stale under concurrent access and should not be used for synchronization.

fn is_full(&self) -> bool

Indicates whether the collection is full. The returned value may be stale under concurrent access and should not be used for synchronization.

fn with_capacity(capacity: usize) -> Self

Constructs a new instance of this type with capacity capacity.

impl<Q: Debug> Debug for Resizable<Q>

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

Formats the value using the given formatter.

impl<Q> Default for Resizable<Q>

where Q: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<Q> Drop for Resizable<Q>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<Q: BoundedCollection> Extend<<Q as BoundedCollection>::Item> for Resizable<Q>

Available on neither echeneis nor loom nor shuttle.

fn extend<I: IntoIterator<Item = Q::Item>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: T)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl<Q: BoundedCollection> IntoIterator for Resizable<Q>

Available on neither echeneis nor loom nor shuttle.

type IntoIter = IntoIter<Q>

Which kind of iterator are we turning this into?

type Item = <Q as BoundedCollection>::Item

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.