"radicle-dag",

name = "radicle-dag"

version = "0.1.0"

dependencies = [

 "fastrand",

]

[[package]]

  "radicle-dag",

fastrand = { version = "1.8.0" }

[dependencies.radicle-dag]

path = "../radicle-dag"

version = "0.1"

use radicle_dag::{Dag, Node};

    graph: Dag<Oid, Change>,

        let mut roots: Vec<(&Oid, &Node<_, _>)> = self.graph.roots().collect();

        roots.sort_by_key(|(k, _)| *k);

        let (root, root_node) = roots.first().unwrap();

        let manifest = root_node.manifest.clone();

        let rng = fastrand::Rng::new();

        let sorted = self.graph.sorted(rng);

        let items = sorted.iter().map(|oid| {

            let node = &self.graph[oid];

            let child_commits = node

                .dependents

                .iter()

                .map(|e| *self.graph[e].id())

            (&node.value, *oid, child_commits)

        self.graph.tips().map(|(_, change)| *change.id()).collect()

        self.graph.len().try_into().unwrap()

    node_indices: HashMap<Oid, Oid>,

    graph: Dag<Oid, Change>,

            graph: Dag::new(),

            self.graph.node(commit_id, change);

            e.insert(commit_id);

            if parent.id != resource_commit && !self.has_dependency(commit_id, parent.id) {

    fn has_dependency(&mut self, child_id: Oid, parent_id: Oid) -> bool {

            (Some(parent_ix), Some(child_ix)) => self.graph.has_dependency(child_ix, parent_ix),

        self.graph.dependency(*child_id, *parent_id);

        if self.graph.roots().next().is_some() {

use radicle_dag::Dag;

    graph: &Dag<Oid, Change>,

    items: impl Iterator<Item = (&'b Change, Oid, Vec<Oid>)>,

                let clock = graph[&c.idx]

                    .dependencies

                    .iter()

                        let entry = &entries[&graph[e].id.into()];

    idx: Oid,

use radicle_dag::Dag;

    graph: Dag<EntryId, EntryWithClock>,

    indices: HashMap<EntryId, Oid>,

        create_dag(&id, &entries)

            Ok(create_dag(&root, &entries))

            .tips()

            .map(|(_, node)| node.clock + node.entry.contents.len() as Clock - 1)

            .tips()

            .map(|(_, n)| n.timestamp())

        let sorted = self.graph.sorted(fastrand::Rng::new());

        let items = sorted.iter().map(|idx| {

            .tips()

            .map(|(_, entry)| (*entry.id()).into())

        self.graph.node(

            new_id,

            EntryWithClock {

                entry: new_entry,

                clock: self.clock() + 1,

            },

        );

            self.graph.dependency(new_id, (*tip_ix).into());

fn create_dag<'a>(root: &'a EntryId, entries: &'a HashMap<EntryId, EntryWithClock>) -> History {

    let mut graph: Dag<EntryId, EntryWithClock> = Dag::new();

    let mut indices = HashMap::<EntryId, Oid>::new();

    let root_entry = entries.get(root).unwrap().clone();

    graph.node(*root, root_entry.clone());

    indices.insert(root_entry.id, (*root).into());

    let mut to_process = vec![root_entry];

            graph.node(*child_id, child.clone());

            indices.insert(child.id, (*child_id).into());

            graph.dependency(*child_id, entry_ix.into());

//! representing a single [`crate::CollaborativeObject`]'s underlying

//! change graph.

[package]

name = "radicle-dag"

version = "0.1.0"

edition = "2021"

[dependencies]

fastrand = { version = "1.8.0" }

use std::{

    borrow::Borrow,

    collections::{HashMap, HashSet},

    fmt,

    hash::Hash,

    ops::{Deref, Index},

};

/// A node in the graph.

#[derive(Clone, Debug, PartialEq, Eq)]

pub struct Node<K: Eq + Hash, V> {

    /// The node value, stored by the user.

    pub value: V,

    /// Nodes depended on.

    pub dependencies: HashSet<K>,

    /// Nodes depending on this node.

    pub dependents: HashSet<K>,

}

impl<K: Eq + Hash, V> Borrow<V> for &Node<K, V> {

    fn borrow(&self) -> &V {

        &self.value

    }

}

impl<K: Eq + Hash, V> Deref for Node<K, V> {

    type Target = V;

    fn deref(&self) -> &Self::Target {

        &self.value

    }

}

/// A directed acyclic graph.

#[derive(Clone, Debug, Default, PartialEq, Eq)]

pub struct Dag<K: Eq + Hash, V> {

    graph: HashMap<K, Node<K, V>>,

    tips: HashSet<K>,

    roots: HashSet<K>,

}

impl<K: Eq + Copy + Hash, V> Dag<K, V> {

    /// Create a new empty DAG.

    pub fn new() -> Self {

        Self {

            graph: HashMap::new(),

            tips: HashSet::new(),

            roots: HashSet::new(),

        }

    }

    /// Check whether there are any nodes in the graph.

    pub fn is_empty(&self) -> bool {

        self.graph.is_empty()

    }

    /// Return the number of nodes in the graph.

    pub fn len(&self) -> usize {

        self.graph.len()

    }

    /// Add a node to the graph.

    pub fn node(&mut self, key: K, value: V) -> Option<Node<K, V>> {

        self.tips.insert(key);

        self.roots.insert(key);

        self.graph.insert(

            key,

            Node {

                value,

                dependencies: HashSet::new(),

                dependents: HashSet::new(),

            },

        )

    }

    /// Add a dependency from one node to the other.

    pub fn dependency(&mut self, from: K, to: K) {

        if let Some(node) = self.graph.get_mut(&from) {

            node.dependencies.insert(to);

            self.roots.remove(&from);

        }

        if let Some(node) = self.graph.get_mut(&to) {

            node.dependents.insert(from);

            self.tips.remove(&to);

        }

    }

    /// Get a node.

    pub fn get(&self, key: &K) -> Option<&Node<K, V>> {

        self.graph.get(key)

    }

    /// Check whether there is a dependency between two nodes.

    pub fn has_dependency(&self, from: &K, to: &K) -> bool {

        self.graph

            .get(from)

            .map(|n| n.dependencies.contains(to))

            .unwrap_or_default()

    }

    /// Get the graph's root nodes, ie. nodes which don't depend on other nodes.

    pub fn roots(&self) -> impl Iterator<Item = (&K, &Node<K, V>)> + '_ {

        self.roots

            .iter()

            .filter_map(|k| self.graph.get(k).map(|n| (k, n)))

    }

    /// Get the graph's tip nodes, ie. nodes which aren't depended on by other nodes.

    pub fn tips(&self) -> impl Iterator<Item = (&K, &Node<K, V>)> + '_ {

        self.tips

            .iter()

            .filter_map(|k| self.graph.get(k).map(|n| (k, n)))

    }

    /// Return a topological ordering of the graph's nodes, using the given RNG.

    /// Graphs with more than one partial order will return an arbitrary topological ordering.

    ///

    /// Calling this function over and over will eventually yield all possible orderings.

    pub fn sorted(&self, rng: fastrand::Rng) -> Vec<K> {

        let mut order = Vec::new(); // Stores the topological order.

        let mut visited = HashSet::new(); // Nodes that have been visited.

        let mut keys = self.graph.keys().collect::<Vec<_>>();

        rng.shuffle(&mut keys);

        for node in keys {

            self.visit(node, &mut visited, &mut order);

        }

        order

    }

    /// Add nodes recursively to the topological order, starting from the given node.

    fn visit(&self, key: &K, visited: &mut HashSet<K>, order: &mut Vec<K>) {

        if visited.contains(key) {

            return;

        }

        visited.insert(*key);

        // Recursively visit all of the node's dependencies.

        if let Some(node) = self.graph.get(key) {

            for dependency in &node.dependencies {

                self.visit(dependency, visited, order);

            }

        }

        // Add the node to the topological order.

        order.push(*key);

    }

}

impl<K: Eq + Copy + Hash + fmt::Debug, V> Index<&K> for Dag<K, V> {

    type Output = Node<K, V>;

    fn index(&self, key: &K) -> &Self::Output {

        self.get(key)

            .unwrap_or_else(|| panic!("Dag::index: node {:?} not found in graph", key))

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn test_len() {

        let mut dag = Dag::new();

        dag.node(0, ());

        dag.node(1, ());

        dag.node(2, ());

        assert_eq!(dag.len(), 3);

    }

    #[test]

    fn test_is_empty() {

        let mut dag = Dag::new();

        assert!(dag.is_empty());

        dag.node(0, ());

        assert!(!dag.is_empty());

    }

    #[test]

    fn test_dependencies() {

        let mut dag = Dag::new();

        dag.node(0, ());

        dag.node(1, ());

        dag.dependency(0, 1);

        assert!(dag.has_dependency(&0, &1));

        assert!(!dag.has_dependency(&1, &0));

    }

    #[test]

    fn test_get() {

        let mut dag = Dag::new();

        dag.node(0, "rad");

        dag.node(1, "dar");

        assert_eq!(dag[&0].value, "rad");

        assert_eq!(dag[&1].value, "dar");

        assert!(dag.get(&2).is_none());

    }

    #[test]

    fn test_cycle() {

        let mut dag = Dag::new();

        dag.node(0, ());

        dag.node(1, ());

        dag.dependency(0, 1);

        dag.dependency(1, 0);

        let sorted = dag.sorted(fastrand::Rng::new());

        let expected: &[&[i32]] = &[&[0, 1], &[1, 0]];

        assert!(expected.contains(&sorted.as_slice()));

    }

    #[test]

    fn test_diamond() {

        let mut dag = Dag::new();

        dag.node(0, ());

        dag.node(1, ());

        dag.node(2, ());

        dag.node(3, ());

        dag.dependency(1, 0);

        dag.dependency(2, 0);

        dag.dependency(3, 1);

        dag.dependency(3, 2);

        assert_eq!(dag.tips().map(|(k, _)| *k).collect::<Vec<_>>(), vec![3]);

        assert_eq!(dag.roots().map(|(k, _)| *k).collect::<Vec<_>>(), vec![0]);

        // All of the possible sort orders for the above graph.

        let expected: &[&[i32]] = &[&[0, 1, 2, 3], &[0, 2, 1, 3]];

        let actual = dag.sorted(fastrand::Rng::new());

        assert!(expected.contains(&actual.as_slice()), "{:?}", actual);

    }

    #[test]

    fn test_complex() {

        let mut dag = Dag::new();

        dag.node(0, ());

        dag.node(1, ());

        dag.node(2, ());

        dag.node(3, ());

        dag.node(4, ());

        dag.node(5, ());

        dag.dependency(3, 2);

        dag.dependency(1, 3);

        dag.dependency(2, 5);

        dag.dependency(0, 5);

        dag.dependency(0, 4);

        dag.dependency(1, 4);

        assert_eq!(

            dag.tips().map(|(k, _)| *k).collect::<HashSet<_>>(),

            HashSet::from_iter([1, 0])

        );

        assert_eq!(

            dag.roots().map(|(k, _)| *k).collect::<HashSet<_>>(),

            HashSet::from_iter([4, 5])

        );

        // All of the possible sort orders for the above graph.

        let expected = &[

            [4, 5, 0, 2, 3, 1],

            [4, 5, 2, 0, 3, 1],

            [4, 5, 2, 3, 0, 1],

            [4, 5, 2, 3, 1, 0],

            [5, 2, 3, 4, 0, 1],

            [5, 2, 3, 4, 1, 0],

            [5, 2, 4, 0, 3, 1],

            [5, 2, 4, 3, 0, 1],

            [5, 2, 4, 3, 1, 0],

            [5, 4, 0, 2, 3, 1],

            [5, 4, 2, 0, 3, 1],

            [5, 4, 2, 3, 0, 1],

            [5, 4, 2, 3, 1, 0],

        ];

        let rng = fastrand::Rng::new();

        let mut sorts = HashSet::new();

        while sorts.len() < expected.len() {

            sorts.insert(dag.sorted(rng.clone()));

        }

        for e in expected {

            assert!(sorts.remove(e.to_vec().as_slice()));

        }

        assert!(sorts.is_empty());

    }

}