geometric-traits 0.2.0

Trait-based algebraic and graph algorithms for Rust, supporting no_std environments
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

//! Submodule providing a general builder to build a generic graph.

use core::marker::PhantomData;

use crate::traits::{
    BipartiteGraph, BipartiteGraphBuilder, MonoplexBipartiteGraph, MonoplexGraphBuilder,
};

#[cfg_attr(feature = "mem_size", derive(mem_dbg::MemSize))]
#[cfg_attr(feature = "mem_size", mem_size(rec))]
#[cfg_attr(feature = "mem_dbg", derive(mem_dbg::MemDbg))]
#[derive(Clone)]
/// Basic builder for a generic graph.
pub struct GenericMonoplexBipartiteGraphBuilder<G: MonoplexBipartiteGraph> {
    /// The left nodes of the graph.
    left_nodes: Option<G::LeftNodes>,
    /// The right nodes of the graph.
    right_nodes: Option<G::RightNodes>,
    /// The edges of the graph.
    edges: Option<G::Edges>,
    /// Phantom data to store the graph type.
    _graph: PhantomData<G>,
}

impl<G: MonoplexBipartiteGraph> Default for GenericMonoplexBipartiteGraphBuilder<G> {
    #[inline]
    fn default() -> Self {
        Self { left_nodes: None, right_nodes: None, edges: None, _graph: PhantomData }
    }
}

impl<G: MonoplexBipartiteGraph> BipartiteGraphBuilder for GenericMonoplexBipartiteGraphBuilder<G> {
    type BipartiteGraph = G;

    #[inline]
    fn left_nodes(self, left_nodes: <Self::BipartiteGraph as BipartiteGraph>::LeftNodes) -> Self {
        Self { left_nodes: Some(left_nodes), ..self }
    }

    #[inline]
    fn right_nodes(
        self,
        right_nodes: <Self::BipartiteGraph as BipartiteGraph>::RightNodes,
    ) -> Self {
        Self { right_nodes: Some(right_nodes), ..self }
    }
}

impl<G: MonoplexBipartiteGraph> MonoplexGraphBuilder for GenericMonoplexBipartiteGraphBuilder<G> {
    type MonoplexGraph = G;

    #[inline]
    fn edges(self, edges: <Self::MonoplexGraph as crate::prelude::MonoplexGraph>::Edges) -> Self {
        Self { edges: Some(edges), ..self }
    }
}

#[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
/// Error type for the builder.
pub enum MonoplexBipartiteGraphBuilderError {
    /// A build error occurred.
    #[error("Missing attribute: {0}")]
    MissingAttribute(&'static str),
}

impl<G: MonoplexBipartiteGraph> GenericMonoplexBipartiteGraphBuilder<G>
where
    G: TryFrom<(G::LeftNodes, G::RightNodes, G::Edges), Error = MonoplexBipartiteGraphBuilderError>,
{
    /// Builds the graph.
    ///
    /// # Errors
    ///
    /// Returns [`MonoplexBipartiteGraphBuilderError`] if the graph cannot be
    /// built.
    #[inline]
    pub fn build(self) -> Result<G, MonoplexBipartiteGraphBuilderError> {
        G::try_from((
            self.left_nodes
                .ok_or(MonoplexBipartiteGraphBuilderError::MissingAttribute("left_nodes"))?,
            self.right_nodes
                .ok_or(MonoplexBipartiteGraphBuilderError::MissingAttribute("right_nodes"))?,
            self.edges.ok_or(MonoplexBipartiteGraphBuilderError::MissingAttribute("edges"))?,
        ))
    }
}