use crate::traits::refs::{DirectedRef, FiniteDigraphRef, FiniteGraphRef, GraphTypeRef, IndexGraphRef, UndirectedRef};
use crate::traits::{
Directed, DirectedEdge, FiniteDigraph, FiniteGraph, GraphIterator, GraphType, IndexGraph, Undirected,
};
#[derive(Clone, Copy)]
pub struct ReverseDigraph<'a, G>(&'a G);
#[derive(Clone, Copy, PartialEq, Eq)]
pub struct ReverseDirectedEdge<E>(E);
#[derive(Clone)]
pub struct ReverseWrapIt<I>(I);
impl<'a, G, I> GraphIterator<ReverseDigraph<'a, G>> for ReverseWrapIt<I>
where
I: GraphIterator<G>,
{
type Item = I::Item;
fn next(&mut self, g: &ReverseDigraph<'a, G>) -> Option<I::Item> {
self.0.next(g.0)
}
fn size_hint(&self, g: &ReverseDigraph<'a, G>) -> (usize, Option<usize>) {
self.0.size_hint(g.0)
}
fn count(self, g: &ReverseDigraph<'a, G>) -> usize {
self.0.count(g.0)
}
}
impl<E> DirectedEdge for ReverseDirectedEdge<E>
where
E: DirectedEdge,
{
type Edge = E::Edge;
fn is_incoming(&self) -> bool {
self.0.is_outgoing()
}
fn is_outgoing(&self) -> bool {
self.0.is_incoming()
}
fn edge(&self) -> Self::Edge {
self.0.edge()
}
}
impl<'g, G> GraphType for ReverseDigraph<'g, G>
where
G: GraphType,
{
type Node<'a> = G::Node<'a>;
type Edge<'a> = G::Edge<'a>;
}
impl<'g, G> FiniteGraph for ReverseDigraph<'g, G>
where
G: FiniteGraph,
{
type NodeIt<'a> = ReverseWrapIt<G::NodeIt<'a>>
where
G: 'a,
'g: 'a;
type EdgeIt<'a> = ReverseWrapIt<G::EdgeIt<'a>>
where
G: 'a,
'g: 'a;
fn num_nodes(&self) -> usize {
self.0.num_nodes()
}
fn num_edges(&self) -> usize {
self.0.num_edges()
}
fn nodes_iter(&self) -> Self::NodeIt<'_> {
ReverseWrapIt(self.0.nodes_iter())
}
fn edges_iter(&self) -> Self::EdgeIt<'_> {
ReverseWrapIt(self.0.edges_iter())
}
fn enodes(&self, e: Self::Edge<'_>) -> (Self::Node<'_>, Self::Node<'_>) {
self.0.enodes(e)
}
}
impl<'g, G> FiniteDigraph for ReverseDigraph<'g, G>
where
G: FiniteDigraph,
{
fn src(&self, e: Self::Edge<'_>) -> Self::Node<'_> {
self.0.snk(e)
}
fn snk(&self, e: Self::Edge<'_>) -> Self::Node<'_> {
self.0.src(e)
}
}
impl<'g, G> Undirected for ReverseDigraph<'g, G>
where
G: Undirected,
{
type NeighIt<'a> = ReverseWrapIt<G::NeighIt<'a>>
where
G: 'a,
'g: 'a;
fn neigh_iter(&self, u: Self::Node<'_>) -> Self::NeighIt<'_> {
ReverseWrapIt(self.0.neigh_iter(u))
}
}
impl<'g, G> IndexGraph for ReverseDigraph<'g, G>
where
G: IndexGraph,
{
fn node_id(&self, u: Self::Node<'_>) -> usize {
self.0.node_id(u)
}
fn id2node(&self, id: usize) -> Self::Node<'_> {
self.0.id2node(id)
}
fn edge_id(&self, e: Self::Edge<'_>) -> usize {
self.0.edge_id(e)
}
fn id2edge(&self, id: usize) -> Self::Edge<'_> {
self.0.id2edge(id)
}
}
#[derive(Clone)]
pub struct ReverseIncidentIt<I>(I);
impl<'a, G, I, N, D> GraphIterator<ReverseDigraph<'a, G>> for ReverseIncidentIt<I>
where
I: GraphIterator<G, Item = (D, N)>,
D: DirectedEdge,
{
type Item = (ReverseDirectedEdge<D>, N);
fn next(&mut self, g: &ReverseDigraph<G>) -> Option<Self::Item> {
self.0.next(g.0).map(|(e, v)| (ReverseDirectedEdge(e), v))
}
fn size_hint(&self, g: &ReverseDigraph<G>) -> (usize, Option<usize>) {
self.0.size_hint(g.0)
}
fn count(self, g: &ReverseDigraph<G>) -> usize {
self.0.count(g.0)
}
}
impl<'g, G> Directed for ReverseDigraph<'g, G>
where
G: Directed,
{
type OutIt<'a> = ReverseWrapIt<G::InIt<'a>>
where
G: 'a,
'g: 'a;
type InIt<'a> = ReverseWrapIt<G::OutIt<'a>>
where
G: 'a,
'g: 'a;
type IncidentIt<'a> = ReverseIncidentIt<G::IncidentIt<'a>>
where
G: 'a,
'g: 'a,;
type DirectedEdge<'a> = ReverseDirectedEdge<G::DirectedEdge<'a>>
where
Self: 'a;
fn out_iter(&self, u: Self::Node<'_>) -> Self::OutIt<'_> {
ReverseWrapIt(self.0.in_iter(u))
}
fn in_iter(&self, u: Self::Node<'_>) -> Self::InIt<'_> {
ReverseWrapIt(self.0.out_iter(u))
}
fn incident_iter(&self, u: Self::Node<'_>) -> Self::IncidentIt<'_> {
ReverseIncidentIt(self.0.incident_iter(u))
}
}
pub fn reverse<G: Directed>(g: &G) -> ReverseDigraph<G> {
ReverseDigraph(g)
}
impl<'a, G> GraphTypeRef<'a> for ReverseDigraph<'a, G>
where
G: GraphTypeRef<'a>,
{
type Node = G::Node;
type Edge = G::Edge;
}
impl<'a, G> FiniteGraphRef<'a> for ReverseDigraph<'a, G>
where
G: FiniteGraphRef<'a>,
{
type NodeIt = ReverseWrapIt<G::NodeIt>;
type EdgeIt = ReverseWrapIt<G::EdgeIt>;
fn num_nodes(&self) -> usize {
self.0.num_nodes()
}
fn num_edges(&self) -> usize {
self.0.num_edges()
}
fn nodes_iter(&self) -> Self::NodeIt {
ReverseWrapIt(self.0.nodes_iter())
}
fn edges_iter(&self) -> Self::EdgeIt {
ReverseWrapIt(self.0.edges_iter())
}
fn enodes(&self, e: Self::Edge) -> (Self::Node, Self::Node) {
self.0.enodes(e)
}
}
impl<'a, G> FiniteDigraphRef<'a> for ReverseDigraph<'a, G>
where
G: FiniteDigraphRef<'a>,
{
fn src(&self, e: Self::Edge) -> Self::Node {
self.0.snk(e)
}
fn snk(&self, e: Self::Edge) -> Self::Node {
self.0.src(e)
}
}
impl<'a, G> UndirectedRef<'a> for ReverseDigraph<'a, G>
where
G: UndirectedRef<'a>,
{
type NeighIt = ReverseWrapIt<G::NeighIt>;
fn neigh_iter(&self, u: Self::Node) -> Self::NeighIt {
ReverseWrapIt(UndirectedRef::neigh_iter(self.0, u))
}
}
impl<'a, G> DirectedRef<'a> for ReverseDigraph<'a, G>
where
G: DirectedRef<'a>,
{
type OutIt = ReverseWrapIt<G::InIt>;
type InIt = ReverseWrapIt<G::OutIt>;
type IncidentIt = ReverseIncidentIt<G::IncidentIt>;
type DirectedEdge = ReverseDirectedEdge<G::DirectedEdge>;
fn out_iter(&self, u: Self::Node) -> Self::OutIt {
ReverseWrapIt(DirectedRef::in_iter(self.0, u))
}
fn in_iter(&self, u: Self::Node) -> Self::InIt {
ReverseWrapIt(DirectedRef::out_iter(self.0, u))
}
fn incident_iter(&self, u: Self::Node) -> Self::IncidentIt {
ReverseIncidentIt(self.0.incident_iter(u))
}
}
impl<'a, G> IndexGraphRef<'a> for ReverseDigraph<'a, G>
where
G: IndexGraphRef<'a>,
{
fn node_id(&self, u: Self::Node) -> usize {
self.0.node_id(u)
}
fn edge_id(&self, e: Self::Edge) -> usize {
self.0.edge_id(e)
}
fn id2node(&self, id: usize) -> Self::Node {
self.0.id2node(id)
}
fn id2edge(&self, id: usize) -> Self::Edge {
self.0.id2edge(id)
}
}