Trait LabelledSimplexCollection 

pub trait LabelledSimplexCollection<'f, FS: OrderedRingSignature + FieldSignature + 'f, T: Eq + Clone + Send + Sync>: Sized
where
    FS::Set: Hash,
{
    type WithLabel<S: Eq + Clone + Send + Sync>: LabelledSimplexCollection<'f, FS, S>;
    type SubsetType: LabelledSimplexCollection<'f, FS, T>;

    // Required methods
    fn try_new_labelled(
        ambient_space: AffineSpace<'f, FS>,
        simplexes: HashMap<Simplex<'f, FS>, T>,
    ) -> Result<Self, &'static str>;
    fn new_labelled_unchecked(
        ambient_space: AffineSpace<'f, FS>,
        simplexes: HashMap<Simplex<'f, FS>, T>,
    ) -> Self;
    fn ambient_space(&self) -> AffineSpace<'f, FS>;
    fn labelled_simplexes(&self) -> HashMap<&Simplex<'f, FS>, &T>;
    fn into_labelled_simplexes(self) -> HashMap<Simplex<'f, FS>, T>;
    fn into_partial_simplicial_complex(
        self,
    ) -> LabelledPartialSimplicialComplex<'f, FS, T>;
    fn to_partial_simplicial_complex(
        &self,
    ) -> LabelledPartialSimplicialComplex<'f, FS, T>;
    fn into_simplicial_disjoint_union(
        self,
    ) -> LabelledSimplicialDisjointUnion<'f, FS, T>;
    fn to_simplicial_disjoint_union(
        &self,
    ) -> LabelledSimplicialDisjointUnion<'f, FS, T>;

    // Provided methods
    fn try_new(
        ambient_space: AffineSpace<'f, FS>,
        simplexes: HashSet<Simplex<'f, FS>>,
    ) -> Result<Self::WithLabel<()>, &'static str> { ... }
    fn new_unchecked(
        ambient_space: AffineSpace<'f, FS>,
        simplexes: HashSet<Simplex<'f, FS>>,
    ) -> Self::WithLabel<()> { ... }
    fn simplexes<'a>(&'a self) -> HashSet<&'a Simplex<'f, FS>>
       where T: 'a { ... }
    fn into_simplexes(self) -> HashSet<Simplex<'f, FS>> { ... }
    fn subset_by_label(
        &self,
        label: &T,
    ) -> <Self::SubsetType as LabelledSimplexCollection<'f, FS, T>>::WithLabel<()> { ... }
    fn into_subset_by_label(
        self,
        label: &T,
    ) -> <Self::SubsetType as LabelledSimplexCollection<'f, FS, T>>::WithLabel<()> { ... }
    fn subset_by_filter(&self, f: impl Fn(&T) -> bool) -> Self::SubsetType { ... }
    fn into_subset_by_filter(self, f: impl Fn(&T) -> bool) -> Self::SubsetType { ... }
    fn apply_label_function<S: Eq + Clone + Send + Sync>(
        &self,
        f: impl Fn(&T) -> S,
    ) -> Self::WithLabel<S> { ... }
    fn into_apply_label_function<S: Eq + Clone + Send + Sync>(
        self,
        f: impl Fn(T) -> S,
    ) -> Self::WithLabel<S> { ... }
    fn forget_labels(&self) -> Self::WithLabel<()> { ... }
    fn into_forget_labels(self) -> Self::WithLabel<()> { ... }
    fn common_label<'a>(
        &'a self,
        simplexes: impl Iterator<Item = &'a Simplex<'f, FS>>,
    ) -> Option<&'a T>
       where FS: 'a,
             AffineSpace<'f, FS>: 'a,
             'f: 'a { ... }
}

A collection of disjoint simplices labelled by T

Required Associated Types

type WithLabel<S: Eq + Clone + Send + Sync>: LabelledSimplexCollection<'f, FS, S>

type SubsetType: LabelledSimplexCollection<'f, FS, T>

Required Methods

fn try_new_labelled( ambient_space: AffineSpace<'f, FS>, simplexes: HashMap<Simplex<'f, FS>, T>, ) -> Result<Self, &'static str>

fn new_labelled_unchecked( ambient_space: AffineSpace<'f, FS>, simplexes: HashMap<Simplex<'f, FS>, T>, ) -> Self

fn ambient_space(&self) -> AffineSpace<'f, FS>

fn labelled_simplexes(&self) -> HashMap<&Simplex<'f, FS>, &T>

fn into_labelled_simplexes(self) -> HashMap<Simplex<'f, FS>, T>

fn into_partial_simplicial_complex( self, ) -> LabelledPartialSimplicialComplex<'f, FS, T>

fn to_partial_simplicial_complex( &self, ) -> LabelledPartialSimplicialComplex<'f, FS, T>

fn into_simplicial_disjoint_union( self, ) -> LabelledSimplicialDisjointUnion<'f, FS, T>

fn to_simplicial_disjoint_union( &self, ) -> LabelledSimplicialDisjointUnion<'f, FS, T>

Provided Methods

fn try_new( ambient_space: AffineSpace<'f, FS>, simplexes: HashSet<Simplex<'f, FS>>, ) -> Result<Self::WithLabel<()>, &'static str>

fn new_unchecked( ambient_space: AffineSpace<'f, FS>, simplexes: HashSet<Simplex<'f, FS>>, ) -> Self::WithLabel<()>

fn simplexes<'a>(&'a self) -> HashSet<&'a Simplex<'f, FS>>

where T: 'a,

fn into_simplexes(self) -> HashSet<Simplex<'f, FS>>

fn subset_by_label( &self, label: &T, ) -> <Self::SubsetType as LabelledSimplexCollection<'f, FS, T>>::WithLabel<()>

fn into_subset_by_label( self, label: &T, ) -> <Self::SubsetType as LabelledSimplexCollection<'f, FS, T>>::WithLabel<()>

fn subset_by_filter(&self, f: impl Fn(&T) -> bool) -> Self::SubsetType

fn into_subset_by_filter(self, f: impl Fn(&T) -> bool) -> Self::SubsetType

fn apply_label_function<S: Eq + Clone + Send + Sync>( &self, f: impl Fn(&T) -> S, ) -> Self::WithLabel<S>

fn into_apply_label_function<S: Eq + Clone + Send + Sync>( self, f: impl Fn(T) -> S, ) -> Self::WithLabel<S>

fn forget_labels(&self) -> Self::WithLabel<()>

fn into_forget_labels(self) -> Self::WithLabel<()>

fn common_label<'a>( &'a self, simplexes: impl Iterator<Item = &'a Simplex<'f, FS>>, ) -> Option<&'a T>

where FS: 'a, AffineSpace<'f, FS>: 'a, 'f: 'a,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<'f, FS: OrderedRingSignature + FieldSignature, T: Eq + Clone + Send + Sync> LabelledSimplexCollection<'f, FS, T> for LabelledPartialSimplicialComplex<'f, FS, T>

where FS::Set: Hash,

type WithLabel<S: Eq + Clone + Send + Sync> = LabelledPartialSimplicialComplex<'f, FS, S>

type SubsetType = LabelledPartialSimplicialComplex<'f, FS, T>

impl<'f, FS: OrderedRingSignature + FieldSignature, T: Eq + Clone + Send + Sync> LabelledSimplexCollection<'f, FS, T> for LabelledSimplicialComplex<'f, FS, T>

where FS::Set: Hash,

type WithLabel<S: Eq + Clone + Send + Sync> = LabelledSimplicialComplex<'f, FS, S>

type SubsetType = LabelledPartialSimplicialComplex<'f, FS, T>

impl<'f, FS: OrderedRingSignature + FieldSignature, T: Eq + Clone + Send + Sync> LabelledSimplexCollection<'f, FS, T> for LabelledSimplicialDisjointUnion<'f, FS, T>

where FS::Set: Hash,

type WithLabel<S: Eq + Clone + Send + Sync> = LabelledSimplicialDisjointUnion<'f, FS, S>

type SubsetType = LabelledSimplicialDisjointUnion<'f, FS, T>