Struct Graph

pub struct Graph<NodeData, DataType, ValueType> {
    pub nodes: SlotMap<NodeId, Node<NodeData>>,
    pub inputs: SlotMap<InputId, InputParam<DataType, ValueType>>,
    pub outputs: SlotMap<OutputId, OutputParam<DataType>>,
    pub connections: SecondaryMap<InputId, OutputId>,
}

The graph, containing nodes, input parameters and output parameters. Because graphs are full of self-referential structures, this type uses the slotmap crate to represent all the inner references in the data.

Fields

nodes: SlotMap<NodeId, Node<NodeData>>

The Nodes of the graph

inputs: SlotMap<InputId, InputParam<DataType, ValueType>>

The InputParams of the graph

outputs: SlotMap<OutputId, OutputParam<DataType>>

The OutputParams of the graph

connections: SecondaryMap<InputId, OutputId>

Implementations

impl<NodeData, DataType, ValueType> Graph<NodeData, DataType, ValueType>

where DataType: PartialEq,

pub fn new() -> Self

pub fn add_node( &mut self, label: String, user_data: NodeData, f: impl FnOnce(&mut Graph<NodeData, DataType, ValueType>, NodeId), ) -> NodeId

pub fn add_input_param( &mut self, node_id: NodeId, name: String, typ: DataType, value: ValueType, kind: InputParamKind, shown_inline: bool, ) -> InputId

pub fn update_input_param( &mut self, input_id: InputId, name: Option<String>, typ: Option<DataType>, value: Option<ValueType>, kind: Option<InputParamKind>, shown_inline: Option<bool>, )

pub fn remove_input_param(&mut self, param: InputId)

pub fn add_output_param( &mut self, node_id: NodeId, name: String, typ: DataType, ) -> OutputId

pub fn update_output_param( &mut self, output_id: OutputId, name: Option<String>, typ: Option<DataType>, )

pub fn remove_output_param(&mut self, param: OutputId)

pub fn ensure_connection_types(&mut self, param_id: AnyParameterId)

Deletes mistyped connection made with param_id

This is only needed connection param type is changed with means other than Graph::update_input_param.

pub fn remove_node( &mut self, node_id: NodeId, ) -> (Node<NodeData>, Vec<(InputId, OutputId)>)

Removes a node from the graph with given node_id. This also removes any incoming or outgoing connections from that node

This function returns the list of connections that has been removed after deleting this node as input-output pairs. Note that one of the two ids in the pair (the one on node_id’s end) will be invalid after calling this function.

pub fn remove_connection(&mut self, input_id: InputId) -> Option<OutputId>

pub fn iter_nodes(&self) -> impl Iterator<Item = NodeId> + '_

pub fn add_connection(&mut self, output: OutputId, input: InputId)

pub fn iter_connections(&self) -> impl Iterator<Item = (InputId, OutputId)> + '_

pub fn connection(&self, input: InputId) -> Option<OutputId>

pub fn any_param_type( &self, param: AnyParameterId, ) -> Result<&DataType, EguiGraphError>

pub fn try_get_input( &self, input: InputId, ) -> Option<&InputParam<DataType, ValueType>>

pub fn get_input(&self, input: InputId) -> &InputParam<DataType, ValueType>

pub fn try_get_output(&self, output: OutputId) -> Option<&OutputParam<DataType>>

pub fn get_output(&self, output: OutputId) -> &OutputParam<DataType>

Trait Implementations

impl<NodeData: Clone, DataType: Clone, ValueType: Clone> Clone for Graph<NodeData, DataType, ValueType>

fn clone(&self) -> Graph<NodeData, DataType, ValueType>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<NodeData: Debug, DataType: Debug, ValueType: Debug> Debug for Graph<NodeData, DataType, ValueType>

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

Formats the value using the given formatter.

impl<NodeData, DataType, ValueType> Default for Graph<NodeData, DataType, ValueType>

where DataType: PartialEq,

fn default() -> Self

Returns the “default value” for a type.

impl<A, B, C> Index<InputId> for Graph<A, B, C>

type Output = InputParam<B, C>

The returned type after indexing.

fn index(&self, index: InputId) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<A, B, C> Index<NodeId> for Graph<A, B, C>

type Output = Node<A>

The returned type after indexing.

fn index(&self, index: NodeId) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<A, B, C> Index<OutputId> for Graph<A, B, C>

type Output = OutputParam<B>

The returned type after indexing.

fn index(&self, index: OutputId) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<A, B, C> IndexMut<InputId> for Graph<A, B, C>

fn index_mut(&mut self, index: InputId) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<A, B, C> IndexMut<NodeId> for Graph<A, B, C>

fn index_mut(&mut self, index: NodeId) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<A, B, C> IndexMut<OutputId> for Graph<A, B, C>

fn index_mut(&mut self, index: OutputId) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.