Upload folder using huggingface_hub

1e92f2d verified over 1 year ago

8.11 kB

use std::{collections::VecDeque, hash::Hash};

use rustc_hash::{FxHashMap, FxHashSet};
use serde::{Deserialize, Serialize};
use turbo_tasks_macros::{TraceRawVcs, ValueDebugFormat};

use super::graph_store::{GraphNode, GraphStore};
use crate::{self as turbo_tasks, NonLocalValue};

/// A graph traversal that builds an adjacency map
#[derive(Debug, Clone, Serialize, Deserialize, TraceRawVcs, ValueDebugFormat)]
#[serde(bound(
    serialize = "T: Serialize + Eq + Hash",
    deserialize = "T: Deserialize<'de> + Eq + Hash"
))]
pub struct AdjacencyMap<T> {
    adjacency_map: FxHashMap<T, Vec<T>>,
    roots: Vec<T>,
}

unsafe impl<T> NonLocalValue for AdjacencyMap<T> where T: NonLocalValue {}

impl<T> PartialEq for AdjacencyMap<T>
where
    T: Eq + Hash,
{
    fn eq(&self, other: &Self) -> bool {
        self.adjacency_map == other.adjacency_map && self.roots == other.roots
    }
}

impl<T> Eq for AdjacencyMap<T> where T: Eq + Hash {}

impl<T> Default for AdjacencyMap<T>
where
    T: Eq + Hash + Clone,
{
    fn default() -> Self {
        Self::new()
    }
}

impl<T> AdjacencyMap<T>
where
    T: Eq + Hash + Clone,
{
    /// Creates a new adjacency map
    pub fn new() -> Self {
        Self {
            adjacency_map: FxHashMap::default(),
            roots: Vec::new(),
        }
    }

    /// Returns an iterator over the root nodes of the graph
    pub fn roots(&self) -> impl Iterator<Item = &T> {
        self.roots.iter()
    }

    /// Returns an iterator over the children of the given node
    pub fn get(&self, node: &T) -> Option<impl Iterator<Item = &T>> {
        self.adjacency_map.get(node).map(|vec| vec.iter())
    }
}

impl<T> GraphStore for AdjacencyMap<T>
where
    T: Eq + Hash + Clone + Send,
{
    type Node = T;
    type Handle = T;

    fn insert(&mut self, from_handle: Option<T>, node: GraphNode<T>) -> Option<(Self::Handle, &T)> {
        let vec = if let Some(from_handle) = from_handle {
            self.adjacency_map
                .entry(from_handle)
                .or_insert_with(|| Vec::with_capacity(1))
        } else {
            &mut self.roots
        };

        vec.push(node.node().clone());
        Some((node.into_node(), vec.last().unwrap()))
    }
}

impl<T> AdjacencyMap<T>
where
    T: Eq + Hash + Clone,
{
    /// Returns an owned iterator over the nodes in postorder topological order,
    /// starting from the roots.
    pub fn into_postorder_topological(self) -> IntoPostorderTopologicalIter<T> {
        IntoPostorderTopologicalIter {
            adjacency_map: self.adjacency_map,
            stack: self
                .roots
                .into_iter()
                .rev()
                .map(|root| (ReverseTopologicalPass::Pre, root))
                .collect(),
            visited: FxHashSet::default(),
        }
    }

    /// Returns an owned iterator over all edges (node pairs) in reverse breadth first order,
    /// starting from the roots.
    pub fn into_breadth_first_edges(self) -> IntoBreadthFirstEdges<T> {
        IntoBreadthFirstEdges {
            adjacency_map: self.adjacency_map,
            queue: self
                .roots
                .into_iter()
                .rev()
                .map(|root| (None, root))
                .collect(),
            expanded: FxHashSet::default(),
        }
    }

    /// Returns an iterator over the nodes in postorder topological order,
    /// starting from the roots.
    pub fn postorder_topological(&self) -> PostorderTopologicalIter<'_, T> {
        PostorderTopologicalIter {
            adjacency_map: &self.adjacency_map,
            stack: self
                .roots
                .iter()
                .rev()
                .map(|root| (ReverseTopologicalPass::Pre, root))
                .collect(),
            visited: FxHashSet::default(),
        }
    }

    /// Returns an iterator over the nodes in postorder topological order,
    /// starting from the given node.
    pub fn postorder_topological_from_node<'graph>(
        &'graph self,
        node: &'graph T,
    ) -> PostorderTopologicalIter<'graph, T> {
        PostorderTopologicalIter {
            adjacency_map: &self.adjacency_map,
            stack: vec![(ReverseTopologicalPass::Pre, node)],
            visited: FxHashSet::default(),
        }
    }
}

#[derive(Debug)]
enum ReverseTopologicalPass {
    Pre,
    Post,
}

/// An iterator over the nodes of a graph in postorder topological order, starting
/// from the roots.
pub struct IntoPostorderTopologicalIter<T>
where
    T: Eq + Hash + Clone,
{
    adjacency_map: FxHashMap<T, Vec<T>>,
    stack: Vec<(ReverseTopologicalPass, T)>,
    visited: FxHashSet<T>,
}

impl<T> Iterator for IntoPostorderTopologicalIter<T>
where
    T: Eq + Hash + Clone,
{
    type Item = T;

    fn next(&mut self) -> Option<Self::Item> {
        let current = loop {
            let (pass, current) = self.stack.pop()?;

            match pass {
                ReverseTopologicalPass::Post => {
                    break current;
                }
                ReverseTopologicalPass::Pre => {
                    if self.visited.contains(&current) {
                        continue;
                    }

                    self.visited.insert(current.clone());

                    let Some(neighbors) = self.adjacency_map.get(&current) else {
                        break current;
                    };

                    self.stack.push((ReverseTopologicalPass::Post, current));
                    self.stack.extend(
                        neighbors
                            .iter()
                            .rev()
                            .map(|neighbor| (ReverseTopologicalPass::Pre, neighbor.clone())),
                    );
                }
            }
        };

        Some(current)
    }
}

pub struct IntoBreadthFirstEdges<T>
where
    T: Eq + std::hash::Hash + Clone,
{
    adjacency_map: FxHashMap<T, Vec<T>>,
    queue: VecDeque<(Option<T>, T)>,
    expanded: FxHashSet<T>,
}

impl<T> Iterator for IntoBreadthFirstEdges<T>
where
    T: Eq + std::hash::Hash + Clone,
{
    type Item = (Option<T>, T);

    fn next(&mut self) -> Option<Self::Item> {
        let (parent, current) = self.queue.pop_front()?;

        let Some(neighbors) = self.adjacency_map.get(&current) else {
            return Some((parent, current));
        };

        if self.expanded.insert(current.clone()) {
            self.queue.extend(
                neighbors
                    .iter()
                    .map(|neighbor| (Some(current.clone()), neighbor.clone())),
            );
        }

        Some((parent, current))
    }
}

/// An iterator over the nodes of a graph in postorder topological order, starting
/// from the roots.
pub struct PostorderTopologicalIter<'graph, T>
where
    T: Eq + Hash + Clone,
{
    adjacency_map: &'graph FxHashMap<T, Vec<T>>,
    stack: Vec<(ReverseTopologicalPass, &'graph T)>,
    visited: FxHashSet<&'graph T>,
}

impl<'graph, T> Iterator for PostorderTopologicalIter<'graph, T>
where
    T: Eq + Hash + Clone,
{
    type Item = &'graph T;

    fn next(&mut self) -> Option<Self::Item> {
        let current = loop {
            let (pass, current) = self.stack.pop()?;

            match pass {
                ReverseTopologicalPass::Post => {
                    break current;
                }
                ReverseTopologicalPass::Pre => {
                    if self.visited.contains(current) {
                        continue;
                    }

                    self.visited.insert(current);

                    let Some(neighbors) = self.adjacency_map.get(current) else {
                        break current;
                    };

                    self.stack.push((ReverseTopologicalPass::Post, current));
                    self.stack.extend(
                        neighbors
                            .iter()
                            .rev()
                            .map(|neighbor| (ReverseTopologicalPass::Pre, neighbor)),
                    );
                }
            }
        };

        Some(current)
    }
}

	use std::{collections::VecDeque, hash::Hash};

	use rustc_hash::{FxHashMap, FxHashSet};
	use serde::{Deserialize, Serialize};
	use turbo_tasks_macros::{TraceRawVcs, ValueDebugFormat};

	use super::graph_store::{GraphNode, GraphStore};
	use crate::{self as turbo_tasks, NonLocalValue};

	/// A graph traversal that builds an adjacency map
	#[derive(Debug, Clone, Serialize, Deserialize, TraceRawVcs, ValueDebugFormat)]
	#[serde(bound(
	serialize = "T: Serialize + Eq + Hash",
	deserialize = "T: Deserialize<'de> + Eq + Hash"
	))]
	pub struct AdjacencyMap<T> {
	adjacency_map: FxHashMap<T, Vec<T>>,
	roots: Vec<T>,
	}

	unsafe impl<T> NonLocalValue for AdjacencyMap<T> where T: NonLocalValue {}

	impl<T> PartialEq for AdjacencyMap<T>
	where
	T: Eq + Hash,
	{
	fn eq(&self, other: &Self) -> bool {
	self.adjacency_map == other.adjacency_map && self.roots == other.roots
	}
	}

	impl<T> Eq for AdjacencyMap<T> where T: Eq + Hash {}

	impl<T> Default for AdjacencyMap<T>
	where
	T: Eq + Hash + Clone,
	{
	fn default() -> Self {
	Self::new()
	}
	}

	impl<T> AdjacencyMap<T>
	where
	T: Eq + Hash + Clone,
	{
	/// Creates a new adjacency map
	pub fn new() -> Self {
	Self {
	adjacency_map: FxHashMap::default(),
	roots: Vec::new(),
	}
	}

	/// Returns an iterator over the root nodes of the graph
	pub fn roots(&self) -> impl Iterator<Item = &T> {
	self.roots.iter()
	}

	/// Returns an iterator over the children of the given node
	pub fn get(&self, node: &T) -> Option<impl Iterator<Item = &T>> {
	self.adjacency_map.get(node).map(\|vec\| vec.iter())
	}
	}

	impl<T> GraphStore for AdjacencyMap<T>
	where
	T: Eq + Hash + Clone + Send,
	{
	type Node = T;
	type Handle = T;

	fn insert(&mut self, from_handle: Option<T>, node: GraphNode<T>) -> Option<(Self::Handle, &T)> {
	let vec = if let Some(from_handle) = from_handle {
	self.adjacency_map
	.entry(from_handle)
	.or_insert_with(\|\| Vec::with_capacity(1))
	} else {
	&mut self.roots
	};

	vec.push(node.node().clone());
	Some((node.into_node(), vec.last().unwrap()))
	}
	}

	impl<T> AdjacencyMap<T>
	where
	T: Eq + Hash + Clone,
	{
	/// Returns an owned iterator over the nodes in postorder topological order,
	/// starting from the roots.
	pub fn into_postorder_topological(self) -> IntoPostorderTopologicalIter<T> {
	IntoPostorderTopologicalIter {
	adjacency_map: self.adjacency_map,
	stack: self
	.roots
	.into_iter()
	.rev()
	.map(\|root\| (ReverseTopologicalPass::Pre, root))
	.collect(),
	visited: FxHashSet::default(),
	}
	}

	/// Returns an owned iterator over all edges (node pairs) in reverse breadth first order,
	/// starting from the roots.
	pub fn into_breadth_first_edges(self) -> IntoBreadthFirstEdges<T> {
	IntoBreadthFirstEdges {
	adjacency_map: self.adjacency_map,
	queue: self
	.roots
	.into_iter()
	.rev()
	.map(\|root\| (None, root))
	.collect(),
	expanded: FxHashSet::default(),
	}
	}

	/// Returns an iterator over the nodes in postorder topological order,
	/// starting from the roots.
	pub fn postorder_topological(&self) -> PostorderTopologicalIter<'_, T> {
	PostorderTopologicalIter {
	adjacency_map: &self.adjacency_map,
	stack: self
	.roots
	.iter()
	.rev()
	.map(\|root\| (ReverseTopologicalPass::Pre, root))
	.collect(),
	visited: FxHashSet::default(),
	}
	}

	/// Returns an iterator over the nodes in postorder topological order,
	/// starting from the given node.
	pub fn postorder_topological_from_node<'graph>(
	&'graph self,
	node: &'graph T,
	) -> PostorderTopologicalIter<'graph, T> {
	PostorderTopologicalIter {
	adjacency_map: &self.adjacency_map,
	stack: vec![(ReverseTopologicalPass::Pre, node)],
	visited: FxHashSet::default(),
	}
	}
	}

	#[derive(Debug)]
	enum ReverseTopologicalPass {
	Pre,
	Post,
	}

	/// An iterator over the nodes of a graph in postorder topological order, starting
	/// from the roots.
	pub struct IntoPostorderTopologicalIter<T>
	where
	T: Eq + Hash + Clone,
	{
	adjacency_map: FxHashMap<T, Vec<T>>,
	stack: Vec<(ReverseTopologicalPass, T)>,
	visited: FxHashSet<T>,
	}

	impl<T> Iterator for IntoPostorderTopologicalIter<T>
	where
	T: Eq + Hash + Clone,
	{
	type Item = T;

	fn next(&mut self) -> Option<Self::Item> {
	let current = loop {
	let (pass, current) = self.stack.pop()?;

	match pass {
	ReverseTopologicalPass::Post => {
	break current;
	}
	ReverseTopologicalPass::Pre => {
	if self.visited.contains(&current) {
	continue;
	}

	self.visited.insert(current.clone());

	let Some(neighbors) = self.adjacency_map.get(&current) else {
	break current;
	};

	self.stack.push((ReverseTopologicalPass::Post, current));
	self.stack.extend(
	neighbors
	.iter()
	.rev()
	.map(\|neighbor\| (ReverseTopologicalPass::Pre, neighbor.clone())),
	);
	}
	}
	};

	Some(current)
	}
	}

	pub struct IntoBreadthFirstEdges<T>
	where
	T: Eq + std::hash::Hash + Clone,
	{
	adjacency_map: FxHashMap<T, Vec<T>>,
	queue: VecDeque<(Option<T>, T)>,
	expanded: FxHashSet<T>,
	}

	impl<T> Iterator for IntoBreadthFirstEdges<T>
	where
	T: Eq + std::hash::Hash + Clone,
	{
	type Item = (Option<T>, T);

	fn next(&mut self) -> Option<Self::Item> {
	let (parent, current) = self.queue.pop_front()?;

	let Some(neighbors) = self.adjacency_map.get(&current) else {
	return Some((parent, current));
	};

	if self.expanded.insert(current.clone()) {
	self.queue.extend(
	neighbors
	.iter()
	.map(\|neighbor\| (Some(current.clone()), neighbor.clone())),
	);
	}

	Some((parent, current))
	}
	}

	/// An iterator over the nodes of a graph in postorder topological order, starting
	/// from the roots.
	pub struct PostorderTopologicalIter<'graph, T>
	where
	T: Eq + Hash + Clone,
	{
	adjacency_map: &'graph FxHashMap<T, Vec<T>>,
	stack: Vec<(ReverseTopologicalPass, &'graph T)>,
	visited: FxHashSet<&'graph T>,
	}

	impl<'graph, T> Iterator for PostorderTopologicalIter<'graph, T>
	where
	T: Eq + Hash + Clone,
	{
	type Item = &'graph T;

	fn next(&mut self) -> Option<Self::Item> {
	let current = loop {
	let (pass, current) = self.stack.pop()?;

	match pass {
	ReverseTopologicalPass::Post => {
	break current;
	}
	ReverseTopologicalPass::Pre => {
	if self.visited.contains(current) {
	continue;
	}

	self.visited.insert(current);

	let Some(neighbors) = self.adjacency_map.get(current) else {
	break current;
	};

	self.stack.push((ReverseTopologicalPass::Post, current));
	self.stack.extend(
	neighbors
	.iter()
	.rev()
	.map(\|neighbor\| (ReverseTopologicalPass::Pre, neighbor)),
	);
	}
	}
	};

	Some(current)
	}
	}