Struct h3ron::collections::H3CompactedVec

pub struct H3CompactedVec { /* fields omitted */ }

structure to keep compacted h3ron indexes to allow more or less efficient adding of further indexes

Implementations

impl<'a> H3CompactedVec

pub fn new() -> H3CompactedVec

pub fn append(&mut self, other: &mut Self, compact: bool)

append the contents of another Stack to this one

Indexes get moved, see Vec::append

will trigger a re-compacting when compact is true

pub fn compact(&mut self)

pub fn append_to_resolution(
    &mut self,
    resolution: u8,
    h3indexes: &mut Vec<H3Index>,
    compact: bool
)

append the contents of a vector

Indexes get moved, see Vec::append

pub fn len(&self) -> usize

pub fn len_resolutions(&self) -> Vec<usize>

length of the vectors for all resolutions. The index of the vec is the resolution

pub fn is_empty(&self) -> bool

pub fn contains(&self, h3index: H3Index) -> bool

check if the stack contains the index or any of its parents

This function is pretty inefficient.

pub fn add_index(&mut self, h3_index: H3Index, compact: bool)

add a single h3 index

will trigger a re-compacting when compact is set

pub fn add_index_to_resolution(
    &mut self,
    h3_index: H3Index,
    resolution: u8,
    compact: bool
)

add a single h3ron index

the resolution parameter must match the resolution of the index. This method only exists to skip the resolution check of add_index.

pub fn add_indexes(&mut self, h3_indexes: &[H3Index], compact: bool)

pub fn add_indexes_from_iter<T: IntoIterator<Item = H3Index>>(
    &mut self,
    iter: T,
    compact: bool
)

pub fn iter_compacted_indexes(&self) -> H3CompactedVecCompactedIterator<'_>

iterate over the compacted (or not, depending on if compact was called) contents

pub fn get_compacted_indexes_at_resolution(&self, resolution: u8) -> &[H3Index]

get the compacted indexes of the given resolution

parent indexes at lower resolutions will not be uncompacted

pub fn iter_uncompacted_indexes(
    &self,
    resolution: u8
) -> H3CompactedVecUncompactedIterator<'_>

iterate over the uncompacted indexes.

indexes at lower resolutions will be decompacted, indexes at higher resolutions will be ignored.

pub fn dedup(&mut self)

deduplicate the internal h3index vector

pub fn finest_resolution_contained(&self) -> Option<u8>

the finest resolution contained

Trait Implementations

impl Debug for H3CompactedVec

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

Formats the value using the given formatter.

impl Default for H3CompactedVec

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for H3CompactedVec

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

Deserialize this value from the given Serde deserializer.

impl From<Vec<u64, Global>> for H3CompactedVec

fn from(in_vec: Vec<H3Index>) -> Self

Performs the conversion.

impl FromIterator<Index> for H3CompactedVec

fn from_iter<T: IntoIterator<Item = Index>>(iter: T) -> Self

Creates a value from an iterator.

impl FromIterator<u64> for H3CompactedVec

fn from_iter<T: IntoIterator<Item = H3Index>>(iter: T) -> Self

Creates a value from an iterator.

impl PartialEq<H3CompactedVec> for H3CompactedVec

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

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

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

This method tests for !=.

impl Serialize for H3CompactedVec

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

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for H3CompactedVec

impl ToLinkedPolygons for H3CompactedVec

fn to_linked_polygons(&self, smoothen: bool) -> Vec<Polygon<f64>>