use super::{
Plugin, PostAddEdgeContext, PostAddEdgeToGroupContext, PostAddEdgeToGroupsContext,
PostAddEdgeWithGroupContext, PostAddEdgeWithGroupsContext, PostAddEdgesContext,
PostAddEdgesDataframesContext, PostAddEdgesDataframesWithGroupContext,
PostAddEdgesDataframesWithGroupsContext, PostAddEdgesToGroupsContext,
PostAddEdgesWithGroupContext, PostAddEdgesWithGroupsContext, PostAddGroupContext,
PostAddNodeContext, PostAddNodeToGroupContext, PostAddNodeToGroupsContext,
PostAddNodeWithGroupContext, PostAddNodeWithGroupsContext, PostAddNodesContext,
PostAddNodesDataframesContext, PostAddNodesDataframesWithGroupContext,
PostAddNodesDataframesWithGroupsContext, PostAddNodesToGroupsContext,
PostAddNodesWithGroupContext, PostAddNodesWithGroupsContext, PostRemoveEdgeContext,
PostRemoveEdgeFromGroupContext, PostRemoveEdgeFromGroupsContext,
PostRemoveEdgesFromGroupsContext, PostRemoveGroupContext, PostRemoveNodeContext,
PostRemoveNodeFromGroupContext, PostRemoveNodeFromGroupsContext,
PostRemoveNodesFromGroupsContext, PreAddEdgeContext, PreAddEdgeToGroupContext,
PreAddEdgeToGroupsContext, PreAddEdgeWithGroupContext, PreAddEdgeWithGroupsContext,
PreAddEdgesContext, PreAddEdgesDataframesContext, PreAddEdgesDataframesWithGroupContext,
PreAddEdgesDataframesWithGroupsContext, PreAddEdgesToGroupsContext,
PreAddEdgesWithGroupContext, PreAddEdgesWithGroupsContext, PreAddGroupContext,
PreAddNodeContext, PreAddNodeToGroupContext, PreAddNodeToGroupsContext,
PreAddNodeWithGroupContext, PreAddNodeWithGroupsContext, PreAddNodesContext,
PreAddNodesDataframesContext, PreAddNodesDataframesWithGroupContext,
PreAddNodesDataframesWithGroupsContext, PreAddNodesToGroupsContext,
PreAddNodesWithGroupContext, PreAddNodesWithGroupsContext, PreRemoveEdgeContext,
PreRemoveEdgeFromGroupContext, PreRemoveEdgeFromGroupsContext, PreRemoveEdgesFromGroupsContext,
PreRemoveGroupContext, PreRemoveNodeContext, PreRemoveNodeFromGroupContext,
PreRemoveNodeFromGroupsContext, PreRemoveNodesFromGroupsContext, PreSetSchemaContext,
};
use crate::{
errors::{GraphRecordError, GraphRecordResult},
graphrecord::{EdgeDataFrameInput, GraphRecord, NodeDataFrameInput},
prelude::{AttributeMap, EdgeIndex, GraphRecordAttribute, Group, NodeIndex, Schema},
};
use graphrecords_utils::aliases::GrHashMap;
use std::sync::Arc;
pub type PluginName = GraphRecordAttribute;
impl GraphRecord {
pub fn with_plugins(
plugins: GrHashMap<PluginName, Box<dyn Plugin>>,
) -> GraphRecordResult<Self> {
let mut graphrecord = Self {
plugins: Arc::new(plugins),
..Default::default()
};
let plugins = graphrecord.plugins.clone();
plugins
.iter()
.try_for_each(|(_, plugin)| plugin.initialize(&mut graphrecord))?;
Ok(graphrecord)
}
pub fn add_plugin(
&mut self,
name: PluginName,
plugin: Box<dyn Plugin>,
) -> GraphRecordResult<()> {
if self.plugins.contains_key(&name) {
return Err(GraphRecordError::PluginAlreadyExists { name });
}
plugin.initialize(self)?;
let plugins = Arc::make_mut(&mut self.plugins);
plugins.insert(name, plugin);
Ok(())
}
pub fn remove_plugin(&mut self, name: &PluginName) -> GraphRecordResult<()> {
let plugin = {
let plugins = Arc::make_mut(&mut self.plugins);
plugins
.remove(name)
.ok_or_else(|| GraphRecordError::PluginNotFound { name: name.clone() })?
};
plugin.finalize(self)?;
Ok(())
}
pub fn plugin_names(&self) -> impl Iterator<Item = &PluginName> {
self.plugins.keys()
}
pub fn set_schema(&mut self, schema: Schema) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreSetSchemaContext { schema };
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_set_schema(self, pre_context)
})?;
self.set_schema_impl(pre_context.schema)?;
plugins
.iter()
.try_for_each(|(_, plugin)| plugin.post_set_schema(self))?;
Ok(())
}
pub fn set_schema_bypass_plugins(&mut self, schema: Schema) -> GraphRecordResult<()> {
self.set_schema_impl(schema)
}
pub fn freeze_schema(&mut self) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
for (_, plugin) in plugins.iter() {
plugin.pre_freeze_schema(self)?;
}
self.freeze_schema_impl();
for (_, plugin) in plugins.iter() {
plugin.post_freeze_schema(self)?;
}
Ok(())
}
pub const fn freeze_schema_bypass_plugins(&mut self) -> GraphRecordResult<()> {
self.freeze_schema_impl();
Ok(())
}
pub fn unfreeze_schema(&mut self) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
for (_, plugin) in plugins.iter() {
plugin.pre_unfreeze_schema(self)?;
}
self.unfreeze_schema_impl();
for (_, plugin) in plugins.iter() {
plugin.post_unfreeze_schema(self)?;
}
Ok(())
}
pub const fn unfreeze_schema_bypass_plugins(&mut self) -> GraphRecordResult<()> {
self.unfreeze_schema_impl();
Ok(())
}
pub fn add_node(
&mut self,
node_index: NodeIndex,
attributes: AttributeMap,
) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreAddNodeContext {
node_index: node_index.clone(),
attributes,
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_node(self, pre_context)
})?;
self.add_node_impl(pre_context.node_index, pre_context.attributes)?;
let post_context = PostAddNodeContext { node_index };
plugins
.iter()
.try_for_each(|(_, plugin)| plugin.post_add_node(self, post_context.clone()))?;
Ok(())
}
pub fn add_node_bypass_plugins(
&mut self,
node_index: NodeIndex,
attributes: AttributeMap,
) -> GraphRecordResult<()> {
self.add_node_impl(node_index, attributes)
}
#[allow(clippy::needless_pass_by_value)]
pub fn add_node_with_group(
&mut self,
node_index: NodeIndex,
attributes: AttributeMap,
group: Group,
) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreAddNodeWithGroupContext {
node_index: node_index.clone(),
attributes,
group: group.clone(),
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_node_with_group(self, pre_context)
})?;
self.add_node_with_group_impl(
pre_context.node_index,
pre_context.attributes,
pre_context.group,
)?;
let post_context = PostAddNodeWithGroupContext { node_index, group };
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_add_node_with_group(self, post_context.clone())
})?;
Ok(())
}
pub fn add_node_with_group_bypass_plugins(
&mut self,
node_index: NodeIndex,
attributes: AttributeMap,
group: Group,
) -> GraphRecordResult<()> {
self.add_node_with_group_impl(node_index, attributes, group)
}
pub fn add_node_with_groups(
&mut self,
node_index: NodeIndex,
attributes: AttributeMap,
groups: impl AsRef<[Group]>,
) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreAddNodeWithGroupsContext {
node_index,
attributes,
groups: groups.as_ref().to_vec(),
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_node_with_groups(self, pre_context)
})?;
self.add_node_with_groups_impl(
pre_context.node_index.clone(),
pre_context.attributes,
&pre_context.groups,
)?;
let post_context = PostAddNodeWithGroupsContext {
node_index: pre_context.node_index,
groups: pre_context.groups,
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_add_node_with_groups(self, post_context.clone())
})?;
Ok(())
}
pub fn add_node_with_groups_bypass_plugins(
&mut self,
node_index: NodeIndex,
attributes: AttributeMap,
groups: impl AsRef<[Group]>,
) -> GraphRecordResult<()> {
self.add_node_with_groups_impl(node_index, attributes, groups)
}
pub fn remove_node(&mut self, node_index: &NodeIndex) -> GraphRecordResult<AttributeMap> {
let plugins = self.plugins.clone();
let pre_context = PreRemoveNodeContext {
node_index: node_index.clone(),
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_remove_node(self, pre_context)
})?;
let attributes = self.remove_node_impl(&pre_context.node_index)?;
let post_context = PostRemoveNodeContext {
node_index: pre_context.node_index,
};
plugins
.iter()
.try_for_each(|(_, plugin)| plugin.post_remove_node(self, post_context.clone()))?;
Ok(attributes)
}
pub fn remove_node_bypass_plugins(
&mut self,
node_index: &NodeIndex,
) -> GraphRecordResult<AttributeMap> {
self.remove_node_impl(node_index)
}
pub fn add_nodes(&mut self, nodes: Vec<(NodeIndex, AttributeMap)>) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreAddNodesContext { nodes };
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_nodes(self, pre_context)
})?;
self.add_nodes_impl(pre_context.nodes.clone())?;
let post_context = PostAddNodesContext {
nodes: pre_context.nodes,
};
plugins
.iter()
.try_for_each(|(_, plugin)| plugin.post_add_nodes(self, post_context.clone()))?;
Ok(())
}
pub fn add_nodes_bypass_plugins(
&mut self,
nodes: Vec<(NodeIndex, AttributeMap)>,
) -> GraphRecordResult<()> {
self.add_nodes_impl(nodes)
}
#[allow(clippy::needless_pass_by_value)]
pub fn add_nodes_with_group(
&mut self,
nodes: Vec<(NodeIndex, AttributeMap)>,
group: Group,
) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreAddNodesWithGroupContext { nodes, group };
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_nodes_with_group(self, pre_context)
})?;
self.add_nodes_with_group_impl(pre_context.nodes.clone(), pre_context.group.clone())?;
let post_context = PostAddNodesWithGroupContext {
nodes: pre_context.nodes,
group: pre_context.group,
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_add_nodes_with_group(self, post_context.clone())
})?;
Ok(())
}
pub fn add_nodes_with_group_bypass_plugins(
&mut self,
nodes: Vec<(NodeIndex, AttributeMap)>,
group: Group,
) -> GraphRecordResult<()> {
self.add_nodes_with_group_impl(nodes, group)
}
pub fn add_nodes_with_groups(
&mut self,
nodes: Vec<(NodeIndex, AttributeMap)>,
groups: impl AsRef<[Group]>,
) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreAddNodesWithGroupsContext {
nodes,
groups: groups.as_ref().to_vec(),
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_nodes_with_groups(self, pre_context)
})?;
self.add_nodes_with_groups_impl(pre_context.nodes.clone(), &pre_context.groups)?;
let post_context = PostAddNodesWithGroupsContext {
nodes: pre_context.nodes,
groups: pre_context.groups,
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_add_nodes_with_groups(self, post_context.clone())
})?;
Ok(())
}
pub fn add_nodes_with_groups_bypass_plugins(
&mut self,
nodes: Vec<(NodeIndex, AttributeMap)>,
groups: impl AsRef<[Group]>,
) -> GraphRecordResult<()> {
self.add_nodes_with_groups_impl(nodes, groups)
}
pub fn add_nodes_dataframes(
&mut self,
nodes_dataframes: impl IntoIterator<Item = impl Into<NodeDataFrameInput>>,
) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreAddNodesDataframesContext {
nodes_dataframes: nodes_dataframes.into_iter().map(Into::into).collect(),
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_nodes_dataframes(self, pre_context)
})?;
self.add_nodes_dataframes_impl(pre_context.nodes_dataframes.clone())?;
let post_context = PostAddNodesDataframesContext {
nodes_dataframes: pre_context.nodes_dataframes,
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_add_nodes_dataframes(self, post_context.clone())
})?;
Ok(())
}
pub fn add_nodes_dataframes_bypass_plugins(
&mut self,
nodes_dataframes: impl IntoIterator<Item = impl Into<NodeDataFrameInput>>,
) -> GraphRecordResult<()> {
self.add_nodes_dataframes_impl(nodes_dataframes)
}
pub fn add_nodes_dataframes_with_group(
&mut self,
nodes_dataframes: impl IntoIterator<Item = impl Into<NodeDataFrameInput>>,
group: Group,
) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreAddNodesDataframesWithGroupContext {
nodes_dataframes: nodes_dataframes.into_iter().map(Into::into).collect(),
group,
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_nodes_dataframes_with_group(self, pre_context)
})?;
self.add_nodes_dataframes_with_group_impl(
pre_context.nodes_dataframes.clone(),
pre_context.group.clone(),
)?;
let post_context = PostAddNodesDataframesWithGroupContext {
nodes_dataframes: pre_context.nodes_dataframes,
group: pre_context.group,
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_add_nodes_dataframes_with_group(self, post_context.clone())
})?;
Ok(())
}
pub fn add_nodes_dataframes_with_group_bypass_plugins(
&mut self,
nodes_dataframes: impl IntoIterator<Item = impl Into<NodeDataFrameInput>>,
group: Group,
) -> GraphRecordResult<()> {
self.add_nodes_dataframes_with_group_impl(nodes_dataframes, group)
}
pub fn add_nodes_dataframes_with_groups(
&mut self,
nodes_dataframes: Vec<NodeDataFrameInput>,
groups: impl AsRef<[Group]>,
) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreAddNodesDataframesWithGroupsContext {
nodes_dataframes,
groups: groups.as_ref().to_vec(),
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_nodes_dataframes_with_groups(self, pre_context)
})?;
self.add_nodes_dataframes_with_groups_impl(
pre_context.nodes_dataframes.clone(),
&pre_context.groups,
)?;
let post_context = PostAddNodesDataframesWithGroupsContext {
nodes_dataframes: pre_context.nodes_dataframes,
groups: pre_context.groups,
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_add_nodes_dataframes_with_groups(self, post_context.clone())
})?;
Ok(())
}
pub fn add_nodes_dataframes_with_groups_bypass_plugins(
&mut self,
nodes_dataframes: Vec<NodeDataFrameInput>,
groups: impl AsRef<[Group]>,
) -> GraphRecordResult<()> {
self.add_nodes_dataframes_with_groups_impl(nodes_dataframes, groups)
}
#[allow(clippy::needless_pass_by_value)]
pub fn add_edge(
&mut self,
source_node_index: NodeIndex,
target_node_index: NodeIndex,
attributes: AttributeMap,
) -> GraphRecordResult<EdgeIndex> {
let plugins = self.plugins.clone();
let pre_context = PreAddEdgeContext {
source_node_index,
target_node_index,
attributes,
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_edge(self, pre_context)
})?;
let edge_index = self.add_edge_impl(
pre_context.source_node_index,
pre_context.target_node_index,
pre_context.attributes,
)?;
let post_context = PostAddEdgeContext { edge_index };
plugins
.iter()
.try_for_each(|(_, plugin)| plugin.post_add_edge(self, post_context.clone()))?;
Ok(edge_index)
}
pub fn add_edge_bypass_plugins(
&mut self,
source_node_index: NodeIndex,
target_node_index: NodeIndex,
attributes: AttributeMap,
) -> GraphRecordResult<EdgeIndex> {
self.add_edge_impl(source_node_index, target_node_index, attributes)
}
#[allow(clippy::needless_pass_by_value)]
pub fn add_edge_with_group(
&mut self,
source_node_index: NodeIndex,
target_node_index: NodeIndex,
attributes: AttributeMap,
group: Group,
) -> GraphRecordResult<EdgeIndex> {
let plugins = self.plugins.clone();
let pre_context = PreAddEdgeWithGroupContext {
source_node_index,
target_node_index,
attributes,
group,
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_edge_with_group(self, pre_context)
})?;
let edge_index = self.add_edge_with_group_impl(
pre_context.source_node_index,
pre_context.target_node_index,
pre_context.attributes,
pre_context.group,
)?;
let post_context = PostAddEdgeWithGroupContext { edge_index };
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_add_edge_with_group(self, post_context.clone())
})?;
Ok(edge_index)
}
pub fn add_edge_with_group_bypass_plugins(
&mut self,
source_node_index: NodeIndex,
target_node_index: NodeIndex,
attributes: AttributeMap,
group: Group,
) -> GraphRecordResult<EdgeIndex> {
self.add_edge_with_group_impl(source_node_index, target_node_index, attributes, group)
}
pub fn add_edge_with_groups(
&mut self,
source_node_index: NodeIndex,
target_node_index: NodeIndex,
attributes: AttributeMap,
groups: impl AsRef<[Group]>,
) -> GraphRecordResult<EdgeIndex> {
let plugins = self.plugins.clone();
let pre_context = PreAddEdgeWithGroupsContext {
source_node_index,
target_node_index,
attributes,
groups: groups.as_ref().to_vec(),
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_edge_with_groups(self, pre_context)
})?;
let edge_index = self.add_edge_with_groups_impl(
pre_context.source_node_index,
pre_context.target_node_index,
pre_context.attributes,
&pre_context.groups,
)?;
let post_context = PostAddEdgeWithGroupsContext {
edge_index,
groups: pre_context.groups,
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_add_edge_with_groups(self, post_context.clone())
})?;
Ok(edge_index)
}
pub fn add_edge_with_groups_bypass_plugins(
&mut self,
source_node_index: NodeIndex,
target_node_index: NodeIndex,
attributes: AttributeMap,
groups: impl AsRef<[Group]>,
) -> GraphRecordResult<EdgeIndex> {
self.add_edge_with_groups_impl(source_node_index, target_node_index, attributes, groups)
}
pub fn remove_edge(&mut self, edge_index: &EdgeIndex) -> GraphRecordResult<AttributeMap> {
let plugins = self.plugins.clone();
let pre_context = PreRemoveEdgeContext {
edge_index: *edge_index,
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_remove_edge(self, pre_context)
})?;
let attributes = self.remove_edge_impl(&pre_context.edge_index)?;
let post_context = PostRemoveEdgeContext {
edge_index: pre_context.edge_index,
};
plugins
.iter()
.try_for_each(|(_, plugin)| plugin.post_remove_edge(self, post_context.clone()))?;
Ok(attributes)
}
pub fn remove_edge_bypass_plugins(
&mut self,
edge_index: &EdgeIndex,
) -> GraphRecordResult<AttributeMap> {
self.remove_edge_impl(edge_index)
}
pub fn add_edges(
&mut self,
edges: Vec<(NodeIndex, NodeIndex, AttributeMap)>,
) -> GraphRecordResult<Vec<EdgeIndex>> {
let plugins = self.plugins.clone();
let pre_context = PreAddEdgesContext { edges };
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_edges(self, pre_context)
})?;
let edge_indices = self.add_edges_impl(pre_context.edges)?;
let post_context = PostAddEdgesContext {
edge_indices: edge_indices.clone(),
};
plugins
.iter()
.try_for_each(|(_, plugin)| plugin.post_add_edges(self, post_context.clone()))?;
Ok(edge_indices)
}
pub fn add_edges_bypass_plugins(
&mut self,
edges: Vec<(NodeIndex, NodeIndex, AttributeMap)>,
) -> GraphRecordResult<Vec<EdgeIndex>> {
self.add_edges_impl(edges)
}
pub fn add_edges_with_group(
&mut self,
edges: Vec<(NodeIndex, NodeIndex, AttributeMap)>,
group: &Group,
) -> GraphRecordResult<Vec<EdgeIndex>> {
let plugins = self.plugins.clone();
let pre_context = PreAddEdgesWithGroupContext {
edges,
group: group.clone(),
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_edges_with_group(self, pre_context)
})?;
let edge_indices = self.add_edges_with_group_impl(pre_context.edges, &pre_context.group)?;
let post_context = PostAddEdgesWithGroupContext {
edge_indices: edge_indices.clone(),
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_add_edges_with_group(self, post_context.clone())
})?;
Ok(edge_indices)
}
pub fn add_edges_with_group_bypass_plugins(
&mut self,
edges: Vec<(NodeIndex, NodeIndex, AttributeMap)>,
group: &Group,
) -> GraphRecordResult<Vec<EdgeIndex>> {
self.add_edges_with_group_impl(edges, group)
}
pub fn add_edges_with_groups(
&mut self,
edges: Vec<(NodeIndex, NodeIndex, AttributeMap)>,
groups: impl AsRef<[Group]>,
) -> GraphRecordResult<Vec<EdgeIndex>> {
let plugins = self.plugins.clone();
let pre_context = PreAddEdgesWithGroupsContext {
edges,
groups: groups.as_ref().to_vec(),
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_edges_with_groups(self, pre_context)
})?;
let edge_indices =
self.add_edges_with_groups_impl(pre_context.edges.clone(), &pre_context.groups)?;
let post_context = PostAddEdgesWithGroupsContext {
edge_indices: edge_indices.clone(),
groups: pre_context.groups,
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_add_edges_with_groups(self, post_context.clone())
})?;
Ok(edge_indices)
}
pub fn add_edges_with_groups_bypass_plugins(
&mut self,
edges: Vec<(NodeIndex, NodeIndex, AttributeMap)>,
groups: impl AsRef<[Group]>,
) -> GraphRecordResult<Vec<EdgeIndex>> {
self.add_edges_with_groups_impl(edges, groups)
}
pub fn add_edges_dataframes(
&mut self,
edges_dataframes: impl IntoIterator<Item = impl Into<EdgeDataFrameInput>>,
) -> GraphRecordResult<Vec<EdgeIndex>> {
let plugins = self.plugins.clone();
let pre_context = PreAddEdgesDataframesContext {
edges_dataframes: edges_dataframes.into_iter().map(Into::into).collect(),
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_edges_dataframes(self, pre_context)
})?;
let edge_indices = self.add_edges_dataframes_impl(pre_context.edges_dataframes.clone())?;
let post_context = PostAddEdgesDataframesContext {
edges_dataframes: pre_context.edges_dataframes,
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_add_edges_dataframes(self, post_context.clone())
})?;
Ok(edge_indices)
}
pub fn add_edges_dataframes_bypass_plugins(
&mut self,
edges_dataframes: impl IntoIterator<Item = impl Into<EdgeDataFrameInput>>,
) -> GraphRecordResult<Vec<EdgeIndex>> {
self.add_edges_dataframes_impl(edges_dataframes)
}
pub fn add_edges_dataframes_with_group(
&mut self,
edges_dataframes: impl IntoIterator<Item = impl Into<EdgeDataFrameInput>>,
group: &Group,
) -> GraphRecordResult<Vec<EdgeIndex>> {
let plugins = self.plugins.clone();
let pre_context = PreAddEdgesDataframesWithGroupContext {
edges_dataframes: edges_dataframes.into_iter().map(Into::into).collect(),
group: group.clone(),
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_edges_dataframes_with_group(self, pre_context)
})?;
let edge_indices = self.add_edges_dataframes_with_group_impl(
pre_context.edges_dataframes.clone(),
&pre_context.group,
)?;
let post_context = PostAddEdgesDataframesWithGroupContext {
edges_dataframes: pre_context.edges_dataframes,
group: pre_context.group,
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_add_edges_dataframes_with_group(self, post_context.clone())
})?;
Ok(edge_indices)
}
pub fn add_edges_dataframes_with_group_bypass_plugins(
&mut self,
edges_dataframes: impl IntoIterator<Item = impl Into<EdgeDataFrameInput>>,
group: &Group,
) -> GraphRecordResult<Vec<EdgeIndex>> {
self.add_edges_dataframes_with_group_impl(edges_dataframes, group)
}
pub fn add_edges_dataframes_with_groups(
&mut self,
edges_dataframes: Vec<EdgeDataFrameInput>,
groups: impl AsRef<[Group]>,
) -> GraphRecordResult<Vec<EdgeIndex>> {
let plugins = self.plugins.clone();
let pre_context = PreAddEdgesDataframesWithGroupsContext {
edges_dataframes,
groups: groups.as_ref().to_vec(),
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_edges_dataframes_with_groups(self, pre_context)
})?;
let edge_indices = self.add_edges_dataframes_with_groups_impl(
pre_context.edges_dataframes.clone(),
&pre_context.groups,
)?;
let post_context = PostAddEdgesDataframesWithGroupsContext {
edges_dataframes: pre_context.edges_dataframes,
groups: pre_context.groups,
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_add_edges_dataframes_with_groups(self, post_context.clone())
})?;
Ok(edge_indices)
}
pub fn add_edges_dataframes_with_groups_bypass_plugins(
&mut self,
edges_dataframes: Vec<EdgeDataFrameInput>,
groups: impl AsRef<[Group]>,
) -> GraphRecordResult<Vec<EdgeIndex>> {
self.add_edges_dataframes_with_groups_impl(edges_dataframes, groups)
}
pub fn add_group(
&mut self,
group: Group,
node_indices: Option<Vec<NodeIndex>>,
edge_indices: Option<Vec<EdgeIndex>>,
) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreAddGroupContext {
group,
node_indices,
edge_indices,
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_group(self, pre_context)
})?;
self.add_group_impl(
pre_context.group.clone(),
pre_context.node_indices.clone(),
pre_context.edge_indices.clone(),
)?;
let post_context = PostAddGroupContext {
group: pre_context.group,
node_indices: pre_context.node_indices,
edge_indices: pre_context.edge_indices,
};
plugins
.iter()
.try_for_each(|(_, plugin)| plugin.post_add_group(self, post_context.clone()))?;
Ok(())
}
pub fn add_group_bypass_plugins(
&mut self,
group: Group,
node_indices: Option<Vec<NodeIndex>>,
edge_indices: Option<Vec<EdgeIndex>>,
) -> GraphRecordResult<()> {
self.add_group_impl(group, node_indices, edge_indices)
}
pub fn remove_group(&mut self, group: &Group) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreRemoveGroupContext {
group: group.clone(),
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_remove_group(self, pre_context)
})?;
self.remove_group_impl(&pre_context.group)?;
let post_context = PostRemoveGroupContext {
group: pre_context.group,
};
plugins
.iter()
.try_for_each(|(_, plugin)| plugin.post_remove_group(self, post_context.clone()))?;
Ok(())
}
pub fn remove_group_bypass_plugins(&mut self, group: &Group) -> GraphRecordResult<()> {
self.remove_group_impl(group)
}
pub fn add_node_to_group(
&mut self,
group: Group,
node_index: NodeIndex,
) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreAddNodeToGroupContext { group, node_index };
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_node_to_group(self, pre_context)
})?;
self.add_node_to_group_impl(pre_context.group.clone(), pre_context.node_index.clone())?;
let post_context = PostAddNodeToGroupContext {
group: pre_context.group,
node_index: pre_context.node_index,
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_add_node_to_group(self, post_context.clone())
})?;
Ok(())
}
pub fn add_node_to_group_bypass_plugins(
&mut self,
group: Group,
node_index: NodeIndex,
) -> GraphRecordResult<()> {
self.add_node_to_group_impl(group, node_index)
}
pub fn add_node_to_groups(
&mut self,
groups: impl AsRef<[Group]>,
node_index: NodeIndex,
) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreAddNodeToGroupsContext {
groups: groups.as_ref().to_vec(),
node_index,
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_node_to_groups(self, pre_context)
})?;
self.add_node_to_groups_impl(&pre_context.groups, pre_context.node_index.clone())?;
let post_context = PostAddNodeToGroupsContext {
groups: pre_context.groups,
node_index: pre_context.node_index,
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_add_node_to_groups(self, post_context.clone())
})?;
Ok(())
}
pub fn add_node_to_groups_bypass_plugins(
&mut self,
groups: impl AsRef<[Group]>,
node_index: NodeIndex,
) -> GraphRecordResult<()> {
self.add_node_to_groups_impl(groups, node_index)
}
pub fn add_nodes_to_groups(
&mut self,
groups: impl AsRef<[Group]>,
node_indices: Vec<NodeIndex>,
) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreAddNodesToGroupsContext {
groups: groups.as_ref().to_vec(),
node_indices,
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_nodes_to_groups(self, pre_context)
})?;
self.add_nodes_to_groups_impl(&pre_context.groups, pre_context.node_indices.clone())?;
let post_context = PostAddNodesToGroupsContext {
groups: pre_context.groups,
node_indices: pre_context.node_indices,
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_add_nodes_to_groups(self, post_context.clone())
})?;
Ok(())
}
pub fn add_nodes_to_groups_bypass_plugins(
&mut self,
groups: impl AsRef<[Group]>,
node_indices: Vec<NodeIndex>,
) -> GraphRecordResult<()> {
self.add_nodes_to_groups_impl(groups, node_indices)
}
pub fn add_edge_to_group(
&mut self,
group: Group,
edge_index: EdgeIndex,
) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreAddEdgeToGroupContext { group, edge_index };
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_edge_to_group(self, pre_context)
})?;
self.add_edge_to_group_impl(pre_context.group.clone(), pre_context.edge_index)?;
let post_context = PostAddEdgeToGroupContext {
group: pre_context.group,
edge_index: pre_context.edge_index,
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_add_edge_to_group(self, post_context.clone())
})?;
Ok(())
}
pub fn add_edge_to_group_bypass_plugins(
&mut self,
group: Group,
edge_index: EdgeIndex,
) -> GraphRecordResult<()> {
self.add_edge_to_group_impl(group, edge_index)
}
pub fn add_edge_to_groups(
&mut self,
groups: impl AsRef<[Group]>,
edge_index: EdgeIndex,
) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreAddEdgeToGroupsContext {
groups: groups.as_ref().to_vec(),
edge_index,
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_edge_to_groups(self, pre_context)
})?;
self.add_edge_to_groups_impl(&pre_context.groups, pre_context.edge_index)?;
let post_context = PostAddEdgeToGroupsContext {
groups: pre_context.groups,
edge_index: pre_context.edge_index,
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_add_edge_to_groups(self, post_context.clone())
})?;
Ok(())
}
pub fn add_edge_to_groups_bypass_plugins(
&mut self,
groups: impl AsRef<[Group]>,
edge_index: EdgeIndex,
) -> GraphRecordResult<()> {
self.add_edge_to_groups_impl(groups, edge_index)
}
pub fn add_edges_to_groups(
&mut self,
groups: impl AsRef<[Group]>,
edge_indices: Vec<EdgeIndex>,
) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreAddEdgesToGroupsContext {
groups: groups.as_ref().to_vec(),
edge_indices,
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_add_edges_to_groups(self, pre_context)
})?;
self.add_edges_to_groups_impl(&pre_context.groups, pre_context.edge_indices.clone())?;
let post_context = PostAddEdgesToGroupsContext {
groups: pre_context.groups,
edge_indices: pre_context.edge_indices,
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_add_edges_to_groups(self, post_context.clone())
})?;
Ok(())
}
pub fn add_edges_to_groups_bypass_plugins(
&mut self,
groups: impl AsRef<[Group]>,
edge_indices: Vec<EdgeIndex>,
) -> GraphRecordResult<()> {
self.add_edges_to_groups_impl(groups, edge_indices)
}
pub fn remove_node_from_group(
&mut self,
group: &Group,
node_index: &NodeIndex,
) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreRemoveNodeFromGroupContext {
group: group.clone(),
node_index: node_index.clone(),
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_remove_node_from_group(self, pre_context)
})?;
self.remove_node_from_group_impl(&pre_context.group, &pre_context.node_index)?;
let post_context = PostRemoveNodeFromGroupContext {
group: pre_context.group,
node_index: pre_context.node_index,
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_remove_node_from_group(self, post_context.clone())
})?;
Ok(())
}
pub fn remove_node_from_group_bypass_plugins(
&mut self,
group: &Group,
node_index: &NodeIndex,
) -> GraphRecordResult<()> {
self.remove_node_from_group_impl(group, node_index)
}
pub fn remove_node_from_groups(
&mut self,
groups: impl AsRef<[Group]>,
node_index: &NodeIndex,
) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreRemoveNodeFromGroupsContext {
groups: groups.as_ref().to_vec(),
node_index: node_index.clone(),
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_remove_node_from_groups(self, pre_context)
})?;
self.remove_node_from_groups_impl(&pre_context.groups, &pre_context.node_index)?;
let post_context = PostRemoveNodeFromGroupsContext {
groups: pre_context.groups,
node_index: pre_context.node_index,
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_remove_node_from_groups(self, post_context.clone())
})?;
Ok(())
}
pub fn remove_node_from_groups_bypass_plugins(
&mut self,
groups: impl AsRef<[Group]>,
node_index: &NodeIndex,
) -> GraphRecordResult<()> {
self.remove_node_from_groups_impl(groups, node_index)
}
pub fn remove_nodes_from_groups(
&mut self,
groups: impl AsRef<[Group]>,
node_indices: &[NodeIndex],
) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreRemoveNodesFromGroupsContext {
groups: groups.as_ref().to_vec(),
node_indices: node_indices.to_vec(),
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_remove_nodes_from_groups(self, pre_context)
})?;
self.remove_nodes_from_groups_impl(&pre_context.groups, &pre_context.node_indices)?;
let post_context = PostRemoveNodesFromGroupsContext {
groups: pre_context.groups,
node_indices: pre_context.node_indices,
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_remove_nodes_from_groups(self, post_context.clone())
})?;
Ok(())
}
pub fn remove_nodes_from_groups_bypass_plugins(
&mut self,
groups: impl AsRef<[Group]>,
node_indices: &[NodeIndex],
) -> GraphRecordResult<()> {
self.remove_nodes_from_groups_impl(groups, node_indices)
}
pub fn remove_edge_from_group(
&mut self,
group: &Group,
edge_index: &EdgeIndex,
) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreRemoveEdgeFromGroupContext {
group: group.clone(),
edge_index: *edge_index,
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_remove_edge_from_group(self, pre_context)
})?;
self.remove_edge_from_group_impl(&pre_context.group, &pre_context.edge_index)?;
let post_context = PostRemoveEdgeFromGroupContext {
group: pre_context.group,
edge_index: pre_context.edge_index,
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_remove_edge_from_group(self, post_context.clone())
})?;
Ok(())
}
pub fn remove_edge_from_group_bypass_plugins(
&mut self,
group: &Group,
edge_index: &EdgeIndex,
) -> GraphRecordResult<()> {
self.remove_edge_from_group_impl(group, edge_index)
}
pub fn remove_edge_from_groups(
&mut self,
groups: impl AsRef<[Group]>,
edge_index: &EdgeIndex,
) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreRemoveEdgeFromGroupsContext {
groups: groups.as_ref().to_vec(),
edge_index: *edge_index,
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_remove_edge_from_groups(self, pre_context)
})?;
self.remove_edge_from_groups_impl(&pre_context.groups, &pre_context.edge_index)?;
let post_context = PostRemoveEdgeFromGroupsContext {
groups: pre_context.groups,
edge_index: pre_context.edge_index,
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_remove_edge_from_groups(self, post_context.clone())
})?;
Ok(())
}
pub fn remove_edge_from_groups_bypass_plugins(
&mut self,
groups: impl AsRef<[Group]>,
edge_index: &EdgeIndex,
) -> GraphRecordResult<()> {
self.remove_edge_from_groups_impl(groups, edge_index)
}
pub fn remove_edges_from_groups(
&mut self,
groups: impl AsRef<[Group]>,
edge_indices: &[EdgeIndex],
) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
let pre_context = PreRemoveEdgesFromGroupsContext {
groups: groups.as_ref().to_vec(),
edge_indices: edge_indices.to_vec(),
};
let pre_context = plugins
.iter()
.try_fold(pre_context, |pre_context, (_, plugin)| {
plugin.pre_remove_edges_from_groups(self, pre_context)
})?;
self.remove_edges_from_groups_impl(&pre_context.groups, &pre_context.edge_indices)?;
let post_context = PostRemoveEdgesFromGroupsContext {
groups: pre_context.groups,
edge_indices: pre_context.edge_indices,
};
plugins.iter().try_for_each(|(_, plugin)| {
plugin.post_remove_edges_from_groups(self, post_context.clone())
})?;
Ok(())
}
pub fn remove_edges_from_groups_bypass_plugins(
&mut self,
groups: impl AsRef<[Group]>,
edge_indices: &[EdgeIndex],
) -> GraphRecordResult<()> {
self.remove_edges_from_groups_impl(groups, edge_indices)
}
pub fn clear(&mut self) -> GraphRecordResult<()> {
let plugins = self.plugins.clone();
for (_, plugin) in plugins.iter() {
plugin.pre_clear(self)?;
}
self.clear_impl();
for (_, plugin) in plugins.iter() {
plugin.post_clear(self)?;
}
Ok(())
}
pub fn clear_bypass_plugins(&mut self) -> GraphRecordResult<()> {
self.clear_impl();
Ok(())
}
}