impl Ord for Path {
    fn cmp(&self, other: &Self) -> Ordering {
        // Paths from the same source are considered equal for set membership.
        // This enables BTreeSet::replace() to update paths from the same source.
        //
        // BGP paths: identified by peer IP
        if let (Some(a), Some(b)) = (&self.bgp, &other.bgp)
            && a.peer == b.peer
        {
            return Ordering::Equal;
        }

        // Static paths: identified by (nexthop, nexthop_interface, vlan_id)
        if self.bgp.is_none()
            && other.bgp.is_none()
            && self.nexthop == other.nexthop
            && self.nexthop_interface == other.nexthop_interface
            && self.vlan_id == other.vlan_id
        {
            return Ordering::Equal;
        }
        if self.nexthop != other.nexthop {
            return self.nexthop.cmp(&other.nexthop);
        }
        if self.shutdown != other.shutdown {
            return self.shutdown.cmp(&other.shutdown);
        }
        if self.rib_priority != other.rib_priority {
            return self.rib_priority.cmp(&other.rib_priority);
        }
        self.bgp.cmp(&other.bgp)
    }
}

impl PartialOrd for BgpPathProperties {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}
impl Ord for BgpPathProperties {
    fn cmp(&self, other: &Self) -> Ordering {
        if self.origin_as != other.origin_as {
            return self.origin_as.cmp(&other.origin_as);
        }
        if self.id != other.id {
            return self.id.cmp(&other.id);
        }
        // MED should *not* be used as a basis for comparison. Paths with
        // distinct MED values are not distinct paths.
        if self.as_path != other.as_path {
            return self.as_path.cmp(&other.as_path);
        }
        self.stale.cmp(&other.stale)
    }
}