Struct wautomata::canonical::NodeFactory

pub struct NodeFactory<NodeId = IdentityWithInt, EdgeId = IdentityWithInt, Kind = NodeKindless> where
    NodeId: IdentityInterface,
    EdgeId: IdentityInterface + IdentityGenerableInterface,
    Kind: NodeKindInterface,
    NodeFactory<NodeId, EdgeId, Kind>: NodeFactoryInterface,  {
    pub id_to_node_map: IndexMap<NodeId, Node<NodeId, EdgeId, Kind>, RandomState>,
    pub id_to_edge_map: IndexMap<EdgeId, Edge<EdgeId, NodeId, Kind>, RandomState>,
    pub _current_edge_id: EdgeId,
}

Node factory.

Fields

id_to_node_map: IndexMap<NodeId, Node<NodeId, EdgeId, Kind>, RandomState>

Map id to node.

id_to_edge_map: IndexMap<EdgeId, Edge<EdgeId, NodeId, Kind>, RandomState>

Map id to edge.

_current_edge_id: EdgeId

Generator of edge ids.

Trait Implementations

impl<NodeId, EdgeId, Kind> Debug for NodeFactory<NodeId, EdgeId, Kind> where
    NodeId: IdentityInterface,
    EdgeId: IdentityInterface + IdentityGenerableInterface,
    Kind: NodeKindInterface, 

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

Formats the value using the given formatter.

impl<NodeId, EdgeId, Kind> GraphEdgesEnumerableInterface for NodeFactory<NodeId, EdgeId, Kind> where
    EdgeId: IdentityInterface + IdentityGenerableInterface,
    NodeId: IdentityInterface,
    Kind: NodeKindInterface, 

fn edges<'a, 'b>(
    &'a self
) -> Box<dyn Iterator<Item = (<<NodeFactory<NodeId, EdgeId, Kind> as GraphEdgesNominalInterface>::EdgeHandle as HasId>::Id, &'a <NodeFactory<NodeId, EdgeId, Kind> as GraphEdgesNominalInterface>::EdgeHandle)> + 'b, Global> where
    'a: 'b, 

Iterate over all edges.

fn nedges(&self) -> usize

Number of edges. Size of the graph.

impl<NodeId, EdgeId, Kind> GraphEdgesExtendableInterface for NodeFactory<NodeId, EdgeId, Kind> where
    NodeId: IdentityInterface,
    EdgeId: IdentityInterface + IdentityGenerableInterface,
    Kind: NodeKindInterface, 

fn _edge_id_generate(
    &mut self,
    _in_node: <<NodeFactory<NodeId, EdgeId, Kind> as GraphNodesNominalInterface>::NodeHandle as HasId>::Id,
    _out_node: <<NodeFactory<NodeId, EdgeId, Kind> as GraphNodesNominalInterface>::NodeHandle as HasId>::Id
) -> <<NodeFactory<NodeId, EdgeId, Kind> as GraphEdgesNominalInterface>::EdgeHandle as HasId>::Id

Either make new or get existing edge for specified nodes.

fn _edge_add(
    &mut self,
    edge_id: <<NodeFactory<NodeId, EdgeId, Kind> as GraphEdgesNominalInterface>::EdgeHandle as HasId>::Id,
    in_node: <<NodeFactory<NodeId, EdgeId, Kind> as GraphNodesNominalInterface>::NodeHandle as HasId>::Id,
    out_node: <<NodeFactory<NodeId, EdgeId, Kind> as GraphNodesNominalInterface>::NodeHandle as HasId>::Id
)

Either make new or get existing edge for specified nodes.

fn _edge_make_for_nodes<IntoNodeId1, IntoNodeId2>(
    &mut self,
    node1: IntoNodeId1,
    node2: IntoNodeId2
) -> <Self::EdgeHandle as HasId>::Id where
    IntoNodeId1: Into<<Self::NodeHandle as HasId>::Id>,
    IntoNodeId2: Into<<Self::NodeHandle as HasId>::Id>, 

Either make new or get existing edge for specified nodes.

impl<NodeId, EdgeId, Kind> GraphEdgesNominalInterface for NodeFactory<NodeId, EdgeId, Kind> where
    EdgeId: IdentityInterface + IdentityGenerableInterface,
    NodeId: IdentityInterface,
    Kind: NodeKindInterface, 

type EdgeHandle = Edge<EdgeId, NodeId, Kind>

Handle of an edge - entity representing an edge or the edge itself. It’s not always possible to operate an edge directly, for example it it has to be wrapped by cell ref. For that use NodeHandle. Otherwise EdgeHandle could be &Node.

fn edge<IntoId>(
    &self,
    id: IntoId
) -> &<NodeFactory<NodeId, EdgeId, Kind> as GraphEdgesNominalInterface>::EdgeHandle where
    IntoId: Into<<<NodeFactory<NodeId, EdgeId, Kind> as GraphEdgesNominalInterface>::EdgeHandle as HasId>::Id>, 

Get edge with id.

fn out_edges_ids<'a, 'b, IntoId>(
    &'a self,
    node_id: IntoId
) -> Box<dyn Iterator<Item = <<NodeFactory<NodeId, EdgeId, Kind> as GraphEdgesNominalInterface>::EdgeHandle as HasId>::Id> + 'b, Global> where
    'a: 'b,
    IntoId: Into<<<NodeFactory<NodeId, EdgeId, Kind> as GraphNodesNominalInterface>::NodeHandle as HasId>::Id>, 

Iterate over output edges of the node. Callback gets ids of nodes in neighbourhood of a picked node.

fn EdgeId<Id>(id: Id) -> <Self::EdgeHandle as HasId>::Id where
    Id: Into<<Self::EdgeHandle as HasId>::Id>, 

Convert argument into edge id.

fn edge_id<Id>(&self, id: Id) -> <Self::EdgeHandle as HasId>::Id where
    Id: Into<<Self::EdgeHandle as HasId>::Id>, 

Convert argument into edge id.

fn out_edges<'a, 'b, IntoId>(
    &'a self,
    node_id: IntoId
) -> Box<dyn Iterator<Item = (<Self::EdgeHandle as HasId>::Id, &'a Self::EdgeHandle)> + 'b, Global> where
    'a: 'b,
    IntoId: Into<<Self::NodeHandle as HasId>::Id>, 

Iterate over output edges of the node. Callback gets ids and references of edges in neighbourhood of a picked node.

impl<NodeId, EdgeId, Kind> GraphNodesEnumerableInterface for NodeFactory<NodeId, EdgeId, Kind> where
    NodeId: IdentityInterface,
    EdgeId: IdentityInterface + IdentityGenerableInterface,
    Kind: NodeKindInterface, 

fn nodes<'a, 'b>(
    &'a self
) -> Box<dyn Iterator<Item = (<<NodeFactory<NodeId, EdgeId, Kind> as GraphNodesNominalInterface>::NodeHandle as HasId>::Id, &'a <NodeFactory<NodeId, EdgeId, Kind> as GraphNodesNominalInterface>::NodeHandle)> + 'b, Global> where
    'a: 'b, 

Iterate over all nodes.

fn nnodes(&self) -> usize

Number of nodes. Order of the graph.

impl<NodeId, EdgeId, Kind> GraphNodesExtendableInterface for NodeFactory<NodeId, EdgeId, Kind> where
    NodeId: IdentityInterface,
    EdgeId: IdentityInterface + IdentityGenerableInterface,
    Kind: NodeKindInterface, 

fn node_add_out_nodes<IntoId1, IntoId2, Iter>(
    &mut self,
    in_node_id: IntoId1,
    out_nodes_iter: Iter
) where
    IntoId1: Into<<<NodeFactory<NodeId, EdgeId, Kind> as GraphNodesNominalInterface>::NodeHandle as HasId>::Id>,
    IntoId2: Into<<<NodeFactory<NodeId, EdgeId, Kind> as GraphNodesNominalInterface>::NodeHandle as HasId>::Id>,
    Iter: IntoIterator<Item = IntoId2>,
    <Iter as IntoIterator>::IntoIter: Clone, 

Iterate output nodes of the node.

fn node_mut<IntoId>(
    &mut self,
    id: IntoId
) -> &mut <NodeFactory<NodeId, EdgeId, Kind> as GraphNodesNominalInterface>::NodeHandle where
    IntoId: Into<<<NodeFactory<NodeId, EdgeId, Kind> as GraphNodesNominalInterface>::NodeHandle as HasId>::Id>, 

Get node with id mutably.

fn node_making<IntoId>(
    &mut self,
    id: IntoId
) -> <<NodeFactory<NodeId, EdgeId, Kind> as GraphNodesNominalInterface>::NodeHandle as HasId>::Id where
    IntoId: Into<<<NodeFactory<NodeId, EdgeId, Kind> as GraphNodesNominalInterface>::NodeHandle as HasId>::Id>, 

Either make new or get existing node.

fn node_add_out_node<IntoId1, IntoId2>(
    &mut self,
    node_id: IntoId1,
    out_node_id: IntoId2
) where
    IntoId1: Into<<Self::NodeHandle as HasId>::Id> + Clone,
    IntoId2: Into<<Self::NodeHandle as HasId>::Id> + Clone, 

Add out edges to the node.

fn make_with_edge_list<IntoIter, Id>(&mut self, into_iter: IntoIter) where
    Id: Into<<Self::NodeHandle as HasId>::Id>,
    IntoIter: IntoIterator<Item = Id>,
    <IntoIter as IntoIterator>::IntoIter: ExactSizeIterator,
    <<IntoIter as IntoIterator>::IntoIter as Iterator>::Item == Id, 

Make edges.

impl<NodeId, EdgeId, Kind> GraphNodesNominalInterface for NodeFactory<NodeId, EdgeId, Kind> where
    NodeId: IdentityInterface,
    EdgeId: IdentityInterface + IdentityGenerableInterface,
    Kind: NodeKindInterface, 

type NodeHandle = Node<NodeId, EdgeId, Kind>

Handle of a node - entity representing a node or the node itself. It’s not always possible to operate a node directly, for example it it has to be wrapped by cell ref. For that use NodeHandle. Otherwise NodeHandle could be &Node.

fn node<IntoId>(
    &self,
    id: IntoId
) -> &<NodeFactory<NodeId, EdgeId, Kind> as GraphNodesNominalInterface>::NodeHandle where
    IntoId: Into<<<NodeFactory<NodeId, EdgeId, Kind> as GraphNodesNominalInterface>::NodeHandle as HasId>::Id>, 

Get node with id.

fn out_nodes_ids<'a, 'b, IntoId>(
    &'a self,
    node_id: IntoId
) -> Box<dyn Iterator<Item = <<NodeFactory<NodeId, EdgeId, Kind> as GraphNodesNominalInterface>::NodeHandle as HasId>::Id> + 'b, Global> where
    'a: 'b,
    IntoId: Into<<<NodeFactory<NodeId, EdgeId, Kind> as GraphNodesNominalInterface>::NodeHandle as HasId>::Id>, 

Iterate over neighbourhood of the node. Callback gets ids of nodes in neighbourhood of a picked node.

fn NodeId<Id>(id: Id) -> <Self::NodeHandle as HasId>::Id where
    Id: Into<<Self::NodeHandle as HasId>::Id>, 

Convert argument into node id.

fn node_id<Id>(&self, id: Id) -> <Self::NodeHandle as HasId>::Id where
    Id: Into<<Self::NodeHandle as HasId>::Id>, 

Convert argument into node id.

fn out_nodes<'a, 'b, Id>(
    &'a self,
    node_id: Id
) -> Box<dyn Iterator<Item = (<Self::NodeHandle as HasId>::Id, &'a Self::NodeHandle)> + 'b, Global> where
    'a: 'b,
    Id: Into<<Self::NodeHandle as HasId>::Id>, 

Iterate over neighbourhood of the node. Callback gets ids and reference on itself of nodes in neighbourhood of a picked node.

impl<NodeId, EdgeId, Kind> Make0 for NodeFactory<NodeId, EdgeId, Kind> where
    NodeId: IdentityInterface,
    EdgeId: IdentityInterface + IdentityGenerableInterface,
    Kind: NodeKindInterface, 

fn make_0() -> NodeFactory<NodeId, EdgeId, Kind>

Constructor without arguments.

fn make() -> Self

Constructor without arguments.

impl<NodeId, EdgeId, Kind> NodeFactoryInterface for NodeFactory<NodeId, EdgeId, Kind> where
    NodeId: IdentityInterface,
    EdgeId: IdentityInterface + IdentityGenerableInterface,
    Kind: NodeKindInterface,