pub(crate) fn is_non_redundant_next(&self, node: NodeId, previous: &NodeIdSet) -> bool {
        if let Some(symmetric_nodes) = self.0.get(&node) {
            symmetric_nodes
                .difference(previous)
                .next()
                .map(|expected_next| expected_next == node)
                .unwrap_or(false)
        } else {
            true
        }
    }
/// If we add nodes to a candidate set one by one, this function helps us ensure that only one
/// ordering of a group of symmetric nodes is allowed, which helps us to avoid redundant
/// branches in a few algorithms.
If we add nodes to a candidate set one by one, this function helps us ensure that only one
ordering of a group of symmetric nodes is allowed, which helps us to avoid redundant
branches in a few algorithms.
If we add nodes to a candidate set one by one this function helps us ensure that only one ordering of a group of symmetric nodes is allowed which helps us to avoid redundant branches in a few algorithms .
pub(crate) fn is_non_redundant_next(&self, node: NodeId, previous: &NodeIdSet) -> bool {
        if let Some(symmetric_nodes) = self.0.get(&node) {
            symmetric_nodes
                .difference(previous)
                .next()
                .map(|expected_next| expected_next == node)
                .unwrap_or(false)
        } else {
            true
        }
    }
pub ( crate ) fn is_non_redundant_next ( & self , node : NodeId , previous : & NodeIdSet ) -> bool { if let Some ( symmetric_nodes ) = self . 0 . get ( & node ) { symmetric_nodes . difference ( previous ) . next ( ) . map ( | expected_next | expected_next == node ) . unwrap_or ( false ) } else { true } }
If we add nodes to a candidate set one by one, this function helps us ensure that only one
ordering of a group of symmetric nodes is allowed, which helps us to avoid redundant
branches in a few algorithms.
If we add nodes to a candidate set one by one this function helps us ensure that only one ordering of a group of symmetric nodes is allowed which helps us to avoid redundant branches in a few algorithms .
&self
node
NodeId
previous
&NodeIdSet
&self
node
NodeId
previous
&NodeIdSet