How to avoid simultaneous mutable and immutable borrowing in Rust? - rust

Question

I`m writing a function which iterates over all edges of a mesh and splits long ones. But getting a compilation error while trying to borrow a mesh struct as mutable and immutable simultaneously. Does anyone have an idea how to avoid mutable and immutable borrowing at the same time here?
fn split_edges(&self, mesh: &'a mut TMesh, max_edge_length: TMesh::ScalarType) {
let edges: Vec<TMesh::EdgeDescriptor> = mesh.edges().collect();
for edge in edges {
let edge_length = mesh.edge_length(edge);
// Split long edges at the middle
if edge_length > max_edge_length {
let (v1, v2) = mesh.edge_positions(edge);
let split_at = v1 + (v2 - v1).scale(cast(0.5).unwrap());
mesh.split_edge(edge, &split_at);
}
}
}
Compilation error:
error[E0502]: cannot borrow `*mesh` as mutable because it is also borrowed as immutable
--> src\remeshing\incremental.rs:48:17
|
12 | impl<'a, TMesh: EditableMesh<'a>> IncrementalRemesher<'a, TMesh> {
| -- lifetime `'a` defined here
...
39 | let edges: Vec<TMesh::EdgeDescriptor> = mesh.edges().collect();
| ------------
| |
| immutable borrow occurs here
| argument requires that `*mesh` is borrowed for `'a`
...
48 | mesh.split_edge(edge, &split_at);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable borrow occurs here
Traits:
pub trait Mesh<'a> {
type ScalarType: Floating;
type EdgeDescriptor: Clone + Copy;
type VertexDescriptor: Clone + Copy;
type FaceDescriptor: Clone + Copy;
type FacesIter: Iterator<Item = Self::FaceDescriptor>;
type VerticesIter: Iterator<Item = Self::VertexDescriptor>;
type EdgesIter: Iterator<Item = Self::EdgeDescriptor>;
/// Creates mesh from vertices and face indices
fn from_vertices_and_indices(vertices: &Vec<Point3<Self::ScalarType>>, faces: &Vec<usize>) -> Self;
/// Iterator over mesh faces
fn faces(&'a self) -> Self::FacesIter;
/// Iterator over mesh vertices
fn vertices(&'a self) -> Self::VerticesIter;
/// Iterator over mesh edges
fn edges(&'a self) -> Self::EdgesIter;
/// Returns positions of face vertices in ccw order
fn face_positions(&self, face: Self::FaceDescriptor) -> (Point3<Self::ScalarType>, Point3<Self::ScalarType>, Point3<Self::ScalarType>);
/// Returns face normal
fn face_normal(&self, face: Self::FaceDescriptor) -> UnitVector3<Self::ScalarType>;
/// Returns edge length
fn edge_positions(&self, edge: Self::EdgeDescriptor) -> (Point3<Self::ScalarType>, Point3<Self::ScalarType>);
/// Returns edge length
fn edge_length(&self, edge: Self::EdgeDescriptor) -> Self::ScalarType;
}
///
/// Triangular mesh that supports editing operations
///
pub trait EditableMesh<'a>: Mesh<'a> {
fn collapse_edge(&mut self, edge: Self::EdgeDescriptor);
fn is_edge_collapse_safe(&mut self, edge: Self::EdgeDescriptor) -> bool;
fn flip_edge(&mut self, edge: Self::EdgeDescriptor);
fn is_edge_flip_safe(&mut self, edge: Self::EdgeDescriptor) -> bool;
fn split_edge(&mut self, edge: Self::EdgeDescriptor, at: &Point3<Self::ScalarType>);
fn shift_vertex(&mut self, vertex: Self::VertexDescriptor, to: &Point3<Self::ScalarType>);
}

Answer 1

As #isactfa stated in the comment I had to change the iterator lifetime to lifetime of borrow.
type FacesIter<'iter>: Iterator<Item = Self::FaceDescriptor> where Self: 'iter;
type VerticesIter<'iter>: Iterator<Item = Self::VertexDescriptor> where Self: 'iter;
type EdgesIter<'iter>: Iterator<Item = Self::EdgeDescriptor> where Self: 'iter;
/// Iterator over mesh faces
fn faces<'a>(&'a self) -> Self::FacesIter<'a>;
/// Iterator over mesh vertices
fn vertices<'a>(&'a self) -> Self::VerticesIter<'a>;
/// Iterator over mesh edges
fn edges<'a>(&'a self) -> Self::EdgesIter<'a>;