Struct eyros::Mix8

pub struct Mix8<A, B, C, D, E, F, G, H> {
    pub v0: Mix<A>,
    pub v1: Mix<B>,
    pub v2: Mix<C>,
    pub v3: Mix<D>,
    pub v4: Mix<E>,
    pub v5: Mix<F>,
    pub v6: Mix<G>,
    pub v7: Mix<H>,
}

Mix coordinate container

Fields

v0: Mix<A>

Access the i-th element.

v1: Mix<B>

Access the i-th element.

v2: Mix<C>

Access the i-th element.

v3: Mix<D>

Access the i-th element.

v4: Mix<E>

Access the i-th element.

v5: Mix<F>

Access the i-th element.

v6: Mix<G>

Access the i-th element.

v7: Mix<H>

Access the i-th element.

Implementations

impl<A, B, C, D, E, F, G, H> Mix8<A, B, C, D, E, F, G, H>

pub fn new(
    v0: Mix<A>,
    v1: Mix<B>,
    v2: Mix<C>,
    v3: Mix<D>,
    v4: Mix<E>,
    v5: Mix<F>,
    v6: Mix<G>,
    v7: Mix<H>
) -> Self

Create a new Mix container from a Mix element for each dimension.

Trait Implementations

impl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone, F: Clone, G: Clone, H: Clone> Clone for Mix8<A, B, C, D, E, F, G, H>

fn clone(&self) -> Mix8<A, B, C, D, E, F, G, H>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Copy, B: Copy, C: Copy, D: Copy, E: Copy, F: Copy, G: Copy, H: Copy> Copy for Mix8<A, B, C, D, E, F, G, H>

impl<A, B, C, D, E, F, G, H> CountBytes for Mix8<A, B, C, D, E, F, G, H> where
    A: CountBytes,
    B: CountBytes,
    C: CountBytes,
    D: CountBytes,
    E: CountBytes,
    F: CountBytes,
    G: CountBytes,
    H: CountBytes, 

fn count_bytes(&self) -> usize

Return the number of bytes that the serialization would require.

fn count_from_bytes(buf: &[u8]) -> Result<usize, Error>

Return how many bytes from buf would be required to deserialize Self.

fn count_from_bytes_more(buf: &[u8]) -> Result<Option<usize>, Error>

Return how many bytes from buf would be required to deserialize Self, where if there are not enough bytes in buf to know how many bytes would be required, you will receive None or otherwise Some(nbytes).

impl<A: Debug, B: Debug, C: Debug, D: Debug, E: Debug, F: Debug, G: Debug, H: Debug> Debug for Mix8<A, B, C, D, E, F, G, H>

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

Formats the value using the given formatter.

impl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq> Eq for Mix8<A, B, C, D, E, F, G, H>

impl<A, B, C, D, E, F, G, H> FromBytes for Mix8<A, B, C, D, E, F, G, H> where
    A: FromBytes,
    B: FromBytes,
    C: FromBytes,
    D: FromBytes,
    E: FromBytes,
    F: FromBytes,
    G: FromBytes,
    H: FromBytes, 

fn from_bytes(src: &[u8]) -> Result<(usize, Self), Error>

Read data from src in order to create an instance Self. The usize in the Result is the number of bytes read from src.

impl<A, B, C, D, E, F, G, H> Into<(Mix<A>, Mix<B>, Mix<C>, Mix<D>, Mix<E>, Mix<F>, Mix<G>, Mix<H>)> for Mix8<A, B, C, D, E, F, G, H>

fn into(
    self
) -> (Mix<A>, Mix<B>, Mix<C>, Mix<D>, Mix<E>, Mix<F>, Mix<G>, Mix<H>)

Performs the conversion.

impl<A, B, C, D, E, F, G, H> Into<Mix8<A, B, C, D, E, F, G, H>> for (Mix<A>, Mix<B>, Mix<C>, Mix<D>, Mix<E>, Mix<F>, Mix<G>, Mix<H>)

fn into(self) -> Mix8<A, B, C, D, E, F, G, H>

Performs the conversion.

impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq> PartialEq<Mix8<A, B, C, D, E, F, G, H>> for Mix8<A, B, C, D, E, F, G, H>

fn eq(&self, other: &Mix8<A, B, C, D, E, F, G, H>) -> bool

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

fn ne(&self, other: &Mix8<A, B, C, D, E, F, G, H>) -> bool

This method tests for !=.

impl<A, B, C, D, E, F, G, H> Point for Mix8<A, B, C, D, E, F, G, H> where
    ((A, A), (B, B), (C, C), (D, D), (E, E), (F, F), (G, G), (H, H)): Point,
    A: ToBytes + FromBytes + CountBytes + Copy + Send + Sync + Debug + PartialOrd + Add<Output = A> + Div<Output = A> + From<u8>,
    B: ToBytes + FromBytes + CountBytes + Copy + Send + Sync + Debug + PartialOrd + Add<Output = B> + Div<Output = B> + From<u8>,
    C: ToBytes + FromBytes + CountBytes + Copy + Send + Sync + Debug + PartialOrd + Add<Output = C> + Div<Output = C> + From<u8>,
    D: ToBytes + FromBytes + CountBytes + Copy + Send + Sync + Debug + PartialOrd + Add<Output = D> + Div<Output = D> + From<u8>,
    E: ToBytes + FromBytes + CountBytes + Copy + Send + Sync + Debug + PartialOrd + Add<Output = E> + Div<Output = E> + From<u8>,
    F: ToBytes + FromBytes + CountBytes + Copy + Send + Sync + Debug + PartialOrd + Add<Output = F> + Div<Output = F> + From<u8>,
    G: ToBytes + FromBytes + CountBytes + Copy + Send + Sync + Debug + PartialOrd + Add<Output = G> + Div<Output = G> + From<u8>,
    H: ToBytes + FromBytes + CountBytes + Copy + Send + Sync + Debug + PartialOrd + Add<Output = H> + Div<Output = H> + From<u8>, 

type Bounds = ((A, B, C, D, E, F, G, H), (A, B, C, D, E, F, G, H))

Bounding-box corresponding to (min,max) as used by db.query(bbox).

type Range = ((A, A), (B, B), (C, C), (D, D), (E, E), (F, F), (G, G), (H, H))

Range corresponding to ((minX,maxX),(minY,maxY),...)

fn cmp_at(&self, other: &Self, level: usize) -> Ordering where
    Self: Sized, 

Compare elements at a level of tree depth. The dimension under consideration alternates each level, so you'll likely want the element at an index corresponding to level % dimension.

fn midpoint_upper(&self, other: &Self) -> Self where
    Self: Sized, 

For intervals, calculate the midpoint of the greater (upper) interval bound (ex: iv.1) for two intervals, returning a new interval where both elements are the midpoint result. For scalars, return the midpoint of two scalars as a scalar.

fn serialize_at(&self, level: usize, dst: &mut [u8]) -> Result<usize, Error>

Return the byte presentation for the element corresponding to the tree depth level for the purpose of making a pivot. If you have an interval type, return the upper bound.

fn dim() -> usize

Get the number of dimensions for this point type.

fn overlaps(&self, bbox: &Self::Bounds) -> bool

Return whether the current point intersects with a bounding box.

fn query_branch(
    buf: &[u8],
    bbox: &Self::Bounds,
    bf: usize,
    level: usize
) -> Result<(Vec<Cursor>, Vec<Block>), Error>

Return a set of (branch_offset,tree_depth) tuples (Cursors) for sub-branches to load next and a set of u64 (Blocks) to read data from according to a traversal of the branch data in buf at the tree depth level and subject to the bounds given in bbox.

fn pivot_bytes_at(&self, level: usize) -> usize

Return the size in bytes of the pivot-form of the element corresponding to the tree depth level.

fn count_bytes_at(buf: &[u8], level: usize) -> Result<usize, Error>

Calculate the number of bytes to read from buf for the tree depth level.

fn bounds(points: &Vec<Self>) -> Option<Self::Bounds>

Return a bounding box for a set of coordinates, if possible.

fn bounds_to_range(bbox: Self::Bounds) -> Self::Range

Return a Range corresponding to a bounding box. This involves transposing the items. For example:

fn format_at(_buf: &[u8], _level: usize) -> Result<String, Error>

Return a string representation of the element in a buffer slice corresponding to the tree depth level.

impl<A, B, C, D, E, F, G, H> StructuralEq for Mix8<A, B, C, D, E, F, G, H>

impl<A, B, C, D, E, F, G, H> StructuralPartialEq for Mix8<A, B, C, D, E, F, G, H>

impl<A, B, C, D, E, F, G, H> ToBytes for Mix8<A, B, C, D, E, F, G, H> where
    A: ToBytes + CountBytes,
    B: ToBytes + CountBytes,
    C: ToBytes + CountBytes,
    D: ToBytes + CountBytes,
    E: ToBytes + CountBytes,
    F: ToBytes + CountBytes,
    G: ToBytes + CountBytes,
    H: ToBytes + CountBytes, 

fn to_bytes(&self) -> Result<Vec<u8>, Error>

Serialize into a newly-allocated byte vector.

fn write_bytes(&self, dst: &mut [u8]) -> Result<usize, Error>

Serialize into an existing mutable byte slice. The usize Result contains how many bytes were written to dst.