Struct timely_container::flatcontainer::MirrorRegion

pub struct MirrorRegion<T>(/* private fields */);

A region for types where the read item type is equal to the index type.

This region is useful where the type is not larger than roughly two usizes (or 1.5x with some optimizations), or looking up the value is too costly. For larger copy types, the memory required to store the copy type and an index is only marginally bigger, with the benefit that the index remains compact.

Examples

For MirrorRegions, we can index with a copy type:

let r = <MirrorRegion<u8>>::default();
let output: u8 = r.index(42);
assert_eq!(output, 42);

Trait Implementations

impl<T> Clone for MirrorRegion<T>

where T: Clone,

fn clone(&self) -> MirrorRegion<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for MirrorRegion<T>

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

Formats the value using the given formatter.

impl<T> Default for MirrorRegion<T>

fn default() -> MirrorRegion<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for MirrorRegion<T>

fn deserialize<__D>( __deserializer: __D, ) -> Result<MirrorRegion<T>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Ord for MirrorRegion<T>

where T: Ord,

fn cmp(&self, other: &MirrorRegion<T>) -> 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 + PartialOrd,

Restrict a value to a certain interval.

impl<T> PartialEq for MirrorRegion<T>

where T: PartialEq,

fn eq(&self, other: &MirrorRegion<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> PartialOrd for MirrorRegion<T>

where T: PartialOrd,

fn partial_cmp(&self, other: &MirrorRegion<T>) -> 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<T> Push<&&T> for MirrorRegion<T>

where T: for<'a> Index + for<'a> IntoOwned<'a, Owned = T>,

fn push(&mut self, item: &&T) -> T

Push item into self, returning an index that allows to look up the corresponding read item.

impl<T> Push<&T> for MirrorRegion<T>

where T: for<'a> Index + for<'a> IntoOwned<'a, Owned = T>,

fn push(&mut self, item: &T) -> T

Push item into self, returning an index that allows to look up the corresponding read item.

impl<T> Push<T> for MirrorRegion<T>

where T: for<'a> Index + for<'a> IntoOwned<'a, Owned = T>,

fn push(&mut self, item: T) -> T

Push item into self, returning an index that allows to look up the corresponding read item.

impl<T> Region for MirrorRegion<T>

where T: for<'a> Index + for<'a> IntoOwned<'a, Owned = T>,

type Owned = T

An owned type that can be constructed from a read item.

type ReadItem<'a> = T where T: 'a

The type of the data that one gets out of the container.

type Index = T

The type to index into the container. Should be treated as an opaque type, even if known.

fn merge_regions<'a>( _regions: impl Iterator<Item = &'a MirrorRegion<T>> + Clone, ) -> MirrorRegion<T>

where MirrorRegion<T>: 'a,

Construct a region that can absorb the contents of regions in the future.

fn index( &self, index: <MirrorRegion<T> as Region>::Index, ) -> <MirrorRegion<T> as Region>::ReadItem<'_>

Index into the container. The index must be obtained by pushing data into the container.

fn reserve_regions<'a, I>(&mut self, _regions: I)

where MirrorRegion<T>: 'a, I: Iterator<Item = &'a MirrorRegion<T>> + Clone,

Ensure that the region can absorb the items of regions without reallocation

fn clear(&mut self)

Remove all elements from this region, but retain allocations if possible.

fn heap_size<F>(&self, _callback: F)

where F: FnMut(usize, usize),

Heap size, size - capacity

fn reborrow<'b, 'a>( item: <MirrorRegion<T> as Region>::ReadItem<'a>, ) -> <MirrorRegion<T> as Region>::ReadItem<'b>

where 'a: 'b, MirrorRegion<T>: 'a,

Converts a read item into one with a narrower lifetime.

impl<'a, T> ReserveItems<&'a T> for MirrorRegion<T>

where T: for<'b> Index + for<'b> IntoOwned<'b, Owned = T>,

fn reserve_items<I>(&mut self, _items: I)

where I: Iterator<Item = &'a T> + Clone,

Ensure that the region can absorb items without reallocation.

impl<T> ReserveItems<T> for MirrorRegion<T>

where T: for<'a> Index + for<'a> IntoOwned<'a, Owned = T>,

fn reserve_items<I>(&mut self, _items: I)

where I: Iterator<Item = T> + Clone,

Ensure that the region can absorb items without reallocation.

impl<T> Serialize for MirrorRegion<T>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Eq for MirrorRegion<T>

where T: Eq,

impl<T> StructuralPartialEq for MirrorRegion<T>