Struct kitsune_p2p_dht::region_set::RegionSetLtcs

pub struct RegionSetLtcs<D: RegionDataConstraints = RegionData> {
    pub coords: RegionCoordSetLtcs,
    pub data: Vec<Vec<Vec<D>>>,
    /* private fields */
}

Implementation for the compact LTCS region set format which gets sent over the wire. The coordinates for the regions are specified by a few values. The data to match the coordinates are specified in a 2D vector which must correspond to the generated coordinates.

Fields

coords: RegionCoordSetLtcs

The generator for the coordinates

data: Vec<Vec<Vec<D>>>

The outermost vec corresponds to arqs in the ArqSet; The middle vecs correspond to the spatial segments per arq; the innermost vecs are the time segments per arq.

Implementations

impl<D: RegionDataConstraints> RegionSetLtcs<D>

pub fn empty() -> Self

An empty LTCS region set

pub fn from_data(coords: RegionCoordSetLtcs, data: Vec<Vec<Vec<D>>>) -> Self

Construct the region set from existing data. The data must match the coords!

pub fn count(&self) -> usize

The total number of regions represented in this region set

pub fn regions(&self) -> impl Iterator<Item = Region<D>> + '_

Iterate over each region in the set

pub fn rectify(&mut self, other: &mut Self) -> GossipResult<()>

Reshape the two region sets so that both match, omitting or merging regions as needed

pub fn diff(self, other: Self) -> GossipResult<Vec<Region<D>>>

Given two region sets, return only the ones which are different between the two

pub fn nonzero_regions(
    &self
) -> impl '_ + Iterator<Item = ((usize, usize, usize), RegionCoords, D)>

Return only the regions which have ops in them. Useful for testing sparse scenarios.

impl<D: RegionDataConstraints> RegionSetLtcs<D>

pub fn from_store<O: OpRegion<D>, S: AccessOpStore<O, D>>(
    store: &S,
    coords: RegionCoordSetLtcs
) -> Self

Query the specified OpStore for each coord in the set, constructing the full RegionSet. Purely for convenience.

Trait Implementations

impl<D: Clone + RegionDataConstraints> Clone for RegionSetLtcs<D>

fn clone(&self) -> RegionSetLtcs<D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<D: RegionDataConstraints> Debug for RegionSetLtcs<D>

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

Formats the value using the given formatter.

impl<'de, D: RegionDataConstraints> Deserialize<'de> for RegionSetLtcs<D>where
    D: DeserializeOwned,

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

Deserialize this value from the given Serde deserializer.

impl<T: RegionDataConstraints> From<RegionSetLtcs<T>> for RegionSet<T>

fn from(original: RegionSetLtcs<T>) -> RegionSet<T>

Converts to this type from the input type.

impl<D: RegionDataConstraints> PartialEq<RegionSetLtcs<D>> for RegionSetLtcs<D>where
    D: PartialEq,

fn eq(&self, other: &Self) -> 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<D: RegionDataConstraints> Serialize for RegionSetLtcs<D>where
    D: Serialize,

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

Serialize this value into the given Serde serializer.

impl<D: RegionDataConstraints> Eq for RegionSetLtcs<D>where
    D: Eq,