Struct Upds

pub struct Upds<O, T, D> {
    pub offs: O,
    pub times: T,
    pub diffs: D,
}

A container for non-empty lists of updates.

This container uses the special representiation of an empty slice to stand in for “the previous single element”. An empty slice is an otherwise invalid representation.

Fields

offs: O

Offsets used to provide indexes from values to updates.

times: T

Concatenated ordered lists of update times, bracketed by offsets in offs.

diffs: D

Concatenated ordered lists of update diffs, bracketed by offsets in offs.

Implementations

impl<O: for<'a> BatchContainer<ReadItem<'a> = usize>, T: BatchContainer, D: BatchContainer> Upds<O, T, D>

pub fn bounds(&self, index: usize) -> (usize, usize)

Lower and upper bounds in self.times and self.diffs of the indexed list.

pub fn get_rel( &self, list_idx: usize, item_idx: usize, ) -> (T::ReadItem<'_>, D::ReadItem<'_>)

Retrieves a value using relative indexes.

The first index identifies a list, and the second an item within the list. The method adds the list’s lower bound to the item index, and then calls get_abs. Using absolute indexes within the list’s bounds can be more efficient than using relative indexing.

pub fn len(&self) -> usize

Number of lists in the container.

pub fn get_abs(&self, index: usize) -> (T::ReadItem<'_>, D::ReadItem<'_>)

Retrieves a value using an absolute rather than relative index.

pub fn with_capacity(o_size: usize, u_size: usize) -> Self

Allocates with capacities for a number of lists and values.

pub fn merge_capacity(this: &Self, that: &Self) -> Self

Allocates with enough capacity to contain two inputs.

Trait Implementations

impl<O: Debug, T: Debug, D: Debug> Debug for Upds<O, T, D>

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

Formats the value using the given formatter.

impl<O: for<'a> BatchContainer<ReadItem<'a> = usize>, T: BatchContainer, D: BatchContainer> Default for Upds<O, T, D>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, O, T, D> Deserialize<'de> for Upds<O, T, D>

where O: Deserialize<'de>, T: Deserialize<'de>, D: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<O, T, D> Serialize for Upds<O, T, D>

where O: Serialize, T: Serialize, D: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.