Struct taxonomy::GeneralTaxonomy

pub struct GeneralTaxonomy {
    pub tax_ids: Vec<String>,
    pub parent_ids: Vec<usize>,
    pub parent_dists: Vec<f32>,
    pub ranks: Vec<TaxRank>,
    pub names: Vec<String>,
    // some fields omitted
}

A concrete implementation of the Taxonomy trait suitable for interconversions of different formats.

Fields

tax_ids: Vec<String>

parent_ids: Vec<usize>

parent_dists: Vec<f32>

ranks: Vec<TaxRank>

names: Vec<String>

Methods

impl GeneralTaxonomy

pub fn from_arrays(
    tax_ids: Vec<String>,
    parent_ids: Vec<usize>,
    names: Option<Vec<String>>,
    ranks: Option<Vec<TaxRank>>,
    dists: Option<Vec<f32>>
) -> Result<Self>

Initializer for a new GeneralTaxonomy.

All Vecs must be the same length or initialization will fail.

pub fn from_taxonomy<'t, T: 't, D: 't>(
    taxonomy: &'t impl Taxonomy<'t, T, D>
) -> Result<Self> where
    T: Clone + Debug + Display + PartialEq + Ord,
    D: Clone + Debug + Ord + Into<f64> + PartialOrd + PartialEq + Sum, 

Build a GeneralTaxonomy from any object that implements the Taxonomy trait.

pub fn from_internal_id(&self, tax_id: usize) -> Result<&str>

Given an internal tax_id (an array position) return the corresponding external tax_id (e.g. a NCBI taxonomy ID).

Because the Taxonomy trait is implemented for internal IDs also, the can be used to speed up some operations by avoiding a string lookup.

pub fn to_internal_id(&self, tax_id: &str) -> Result<usize>

Given an external tax_id (e.g. a NCBI taxonomy ID) return the corresponding internal tax_id (the position of that tax node in the internal array).

Because the Taxonomy trait is implemented for internal IDs also, the can be used to speed up some operations by avoiding a string lookup.

pub fn remove(&mut self, tax_id: usize) -> Result<()>

Remove a single node from the taxonomy.

Unlike pruning the children of the node are kept, but are rejoined onto the node's parent. The root node can not be removed

pub fn add(&mut self, parent_id: usize, tax_id: &str) -> Result<()>

Add a new node to the taxonomy.

Trait Implementations

impl Clone for GeneralTaxonomy

fn clone(&self) -> GeneralTaxonomy

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for GeneralTaxonomy

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

Formats the value using the given formatter.

impl Default for GeneralTaxonomy

fn default() -> Self

Create a new GeneralTaxonomy with only a root node.

impl<'de> Deserialize<'de> for GeneralTaxonomy

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

Deserialize this value from the given Serde deserializer.

impl Serialize for GeneralTaxonomy

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

Serialize this value into the given Serde serializer.

impl<'s> Taxonomy<'s, &'s str, f32> for GeneralTaxonomy

This is the implementation for &str taxonomy access for a more end-user understandable (but slightly slower) workflow.

fn root(&'s self) -> &'s str

Returns the root node of the entire tree.

fn children(&self, tax_id: &str) -> Result<Vec<&str>>

Returns a Vec of all the child IDs of the given tax_id.

fn parent(&self, tax_id: &str) -> Result<Option<(&str, f32)>>

Returns the parent of the given taxonomic node and the distance to said parent. The parent of the root node should always be None.

fn len(&self) -> usize

Returns the number of nodes in the taxonomy

fn name(&self, tax_id: &str) -> Result<&str>

Returns the name of the tax_id provided.

fn rank(&self, tax_id: &str) -> Result<TaxRank>

Returns the taxonomic rank of the tax_id provided.

fn lineage(&'t self, tax_id: T) -> Result<Vec<T>>

Returns a Vec of taxonomy nodes from the one provided back to root. This method must return the node itself as the first entry in the list and the root node as the last entry in the list.

fn parent_at_rank(&'t self, tax_id: T, rank: TaxRank) -> Result<Option<(T, D)>>

Returns the parent at a given taxonomic rank (note this may not be the immediate parent). This also returns the distance to that parent.

fn lca(&'t self, id1: T, id2: T) -> Result<T>

Returns the first common parent between two nodes. E.g. for the tree:

fn traverse(&'t self, node: T) -> Result<TaxonomyIterator<'t, T, D>> where
    Self: Sized, 

Generates an iterator that traces over the entire taxonomic tree. During preorder traversal, it returns (T, true) and during postorder traversal it returns (T, false)

fn is_empty(&'t self) -> bool where
    Self: Sized, 

Determines if there are any nodes at all in the taxonomy. This should almost always be implemented for performance reasons.

impl<'s> Taxonomy<'s, usize, f32> for GeneralTaxonomy

This is the implementation for "internal" tax ID lookup; these IDs are arbitrary (they're positions of the tax nodes in the internal array) and not linked at all to the "external" (e.g. NCBI) IDs. Using these IDs directly can lead to a decent speed up without having to build indicies.

fn root(&self) -> usize

Returns the root node of the entire tree.

fn children(&self, tax_id: usize) -> Result<Vec<usize>>

Returns a Vec of all the child IDs of the given tax_id.

fn parent(&self, tax_id: usize) -> Result<Option<(usize, f32)>>

Returns the parent of the given taxonomic node and the distance to said parent. The parent of the root node should always be None.

fn len(&self) -> usize

Returns the number of nodes in the taxonomy

fn name(&self, tax_id: usize) -> Result<&str>

Returns the name of the tax_id provided.

fn rank(&self, tax_id: usize) -> Result<TaxRank>

Returns the taxonomic rank of the tax_id provided.

fn lineage(&'t self, tax_id: T) -> Result<Vec<T>>

Returns a Vec of taxonomy nodes from the one provided back to root. This method must return the node itself as the first entry in the list and the root node as the last entry in the list.

fn parent_at_rank(&'t self, tax_id: T, rank: TaxRank) -> Result<Option<(T, D)>>

Returns the parent at a given taxonomic rank (note this may not be the immediate parent). This also returns the distance to that parent.

fn lca(&'t self, id1: T, id2: T) -> Result<T>

Returns the first common parent between two nodes. E.g. for the tree:

fn traverse(&'t self, node: T) -> Result<TaxonomyIterator<'t, T, D>> where
    Self: Sized, 

Generates an iterator that traces over the entire taxonomic tree. During preorder traversal, it returns (T, true) and during postorder traversal it returns (T, false)

fn is_empty(&'t self) -> bool where
    Self: Sized, 

Determines if there are any nodes at all in the taxonomy. This should almost always be implemented for performance reasons.