Struct holochain::prelude::dependencies::kitsune_p2p_types::dht::prelude::TelescopingTimes

pub struct TelescopingTimes { /* private fields */ }

A type which generates a sequence of exponentially expanding TimeSegments, with the smallest possible segment covering the most recent time, and larger segments as we go further back in time.

The segments completely cover the set of time quanta from 0 to the specified time parameter. The segments never overlap.

The set of segments grows logarithmically with the number of time quanta to be covered.

Implementations

impl TelescopingTimes

pub fn empty() -> TelescopingTimes

An empty set of times

pub fn new(time: TimeQuantum) -> TelescopingTimes

Constructor,

pub fn historical(topo: &Topology) -> TelescopingTimes

Get TelescopingTimes from the origin time up until times less than recent_threshold ago, to be handled by historical gossip. (Recent gossip will handle everything after the threshold.)

pub fn segments(&self) -> Vec<Segment<TimeOffset>, Global>

Calculate the exponentially expanding time segments using the binary representation of the current timestamp.

The intuition for this algorithm is that the position of the most significant 1 represents the power of the largest, leftmost time segment, and subsequent bits represent the powers of 2 below that one. After the MSB, a 0 represents a single value of the power represented by that bit, and a 1 represents two values of the power at that bit.

See the test below which has the first 16 time segments, each alongside the binary representation of the timestamp (+1) which generated it. Seeing the pattern in that test is the best way to understand this.

pub fn limit(&self, limit: u32) -> TelescopingTimes

Set a limit

pub fn rectify<T>(
    a: (&TelescopingTimes, &mut Vec<T, Global>),
    b: (&TelescopingTimes, &mut Vec<T, Global>)
)where
    T: AddAssign<T>,

Modify the region data associated with two different TelescopingTimes of different lengths, so that both data vectors are referring to the same regions.

In general, when one TelescopingTimes sequence is longer than another, the longer sequence will have larger TimeSegments than the shorter one. To rectify them, the shorter sequence needs to merge some of its earlier data until it has a segment large enough to match the larger segment of the other sequence. This continues until all segments of the smaller sequence are exhausted. Then, the longer sequence is truncated to match the shorter one.

Trait Implementations

impl Clone for TelescopingTimes

fn clone(&self) -> TelescopingTimes

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TelescopingTimes

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TelescopingTimes

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

Deserialize this value from the given Serde deserializer.

impl Ord for TelescopingTimes

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<TelescopingTimes> for TelescopingTimes

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd<TelescopingTimes> for TelescopingTimes

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl Serialize for TelescopingTimes

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 Copy for TelescopingTimes

impl Eq for TelescopingTimes

impl StructuralEq for TelescopingTimes

impl StructuralPartialEq for TelescopingTimes