hypergraphx 0.0.5

use std::ops::DerefMut;

use crate::prelude::*;
#[cfg(feature = "rayon")]
use rayon::prelude::*;

/// This trait allows mutable access to the node and edge *weights* of a graph.
/// It's generally a bad idea to mess with the graph incidence data - that's why there's no
/// mutable access to `Node`s or `Edge`s. You can, however, go crazy with the weights.
///
/// As for shared access to the weights, just iterate over the nodes (edges) and access the weights directly.
pub trait Weights<'a, N: 'a, E: 'a>: GraphBasics<'a> {
    fn node_weights(&'a self) -> impl Iterator<Item = &'a N> + 'a;
    fn edge_weights(&'a self) -> impl Iterator<Item = &'a E> + 'a;
    fn node_weights_mut(&'a mut self) -> impl Iterator<Item = &'a mut N> + 'a;
    fn edge_weights_mut(&'a mut self) -> impl Iterator<Item = &'a mut E> + 'a;
    fn node_weight_mut(
        &'a mut self,
        node_index: <Self as GraphBasics<'a>>::NodeIndex,
    ) -> Option<&'a mut N>;
    fn edge_weight_mut(
        &'a mut self,
        edge_index: <Self as GraphBasics<'a>>::EdgeIndex,
    ) -> Option<&'a mut E>;
    fn node_weight(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> Option<&'a N>;
    fn edge_weight(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> Option<&'a E>;
    // Be nice to have these, I figured.
    unsafe fn node_weight_unchecked(
        &'a self,
        node_index: <Self as GraphBasics<'a>>::NodeIndex,
    ) -> &'a N;
    unsafe fn edge_weight_unchecked(
        &'a self,
        edge_index: <Self as GraphBasics<'a>>::EdgeIndex,
    ) -> &'a E;
    unsafe fn node_weight_unchecked_mut(
        &'a mut self,
        node_index: <Self as GraphBasics<'a>>::NodeIndex,
    ) -> &'a mut N;
    unsafe fn edge_weight_unchecked_mut(
        &'a mut self,
        edge_index: <Self as GraphBasics<'a>>::EdgeIndex,
    ) -> &'a mut E;
    fn edge_weight_copied(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> Option<E>
    where
        E: Copy;
    fn node_weight_copied(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> Option<N>
    where
        N: Copy;
    unsafe fn edge_weight_copied_unchecked(
        &'a self,
        edge_index: <Self as GraphBasics<'a>>::EdgeIndex,
    ) -> E
    where
        E: Copy;
    unsafe fn node_weight_copied_unchecked(
        &'a self,
        node_index: <Self as GraphBasics<'a>>::NodeIndex,
    ) -> N
    where
        N: Copy;
}

#[macro_export]
macro_rules! impl_weights {
    ($graph:ty$(, <$($gens:tt),*>)? $(, |$(const $cgens:ident: $ity:ty),*|)?) => {
        impl<'a, N: 'a, E: 'a$(, $($gens),*)?$(, $(const $cgens: $ity),*)?> Weights<'a, N, E> for $graph
        where
            N: Clone + Eq + Hash,
            E: Clone + Eq + Hash,
        {
            fn node_weights(&'a self) -> impl Iterator<Item = &'a N> + 'a {
                self.nodes.iter().map(|node| &node.weight)
            }

            fn edge_weights(&'a self) -> impl Iterator<Item = &'a E> + 'a {
                self.edges.iter().map(|edge| &edge.weight)
            }

            fn node_weights_mut(&'a mut self) -> impl Iterator<Item = &'a mut N> + 'a {
                self.nodes.iter_mut().map(|node| &mut node.weight)
            }

            fn edge_weights_mut(&'a mut self) -> impl Iterator<Item = &'a mut E> + 'a {
                self.edges.iter_mut().map(|edge| &mut edge.weight)
            }

            fn node_weight_mut(&'a mut self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> Option<&'a mut N> {
                self.nodes.get_mut(node_index).map(|node| &mut node.weight)
            }

            fn edge_weight_mut(&'a mut self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> Option<&'a mut E> {
                self.edges.get_mut(edge_index).map(|edge| &mut edge.weight)
            }

            fn node_weight(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> Option<&'a N> {
                self.nodes.get(node_index).map(|node| &node.weight)
            }

            fn edge_weight(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> Option<&'a E> {
                self.edges.get(edge_index).map(|edge| &edge.weight)
            }

            unsafe fn node_weight_unchecked(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> &'a N {
                unsafe {&self.nodes.get_unchecked(node_index).weight}
            }

            unsafe fn edge_weight_unchecked(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> &'a E {
                unsafe {&self.edges.get_unchecked(edge_index).weight}
            }

            unsafe fn node_weight_unchecked_mut(&'a mut self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> &'a mut N {
                unsafe {&mut self.nodes.get_unchecked_mut(node_index).weight}
            }

            unsafe fn edge_weight_unchecked_mut(&'a mut self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> &'a mut E {
                unsafe {&mut self.edges.get_unchecked_mut(edge_index).weight}
            }

            fn edge_weight_copied(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> Option<E> where E: Copy {
                Some(self.edges[edge_index].weight)
            }

            fn node_weight_copied(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> Option<N> where N: Copy {
                Some(self.nodes[node_index].weight)
            }

            unsafe fn edge_weight_copied_unchecked(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> E where E: Copy {
                unsafe{self.edges.get_unchecked(edge_index).weight}
            }

            unsafe fn node_weight_copied_unchecked(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> N where N: Copy {
                unsafe{self.nodes.get_unchecked(node_index).weight}
            }
        }

    }
}

#[macro_export]
macro_rules! impl_weights_wrapper {
    (
        $graph:ty,
        reduce N = $node_weight:tt,
        reduce E = $edge_weight:tt
        $(, <$($gens:tt),*>)?
        $(, |$(const $cgens:ident: $ity:ty),*|)?
    ) => {
        impl<'a, $(, $($gens),*)?$(, $(const $cgens: $ity),*)?> Weights<'a, $node_weight, $edge_weight> for $graph
        {
            fn node_weights(&'a self) -> impl Iterator<Item = &'a $node_weight> + 'a {
                self.inner.nodes.iter().map(|node| &node.weight)
            }

            fn edge_weights(&'a self) -> impl Iterator<Item = &'a $edge_weight> + 'a {
                self.inner.edges.iter().map(|edge| &edge.weight)
            }

            fn node_weights_mut(&'a mut self) -> impl Iterator<Item = &'a mut $node_weight> + 'a {
                self.inner.nodes.iter_mut().map(|node| &mut node.weight)
            }

            fn edge_weights_mut(&'a mut self) -> impl Iterator<Item = &'a mut $edge_weight> + 'a {
                self.inner.edges.iter_mut().map(|edge| &mut edge.weight)
            }

            fn node_weight_mut(&'a mut self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> Option<&'a mut $node_weight> {
                self.inner.nodes.get_mut(node_index).map(|node| &mut node.weight)
            }

            fn edge_weight_mut(&'a mut self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> Option<&'a mut $edge_weight> {
                self.inner.edges.get_mut(edge_index).map(|edge| &mut edge.weight)
            }

            fn node_weight(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> Option<&'a $node_weight> {
                self.inner.nodes.get(node_index).map(|node| &node.weight)
            }

            fn edge_weight(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> Option<&'a $edge_weight> {
                self.inner.edges.get(edge_index).map(|edge| &edge.weight)
            }

            unsafe fn node_weight_unchecked(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> &'a $node_weight {
                unsafe {&self.inner.nodes.get_unchecked(node_index).weight}
            }

            unsafe fn edge_weight_unchecked(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> &'a $edge_weight {
                unsafe {&self.inner.edges.get_unchecked(edge_index).weight}
            }

            unsafe fn node_weight_unchecked_mut(&'a mut self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> &'a mut $node_weight {
                unsafe {&mut self.inner.nodes.get_unchecked_mut(node_index).weight}
            }

            unsafe fn edge_weight_unchecked_mut(&'a mut self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> &'a mut $edge_weight {
                unsafe {&mut self.inner.edges.get_unchecked_mut(edge_index).weight}
            }

            fn edge_weight_copied(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> Option<E> where $edge_weight: Copy {
                Some(self.inner.edges[edge_index].weight)
            }

            fn node_weight_copied(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> Option<N> where $node_weight: Copy {
                Some(self.inner.nodes[node_index].weight)
            }

            unsafe fn edge_weight_copied_unchecked(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> $edge_weight where $edge_weight: Copy {
                unsafe{self.inner.edges.get_unchecked(edge_index).weight}
            }

            unsafe fn node_weight_copied_unchecked(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> $node_weight where $node_weight: Copy {
                unsafe{self.inner.nodes.get_unchecked(node_index).weight}
            }
        }

    };
    (
        $graph:ty,
        reduce N = $node_weight:tt
        $(, <$($gens:tt),*>)?
        $(, |$(const $cgens:ident: $ity:ty),*|)?
    ) => {
        impl<'a, E $(, $($gens),*)?$(, $(const $cgens: $ity),*)?> Weights<'a, $node_weight, E> for $graph
        where
            E: Clone + Eq + Hash + 'a,
        {
            fn node_weights(&'a self) -> impl Iterator<Item = &'a $node_weight> + 'a {
                self.inner.nodes.iter().map(|node| &node.weight)
            }

            fn edge_weights(&'a self) -> impl Iterator<Item = &'a E> + 'a {
                self.inner.edges.iter().map(|edge| &edge.weight)
            }

            fn node_weights_mut(&'a mut self) -> impl Iterator<Item = &'a mut $node_weight> + 'a {
                self.inner.nodes.iter_mut().map(|node| &mut node.weight)
            }

            fn edge_weights_mut(&'a mut self) -> impl Iterator<Item = &'a mut E> + 'a {
                self.inner.edges.iter_mut().map(|edge| &mut edge.weight)
            }

            fn node_weight_mut(&'a mut self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> Option<&'a mut $node_weight> {
                self.inner.nodes.get_mut(node_index).map(|node| &mut node.weight)
            }

            fn edge_weight_mut(&'a mut self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> Option<&'a mut E> {
                self.inner.edges.get_mut(edge_index).map(|edge| &mut edge.weight)
            }

            fn node_weight(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> Option<&'a $node_weight> {
                self.inner.nodes.get(node_index).map(|node| &node.weight)
            }

            fn edge_weight(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> Option<&'a E> {
                self.inner.edges.get(edge_index).map(|edge| &edge.weight)
            }

            unsafe fn node_weight_unchecked(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> &'a $node_weight {
                unsafe {&self.inner.nodes.get_unchecked(node_index).weight}
            }

            unsafe fn edge_weight_unchecked(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> &'a E {
                unsafe {&self.inner.edges.get_unchecked(edge_index).weight}
            }

            unsafe fn node_weight_unchecked_mut(&'a mut self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> &'a mut $node_weight {
                unsafe {&mut self.inner.nodes.get_unchecked_mut(node_index).weight}
            }

            unsafe fn edge_weight_unchecked_mut(&'a mut self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> &'a mut E {
                unsafe {&mut self.inner.edges.get_unchecked_mut(edge_index).weight}
            }

            fn edge_weight_copied(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> Option<E> where E: Copy {
                Some(self.inner.edges[edge_index].weight)
            }

            fn node_weight_copied(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> Option<$node_weight> where $node_weight: Copy {
                Some(self.inner.nodes[node_index].weight)
            }

            unsafe fn edge_weight_copied_unchecked(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> E where E: Copy {
                unsafe{self.inner.edges.get_unchecked(edge_index).weight}
            }

            unsafe fn node_weight_copied_unchecked(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> $node_weight where $node_weight: Copy {
                unsafe{self.inner.nodes.get_unchecked(node_index).weight}
            }
        }
    };
    (
        $graph:ty,
        reduce E = $edge_weight:tt
        $(, <$($gens:tt),*>)?
        $(, |$(const $cgens:ident: $ity:ty),*|)?
    ) => {
                impl<'a, N$(, $($gens),*)?$(, $(const $cgens: $ity),*)?> Weights<'a, N, $edge_weight> for $graph
        where
            N: Clone + Eq + Hash + 'a,
        {
            fn node_weights(&'a self) -> impl Iterator<Item = &'a N> + 'a {
                self.inner.nodes.iter().map(|node| &node.weight)
            }

            fn edge_weights(&'a self) -> impl Iterator<Item = &'a $edge_weight> + 'a {
                self.inner.edges.iter().map(|edge| &edge.weight)
            }

            fn node_weights_mut(&'a mut self) -> impl Iterator<Item = &'a mut N> + 'a {
                self.inner.nodes.iter_mut().map(|node| &mut node.weight)
            }

            fn edge_weights_mut(&'a mut self) -> impl Iterator<Item = &'a mut $edge_weight> + 'a {
                self.inner.edges.iter_mut().map(|edge| &mut edge.weight)
            }

            fn node_weight_mut(&'a mut self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> Option<&'a mut N> {
                self.inner.nodes.get_mut(node_index).map(|node| &mut node.weight)
            }

            fn edge_weight_mut(&'a mut self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> Option<&'a mut $edge_weight> {
                self.inner.edges.get_mut(edge_index).map(|edge| &mut edge.weight)
            }

            fn node_weight(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> Option<&'a N> {
                self.inner.nodes.get(node_index).map(|node| &node.weight)
            }

            fn edge_weight(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> Option<&'a $edge_weight>
            {
                self.inner.edges.get(edge_index).map(|edge| &edge.weight)
            }

            unsafe fn node_weight_unchecked(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> &'a N {
                unsafe {&self.inner.nodes.get_unchecked(node_index).weight}
            }

            unsafe fn edge_weight_unchecked(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> &'a $edge_weight {
                unsafe {&self.inner.edges.get_unchecked(edge_index).weight}
            }

            unsafe fn node_weight_unchecked_mut(&'a mut self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> &'a mut N {
                unsafe {&mut self.inner.nodes.get_unchecked_mut(node_index).weight}
            }

            unsafe fn edge_weight_unchecked_mut(&'a mut self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> &'a mut $edge_weight {
                unsafe {&mut self.inner.edges.get_unchecked_mut(edge_index).weight}
            }

            fn edge_weight_copied(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> Option<$edge_weight> where $edge_weight: Copy {
                Some(self.inner.edges[edge_index].weight)
            }

            fn node_weight_copied(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> Option<N> where N: Copy {
                Some(self.inner.nodes[node_index].weight)
            }

            unsafe fn edge_weight_copied_unchecked(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> $edge_weight where $edge_weight: Copy {
                unsafe{self.inner.edges.get_unchecked(edge_index).weight}
            }

            unsafe fn node_weight_copied_unchecked(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> N where N: Copy {
                unsafe{self.inner.nodes.get_unchecked(node_index).weight}
            }
        }
    };
    (
        $graph:ty
        $(, <$($gens:tt),*>)?
        $(, |$(const $cgens:ident: $ity:ty),*|)?
    ) => {
                impl<'a, N, E $(, $($gens),*)?$(, $(const $cgens: $ity),*)?> Weights<'a, N, E> for $graph
        where
            N: Clone + Eq + Hash + 'a,
            E: Clone + Eq + Hash + 'a,
        {
            fn node_weights(&'a self) -> impl Iterator<Item = &'a N> + 'a {
                self.inner.nodes.iter().map(|node| &node.weight)
            }

            fn edge_weights(&'a self) -> impl Iterator<Item = &'a E> + 'a {
                self.inner.edges.iter().map(|edge| &edge.weight)
            }

            fn node_weights_mut(&'a mut self) -> impl Iterator<Item = &'a mut N> + 'a {
                self.inner.nodes.iter_mut().map(|node| &mut node.weight)
            }

            fn edge_weights_mut(&'a mut self) -> impl Iterator<Item = &'a mut E> + 'a {
                self.inner.edges.iter_mut().map(|edge| &mut edge.weight)
            }

            fn node_weight_mut(&'a mut self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> Option<&'a mut N> {
                self.inner.nodes.get_mut(node_index).map(|node| &mut node.weight)
            }

            fn edge_weight_mut(&'a mut self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> Option<&'a mut E> {
                self.inner.edges.get_mut(edge_index).map(|edge| &mut edge.weight)
            }

            fn node_weight(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> Option<&'a N> {
                self.inner.nodes.get(node_index).map(|node| &node.weight)
            }

            fn edge_weight(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> Option<&'a E> {
                self.inner.edges.get(edge_index).map(|edge| &edge.weight)
            }

            unsafe fn node_weight_unchecked(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> &'a N {
                unsafe {&self.inner.nodes.get_unchecked(node_index).weight}
            }

            unsafe fn edge_weight_unchecked(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> &'a E {
                unsafe {&self.inner.edges.get_unchecked(edge_index).weight}
            }

            unsafe fn node_weight_unchecked_mut(&'a mut self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> &'a mut N {
                unsafe {&mut self.inner.nodes.get_unchecked_mut(node_index).weight}
            }

            unsafe fn edge_weight_unchecked_mut(&'a mut self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> &'a mut E {
                unsafe {&mut self.inner.edges.get_unchecked_mut(edge_index).weight}
            }

            fn edge_weight_copied(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> Option<E> where E: Copy {
                Some(self.inner.edges[edge_index].weight)
            }

            fn node_weight_copied(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> Option<N> where N: Copy {
                Some(self.inner.nodes[node_index].weight)
            }

            unsafe fn edge_weight_copied_unchecked(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> E where E: Copy {
                unsafe{self.inner.edges.get_unchecked(edge_index).weight}
            }

            unsafe fn node_weight_copied_unchecked(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> N where N: Copy {
                unsafe{self.inner.nodes.get_unchecked(node_index).weight}
            }
        }

    };
}

impl<'a, T: 'a, U, N: 'a, E: 'a> Weights<'a, N, E> for U
where
    T: Weights<'a, N, E>,
    U: DerefMut<Target = T>,
{
    fn node_weights_mut(&'a mut self) -> impl Iterator<Item = &'a mut N> + 'a {
        (**self).node_weights_mut()
    }

    fn edge_weights_mut(&'a mut self) -> impl Iterator<Item = &'a mut E> + 'a {
        (**self).edge_weights_mut()
    }

    fn node_weight_mut(
        &'a mut self,
        node_index: <Self as GraphBasics<'a>>::NodeIndex,
    ) -> Option<&'a mut N> {
        (**self).node_weight_mut(node_index)
    }

    fn edge_weight_mut(
        &'a mut self,
        edge_index: <Self as GraphBasics<'a>>::EdgeIndex,
    ) -> Option<&'a mut E> {
        (**self).edge_weight_mut(edge_index)
    }

    fn node_weight(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> Option<&'a N> {
        (**self).node_weight(node_index)
    }

    fn edge_weight(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> Option<&'a E> {
        (**self).edge_weight(edge_index)
    }

    unsafe fn node_weight_unchecked(
        &'a self,
        node_index: <Self as GraphBasics<'a>>::NodeIndex,
    ) -> &'a N {
        unsafe { (**self).node_weight_unchecked(node_index) }
    }

    unsafe fn edge_weight_unchecked(
        &'a self,
        edge_index: <Self as GraphBasics<'a>>::EdgeIndex,
    ) -> &'a E {
        unsafe { (**self).edge_weight_unchecked(edge_index) }
    }

    unsafe fn node_weight_unchecked_mut(
        &'a mut self,
        node_index: <Self as GraphBasics<'a>>::NodeIndex,
    ) -> &'a mut N {
        unsafe { (**self).node_weight_unchecked_mut(node_index) }
    }

    unsafe fn edge_weight_unchecked_mut(
        &'a mut self,
        edge_index: <Self as GraphBasics<'a>>::EdgeIndex,
    ) -> &'a mut E {
        unsafe { (**self).edge_weight_unchecked_mut(edge_index) }
    }

    fn edge_weight_copied(&'a self, edge_index: <Self as GraphBasics<'a>>::EdgeIndex) -> Option<E>
    where
        E: Copy,
    {
        (**self).edge_weight_copied(edge_index)
    }

    fn node_weight_copied(&'a self, node_index: <Self as GraphBasics<'a>>::NodeIndex) -> Option<N>
    where
        N: Copy,
    {
        (**self).node_weight_copied(node_index)
    }

    unsafe fn edge_weight_copied_unchecked(
        &'a self,
        edge_index: <Self as GraphBasics<'a>>::EdgeIndex,
    ) -> E
    where
        E: Copy,
    {
        unsafe { (**self).edge_weight_copied_unchecked(edge_index) }
    }

    unsafe fn node_weight_copied_unchecked(
        &'a self,
        node_index: <Self as GraphBasics<'a>>::NodeIndex,
    ) -> N
    where
        N: Copy,
    {
        unsafe { (**self).node_weight_copied_unchecked(node_index) }
    }

    fn node_weights(&'a self) -> impl Iterator<Item = &'a N> + 'a {
        (**self).node_weights()
    }

    fn edge_weights(&'a self) -> impl Iterator<Item = &'a E> + 'a {
        (**self).edge_weights()
    }
}

#[cfg(feature = "rayon")]
pub trait ParallelWeights<'a, N: 'a, E: 'a>: GraphBasics<'a> + Weights<'a, N, E> {
    fn par_node_weights(&'a self) -> impl ParallelIterator<Item = &'a N>;
    fn par_edge_weights(&'a self) -> impl ParallelIterator<Item = &'a E>;
}

#[cfg(feature = "rayon")]
impl<'a, N, E, G> ParallelWeights<'a, N, E> for G
where
    G: GraphBasics<'a> + Weights<'a, N, E> + Sync,
    N: 'a + Send + Sync,
    E: 'a + Send + Sync,
{
    fn par_node_weights(&'a self) -> impl ParallelIterator<Item = &'a N> {
        (0..self.node_count())
            .into_par_iter()
            .map(|x| unsafe { self.node_weight_unchecked(x.into()) })
    }

    fn par_edge_weights(&'a self) -> impl ParallelIterator<Item = &'a E> {
        (0..self.edge_count())
            .into_par_iter()
            .map(|x| unsafe { self.edge_weight_unchecked(x.into()) })
    }
}