graph-types 0.0.13

use crate::{errors::GraphError, Query};
use std::ops::{Deref, DerefMut};

pub mod query;

/// # Arguments
///
/// * `index`:
///
/// returns: Option<Cow<Self::Node>>
///
/// # Examples
///
/// ```
/// use graph_theory::GraphEngine;
/// ```
#[repr(u8)]
#[derive(Copy, Clone, Debug)]
pub enum GraphEntry {
    /// # Arguments
    ///
    /// * `index`:
    ///
    /// returns: Option<Cow<Self::Node>>
    ///
    /// # Examples
    ///
    /// ```
    /// use graph_theory::GraphEngine;
    /// ```
    Node = 0,
    /// # Arguments
    ///
    /// * `index`:
    /// raphEngine
    /// returns: Option<Cow<Self::Node>>
    ///
    /// # Examples
    ///
    /// ```
    /// use graph_theory::GraphEngine;
    /// ```
    Edge = 1,
}

/// Mark the graph as directed or undirected.
///
/// Generally speaking, a directed graph engine can insert undirected edges,
/// but a undirected graph engine cannot insert directed edges.
///
/// # Examples
///
/// ```
/// use graph_theory::{graph_engines::CycleGraph, GraphEngine, GraphKind};
/// assert_eq!(CycleGraph::one_way(5).graph_kind(), GraphKind::Directed);
/// assert_eq!(CycleGraph::two_way(5).graph_kind(), GraphKind::Undirected);
/// ```
#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum GraphKind {
    /// # Arguments
    ///
    /// * `index`:
    ///
    /// returns: Option<Cow<Self::Node>>
    ///
    /// # Examples
    ///
    /// ```
    /// use graph_theory::GraphEngine;
    /// ```
    Directed = 0,
    /// # Arguments
    ///
    /// * `index`:
    ///
    /// returns: Option<Cow<Self::Node>>
    ///
    /// # Examples
    ///
    /// ```
    /// use graph_theory::GraphEngine;
    /// ```
    Undirected = 1,
}

impl GraphKind {
    pub const fn is_one_way(&self) -> bool {
        matches!(self, GraphKind::Directed)
    }
    pub const fn is_two_way(&self) -> bool {
        matches!(self, GraphKind::Undirected)
    }
}

pub trait EntryEngine<V> {
    type EntryRef<'i>: Deref<Target = V>
    where
        Self: 'i;
    type EntryMut<'i>: DerefMut<Target = V>
    where
        Self: 'i;

    /// Get the reference of data by given query from the storage.
    ///
    /// # Examples
    ///
    /// ```
    /// use graph_theory::GraphEngine;
    /// ```
    fn get_entry<'i, Q: Into<Query>>(&'i self, query: Q) -> V;
    /// Get the reference of data by given query from the storage.
    ///
    /// # Examples
    ///
    /// ```
    /// use graph_theory::GraphEngine;
    /// ```
    fn try_entry<'i, Q: Into<Query>>(&'i self, query: Q) -> Result<Self::EntryRef<'i>, GraphError>;
    /// Get the reference of data by given query from the storage.
    ///
    /// # Examples
    ///
    /// ```
    /// use graph_theory::GraphEngine;
    /// ```
    fn mut_entry<'i, Q: Into<Query>>(&'i mut self, query: Q) -> Result<Self::EntryMut<'i>, GraphError>;
    /// Get the reference of data by given query from the storage.
    ///
    /// # Examples
    ///
    /// ```
    /// use graph_theory::GraphEngine;
    /// ```
    fn set_entry<'i, Q: Into<Query>>(&'i mut self, query: Q, entry: V) -> Result<(), GraphError> {
        let mut entry_ref = self.mut_entry(query)?;
        *entry_ref.deref_mut() = entry;
        Ok(())
    }
    fn get_node_data<'i>(&'i self, node: usize) -> V {
        self.get_entry(Query::NodeID(node))
    }
    fn try_node_data<'i>(&'i self, node: usize) -> Option<Self::EntryRef<'i>> {
        self.try_entry(Query::NodeID(node)).ok()
    }
    fn mut_node_data<'i>(&'i mut self, node: usize) -> Option<Self::EntryMut<'i>> {
        self.mut_entry(Query::NodeID(node)).ok()
    }
    fn set_node_data<'i>(&'i mut self, node: usize, data: V) {
        self.set_entry(Query::NodeID(node), data).ok();
    }
    fn get_edge_data<'i>(&'i self, edge: usize) -> V {
        self.get_entry(Query::EdgeID(edge))
    }
    fn try_edge_data<'i>(&'i self, edge: usize) -> Option<Self::EntryRef<'i>> {
        self.try_entry(Query::EdgeID(edge)).ok()
    }
    fn mut_edge_data<'i>(&'i mut self, edge: usize) -> Option<Self::EntryMut<'i>> {
        self.mut_entry(Query::EdgeID(edge)).ok()
    }
    fn set_edge_data<'i>(&'i mut self, edge: usize, data: V) {
        self.set_entry(Query::EdgeID(edge), data).ok();
    }
}