[−][src]Trait eyros::Point

pub trait Point: Copy + Clone + Debug + Serialize + DeserializeOwned {
    type Bounds: Copy + Clone + Debug + Serialize + DeserializeOwned;
    type Range: Point + Copy + Clone + Debug + Serialize + DeserializeOwned;
    fn cmp_at(&self, other: &Self, level: usize) -> Ordering
    where
        Self: Sized;
    fn cmp_buf(
        bincode: &Config, 
        buf: &[u8], 
        bbox: &Self::Bounds, 
        level: usize
    ) -> Result<(bool, bool), Error>;
    fn midpoint_upper(&self, other: &Self) -> Self
    where
        Self: Sized;
    fn serialize_at(
        &self, 
        bincode: &Config, 
        level: usize
    ) -> Result<Vec<u8>, Error>;
    fn dim() -> usize;
    fn overlaps(&self, bbox: &Self::Bounds) -> bool;
    fn pivot_size_at(level: usize) -> usize;
    fn size_of() -> usize;
    fn bounds(coords: &Vec<Self>) -> Option<Self::Bounds>;
    fn bounds_to_range(bbox: Self::Bounds) -> Self::Range;
    fn format_at(
        bincode: &Config, 
        buf: &[u8], 
        level: usize
    ) -> Result<String, Error>;
}

Points (scalar or interval) must implement these methods. There's a lot going on here, so you'll most likely want to use one of the built-in implementations rather than write your own.

Below, the term "element" refs to a value contained in a point which could be a scalar or interval. For example, for the point ((-2.0,4.5), 6.0, (9.0,11.0)), each of (-2.0,4.5), 6.0, and (9.0,11.0) is an "element".

Presently only types with static sizes are supported.

Associated Types

`type Bounds: Copy + Clone + Debug + Serialize + DeserializeOwned`

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

`type Range: Point + Copy + Clone + Debug + Serialize + DeserializeOwned`

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

Loading content...

Required methods

`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 cmp_buf( bincode: &Config, buf: &[u8], bbox: &Self::Bounds, level: usize ) -> Result<(bool, bool), Error>`

Determine whether an element in a buffer slice greater than the bbox minimum and less than the bbox maximum for a particular tree depth. Each of these comparisons (isGTMin,isLTMax) is returned in the result type. A bincode configuration is required to avoid parsing the entire buffer where possible, as only a single element is needed.

`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, bincode: &Config, level: usize) -> Result<Vec<u8>, Error>`

Return the byte presentation for the element corresponding to the tree depth level.

`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 pivot_size_at(level: usize) -> usize`

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

`fn size_of() -> usize`

Return the size in bytes of the entire point when serialized.

`fn bounds(coords: &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:

((-1.0,0.0,-4.0),(3.0,0.8,2.5) (bbox)

becomes

((-1.0,3.0),(0.0,0.8),(-4.0,2.5)) (range)

`fn format_at( bincode: &Config, buf: &[u8], level: usize ) -> Result<String, Error>`

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

Loading content...

Implementations on Foreign Types

`impl<A, B> Point for (A, B) where A: Num<A>, B: Num,` [src]

`type Bounds = ((A, B), (A, B))`

`type Range = ((A, A), (B, B))`

[−][src]Trait eyros::Point

Associated Types

type Bounds: Copy + Clone + Debug + Serialize + DeserializeOwned

type Range: Point + Copy + Clone + Debug + Serialize + DeserializeOwned

Required methods

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

fn cmp_buf( bincode: &Config, buf: &[u8], bbox: &Self::Bounds, level: usize) -> Result<(bool, bool), Error>

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

fn serialize_at(&self, bincode: &Config, level: usize) -> Result<Vec<u8>, Error>

fn dim() -> usize

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

fn pivot_size_at(level: usize) -> usize

fn size_of() -> usize

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

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

fn format_at( bincode: &Config, buf: &[u8], level: usize) -> Result<String, Error>

Implementations on Foreign Types

impl<A, B> Point for (A, B) where A: Num<A>, B: Num<B>, [src]

type Bounds = ((A, B), (A, B))

type Range = ((A, A), (B, B))

fn cmp_at(&self, other: &Self, level: usize) -> Ordering[src]

fn cmp_buf( bincode: &Config, buf: &[u8], bbox: &Self::Bounds, level: usize) -> Result<(bool, bool), Error>[src]

fn midpoint_upper(&self, other: &Self) -> Self[src]

fn serialize_at(&self, bincode: &Config, level: usize) -> Result<Vec<u8>, Error>[src]

fn dim() -> usize[src]

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

fn pivot_size_at(i: usize) -> usize[src]

fn size_of() -> usize[src]

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

fn bounds_to_range(bounds: Self::Bounds) -> Self::Range[src]

fn format_at( bincode: &Config, buf: &[u8], level: usize) -> Result<String, Error>[src]

impl<A, B> Point for (A, (B, B)) where A: Num<A>, B: Num<B>, [src]

type Bounds = ((A, B), (A, B))

type Range = ((A, A), (B, B))

fn cmp_at(&self, other: &Self, level: usize) -> Ordering[src]

fn cmp_buf( bincode: &Config, buf: &[u8], bbox: &Self::Bounds, level: usize) -> Result<(bool, bool), Error>[src]

fn midpoint_upper(&self, other: &Self) -> Self[src]

fn serialize_at(&self, bincode: &Config, level: usize) -> Result<Vec<u8>, Error>[src]

fn dim() -> usize[src]

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

fn pivot_size_at(i: usize) -> usize[src]

fn size_of() -> usize[src]

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

fn bounds_to_range(bounds: Self::Bounds) -> Self::Range[src]

fn format_at( bincode: &Config, buf: &[u8], level: usize) -> Result<String, Error>[src]

impl<A, B> Point for ((A, A), B) where A: Num<A>, B: Num<B>, [src]

type Bounds = ((A, B), (A, B))

type Range = ((A, A), (B, B))

fn cmp_at(&self, other: &Self, level: usize) -> Ordering[src]

fn cmp_buf( bincode: &Config, buf: &[u8], bbox: &Self::Bounds, level: usize) -> Result<(bool, bool), Error>[src]

fn midpoint_upper(&self, other: &Self) -> Self[src]

fn serialize_at(&self, bincode: &Config, level: usize) -> Result<Vec<u8>, Error>[src]

fn dim() -> usize[src]

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

fn pivot_size_at(i: usize) -> usize[src]

fn size_of() -> usize[src]

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

fn bounds_to_range(bounds: Self::Bounds) -> Self::Range[src]

fn format_at( bincode: &Config, buf: &[u8], level: usize) -> Result<String, Error>[src]

impl<A, B> Point for ((A, A), (B, B)) where A: Num<A>, B: Num<B>, [src]

type Bounds = ((A, B), (A, B))

type Range = ((A, A), (B, B))

fn cmp_at(&self, other: &Self, level: usize) -> Ordering[src]

fn cmp_buf( bincode: &Config, buf: &[u8], bbox: &Self::Bounds, level: usize) -> Result<(bool, bool), Error>[src]

fn midpoint_upper(&self, other: &Self) -> Self[src]

fn serialize_at(&self, bincode: &Config, level: usize) -> Result<Vec<u8>, Error>[src]

fn dim() -> usize[src]

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

fn pivot_size_at(i: usize) -> usize[src]

fn size_of() -> usize[src]

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

fn bounds_to_range(bounds: Self::Bounds) -> Self::Range[src]

fn format_at( bincode: &Config, buf: &[u8], level: usize) -> Result<String, Error>[src]

impl<A, B, C> Point for (A, B, C) where A: Num<A>, B: Num<B>, C: Num<C>, [src]

type Bounds = ((A, B, C), (A, B, C))

type Range = ((A, A), (B, B), (C, C))

fn cmp_at(&self, other: &Self, level: usize) -> Ordering[src]

fn cmp_buf( bincode: &Config, buf: &[u8], bbox: &Self::Bounds, level: usize) -> Result<(bool, bool), Error>[src]

fn midpoint_upper(&self, other: &Self) -> Self[src]

fn serialize_at(&self, bincode: &Config, level: usize) -> Result<Vec<u8>, Error>[src]

`type Bounds: Copy + Clone + Debug + Serialize + DeserializeOwned`

`type Range: Point + Copy + Clone + Debug + Serialize + DeserializeOwned`

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

`fn cmp_buf( bincode: &Config, buf: &[u8], bbox: &Self::Bounds, level: usize ) -> Result<(bool, bool), Error>`

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

`fn serialize_at(&self, bincode: &Config, level: usize) -> Result<Vec<u8>, Error>`

`fn dim() -> usize`

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

`fn pivot_size_at(level: usize) -> usize`

`fn size_of() -> usize`

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

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

`fn format_at( bincode: &Config, buf: &[u8], level: usize ) -> Result<String, Error>`

`impl<A, B> Point for (A, B) where A: Num<A>, B: Num<B>,` [src]

`type Bounds = ((A, B), (A, B))`

`type Range = ((A, A), (B, B))`

`fn cmp_at(&self, other: &Self, level: usize) -> Ordering`[src]

`fn cmp_buf( bincode: &Config, buf: &[u8], bbox: &Self::Bounds, level: usize ) -> Result<(bool, bool), Error>`[src]

`fn midpoint_upper(&self, other: &Self) -> Self`[src]

`fn serialize_at(&self, bincode: &Config, level: usize) -> Result<Vec<u8>, Error>`[src]

`fn dim() -> usize`[src]

`fn overlaps(&self, bbox: &Self::Bounds) -> bool`[src]

`fn pivot_size_at(i: usize) -> usize`[src]

`fn size_of() -> usize`[src]

`fn bounds(points: &Vec<Self>) -> Option<Self::Bounds>`[src]

`fn bounds_to_range(bounds: Self::Bounds) -> Self::Range`[src]

`fn format_at( bincode: &Config, buf: &[u8], level: usize ) -> Result<String, Error>`[src]

`impl<A, B> Point for (A, (B, B)) where A: Num<A>, B: Num<B>,` [src]

`type Bounds = ((A, B), (A, B))`

`type Range = ((A, A), (B, B))`

`fn cmp_at(&self, other: &Self, level: usize) -> Ordering`[src]

`fn cmp_buf( bincode: &Config, buf: &[u8], bbox: &Self::Bounds, level: usize ) -> Result<(bool, bool), Error>`[src]

`fn midpoint_upper(&self, other: &Self) -> Self`[src]

`fn serialize_at(&self, bincode: &Config, level: usize) -> Result<Vec<u8>, Error>`[src]

`fn dim() -> usize`[src]

`fn overlaps(&self, bbox: &Self::Bounds) -> bool`[src]

`fn pivot_size_at(i: usize) -> usize`[src]

`fn size_of() -> usize`[src]

`fn bounds(points: &Vec<Self>) -> Option<Self::Bounds>`[src]

`fn bounds_to_range(bounds: Self::Bounds) -> Self::Range`[src]

`fn format_at( bincode: &Config, buf: &[u8], level: usize ) -> Result<String, Error>`[src]

`impl<A, B> Point for ((A, A), B) where A: Num<A>, B: Num<B>,` [src]

`type Bounds = ((A, B), (A, B))`

`type Range = ((A, A), (B, B))`

`fn cmp_at(&self, other: &Self, level: usize) -> Ordering`[src]

`fn cmp_buf( bincode: &Config, buf: &[u8], bbox: &Self::Bounds, level: usize ) -> Result<(bool, bool), Error>`[src]

`fn midpoint_upper(&self, other: &Self) -> Self`[src]

`fn serialize_at(&self, bincode: &Config, level: usize) -> Result<Vec<u8>, Error>`[src]

`fn dim() -> usize`[src]

`fn overlaps(&self, bbox: &Self::Bounds) -> bool`[src]

`fn pivot_size_at(i: usize) -> usize`[src]

`fn size_of() -> usize`[src]

`fn bounds(points: &Vec<Self>) -> Option<Self::Bounds>`[src]

`fn bounds_to_range(bounds: Self::Bounds) -> Self::Range`[src]

`fn format_at( bincode: &Config, buf: &[u8], level: usize ) -> Result<String, Error>`[src]

`impl<A, B> Point for ((A, A), (B, B)) where A: Num<A>, B: Num<B>,` [src]

`type Bounds = ((A, B), (A, B))`

`type Range = ((A, A), (B, B))`

`fn cmp_at(&self, other: &Self, level: usize) -> Ordering`[src]

`fn cmp_buf( bincode: &Config, buf: &[u8], bbox: &Self::Bounds, level: usize ) -> Result<(bool, bool), Error>`[src]

`fn midpoint_upper(&self, other: &Self) -> Self`[src]

`fn serialize_at(&self, bincode: &Config, level: usize) -> Result<Vec<u8>, Error>`[src]

`fn dim() -> usize`[src]

`fn overlaps(&self, bbox: &Self::Bounds) -> bool`[src]

`fn pivot_size_at(i: usize) -> usize`[src]

`fn size_of() -> usize`[src]

`fn bounds(points: &Vec<Self>) -> Option<Self::Bounds>`[src]

`fn bounds_to_range(bounds: Self::Bounds) -> Self::Range`[src]

`fn format_at( bincode: &Config, buf: &[u8], level: usize ) -> Result<String, Error>`[src]

`impl<A, B, C> Point for (A, B, C) where A: Num<A>, B: Num<B>, C: Num<C>,` [src]

`type Bounds = ((A, B, C), (A, B, C))`

`type Range = ((A, A), (B, B), (C, C))`

`fn cmp_at(&self, other: &Self, level: usize) -> Ordering`[src]

`fn cmp_buf( bincode: &Config, buf: &[u8], bbox: &Self::Bounds, level: usize ) -> Result<(bool, bool), Error>`[src]

`fn midpoint_upper(&self, other: &Self) -> Self`[src]

`fn serialize_at(&self, bincode: &Config, level: usize) -> Result<Vec<u8>, Error>`[src]

`fn dim() -> usize`[src]

`fn overlaps(&self, bbox: &Self::Bounds) -> bool`[src]

`fn pivot_size_at(i: usize) -> usize`[src]

`fn size_of() -> usize`[src]