Struct eyros::Mix6

pub struct Mix6<A, B, C, D, E, F> {
    pub v0: Mix<A>,
    pub v1: Mix<B>,
    pub v2: Mix<C>,
    pub v3: Mix<D>,
    pub v4: Mix<E>,
    pub v5: Mix<F>,
}

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.

Implementations

impl<A, B, C, D, E, F> Mix6<A, B, C, D, E, F>

pub fn new(
    v0: Mix<A>,
    v1: Mix<B>,
    v2: Mix<C>,
    v3: Mix<D>,
    v4: Mix<E>,
    v5: Mix<F>
) -> 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> Clone for Mix6<A, B, C, D, E, F>

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

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> Copy for Mix6<A, B, C, D, E, F>

impl<A, B, C, D, E, F> CountBytes for Mix6<A, B, C, D, E, F> where
    A: CountBytes,
    B: CountBytes,
    C: CountBytes,
    D: CountBytes,
    E: CountBytes,
    F: 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> Debug for Mix6<A, B, C, D, E, F>

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> Eq for Mix6<A, B, C, D, E, F>

impl<A, B, C, D, E, F> FromBytes for Mix6<A, B, C, D, E, F> where
    A: FromBytes,
    B: FromBytes,
    C: FromBytes,
    D: FromBytes,
    E: FromBytes,
    F: 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> Into<(Mix<A>, Mix<B>, Mix<C>, Mix<D>, Mix<E>, Mix<F>)> for Mix6<A, B, C, D, E, F>

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

Performs the conversion.

impl<A, B, C, D, E, F> Into<Mix6<A, B, C, D, E, F>> for (Mix<A>, Mix<B>, Mix<C>, Mix<D>, Mix<E>, Mix<F>)

fn into(self) -> Mix6<A, B, C, D, E, F>

Performs the conversion.

impl<A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq> PartialEq<Mix6<A, B, C, D, E, F>> for Mix6<A, B, C, D, E, F>

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

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

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

This method tests for !=.

impl<A, B, C, D, E, F> Point for Mix6<A, B, C, D, E, F> where
    ((A, A), (B, B), (C, C), (D, D), (E, E), (F, F)): 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>, 

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

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))

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> StructuralEq for Mix6<A, B, C, D, E, F>

impl<A, B, C, D, E, F> StructuralPartialEq for Mix6<A, B, C, D, E, F>

impl<A, B, C, D, E, F> ToBytes for Mix6<A, B, C, D, E, F> where
    A: ToBytes + CountBytes,
    B: ToBytes + CountBytes,
    C: ToBytes + CountBytes,
    D: ToBytes + CountBytes,
    E: ToBytes + CountBytes,
    F: 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.