Make Table<T> implement the IntoIterator trait

Author: Keavon

editor/src/messages/portfolio/spreadsheet/spreadsheet_message_handler.rs

@@ -288,7 +288,7 @@ impl<T: TableRowLayout> TableRowLayout for Table<T> {
 		}
 
 		let mut rows = self
-			.iter_ref()
+			.iter()
 			.enumerate()
 			.map(|(index, row)| {
 				let (scale, angle, translation) = row.transform.to_scale_angle_translation();

editor/src/node_graph_executor/runtime.rs

@@ -316,7 +316,7 @@ impl NodeRuntime {
 			} else if let Some(record) = introspected_data.downcast_ref::<IORecord<Context, Table<Vector>>>() {
 				let default = TableRow::default();
 				self.vector_modify
-					.insert(parent_network_node_id, record.output.iter_ref().next().unwrap_or_else(|| default.as_ref()).element.clone());
+					.insert(parent_network_node_id, record.output.iter().next().unwrap_or_else(|| default.as_ref()).element.clone());
 			} else {
 				log::warn!("Failed to downcast monitor node output {parent_network_node_id:?}");
 			}

node-graph/gbrush/src/brush.rs

@@ -130,7 +130,7 @@ where
 pub async fn create_brush_texture(brush_style: &BrushStyle) -> Raster<CPU> {
 	let stamp = brush_stamp_generator(brush_style.diameter, brush_style.color, brush_style.hardness, brush_style.flow);
 	let transform = DAffine2::from_scale_angle_translation(DVec2::splat(brush_style.diameter), 0., -DVec2::splat(brush_style.diameter / 2.));
-	let blank_texture = empty_image((), transform, Color::TRANSPARENT).iter().next().unwrap_or_default();
+	let blank_texture = empty_image((), transform, Color::TRANSPARENT).into_iter().next().unwrap_or_default();
 	let image = blend_stamp_closure(stamp, blank_texture, |a, b| blend_colors(a, b, BlendMode::Normal, 1.));
 
 	image.element
@@ -184,7 +184,7 @@ async fn brush(_: impl Ctx, mut image_frame_table: Table<Raster<CPU>>, strokes:
 		image_frame_table.push(TableRow::default());
 	}
 	// TODO: Find a way to handle more than one row
-	let table_row = image_frame_table.iter_ref().next().expect("Expected the one row we just pushed").into_cloned();
+	let table_row = image_frame_table.iter().next().expect("Expected the one row we just pushed").into_cloned();
 
 	let [start, end] = Table::new_from_row(table_row.clone()).bounding_box(DAffine2::IDENTITY, false).unwrap_or([DVec2::ZERO, DVec2::ZERO]);
 	let image_bbox = AxisAlignedBbox { start, end };
@@ -198,7 +198,7 @@ async fn brush(_: impl Ctx, mut image_frame_table: Table<Raster<CPU>>, strokes:
 	let mut brush_plan = cache.compute_brush_plan(table_row, &draw_strokes);
 
 	// TODO: Find a way to handle more than one row
-	let Some(mut actual_image) = extend_image_to_bounds((), Table::new_from_row(brush_plan.background), background_bounds).iter().next() else {
+	let Some(mut actual_image) = extend_image_to_bounds((), Table::new_from_row(brush_plan.background), background_bounds).into_iter().next() else {
 		return Table::new();
 	};
 
@@ -246,7 +246,7 @@ async fn brush(_: impl Ctx, mut image_frame_table: Table<Raster<CPU>>, strokes:
 
 			let table = blit_node.eval(blit_target).await;
 			assert_eq!(table.len(), 1);
-			table.iter().next().unwrap_or_default()
+			table.into_iter().next().unwrap_or_default()
 		};
 
 		// Cache image before doing final blend, and store final stroke texture.
@@ -285,7 +285,7 @@ async fn brush(_: impl Ctx, mut image_frame_table: Table<Raster<CPU>>, strokes:
 						FutureWrapperNode::new(ClonedNode::new(positions)),
 						FutureWrapperNode::new(ClonedNode::new(blend_params)),
 					);
-					erase_restore_mask = blit_node.eval(Table::new_from_row(erase_restore_mask)).await.iter().next().unwrap_or_default();
+					erase_restore_mask = blit_node.eval(Table::new_from_row(erase_restore_mask)).await.into_iter().next().unwrap_or_default();
 				}
 				// Yes, this is essentially the same as the above, but we duplicate to inline the blend mode.
 				BlendMode::Restore => {
@@ -295,7 +295,7 @@ async fn brush(_: impl Ctx, mut image_frame_table: Table<Raster<CPU>>, strokes:
 						FutureWrapperNode::new(ClonedNode::new(positions)),
 						FutureWrapperNode::new(ClonedNode::new(blend_params)),
 					);
-					erase_restore_mask = blit_node.eval(Table::new_from_row(erase_restore_mask)).await.iter().next().unwrap_or_default();
+					erase_restore_mask = blit_node.eval(Table::new_from_row(erase_restore_mask)).await.into_iter().next().unwrap_or_default();
 				}
 				_ => unreachable!(),
 			}
@@ -406,6 +406,6 @@ mod test {
 			BrushCache::default(),
 		)
 		.await;
-		assert_eq!(image.iter_ref().next().unwrap().element.width, 20);
+		assert_eq!(image.iter().next().unwrap().element.width, 20);
 	}
 }

node-graph/gcore/src/artboard.rs

@@ -90,7 +90,7 @@ pub fn migrate_artboard_group<'de, D: serde::Deserializer<'de>>(deserializer: D)
 
 impl BoundingBox for Table<Artboard> {
 	fn bounding_box(&self, transform: DAffine2, include_stroke: bool) -> Option<[DVec2; 2]> {
-		self.iter_ref().filter_map(|row| row.element.bounding_box(transform, include_stroke)).reduce(Quad::combine_bounds)
+		self.iter().filter_map(|row| row.element.bounding_box(transform, include_stroke)).reduce(Quad::combine_bounds)
 	}
 }
 

node-graph/gcore/src/graphic.rs

@@ -155,16 +155,16 @@ impl Graphic {
 
 	pub fn had_clip_enabled(&self) -> bool {
 		match self {
-			Graphic::Vector(vector) => vector.iter_ref().all(|row| row.alpha_blending.clip),
-			Graphic::Group(group) => group.iter_ref().all(|row| row.alpha_blending.clip),
-			Graphic::RasterCPU(raster) => raster.iter_ref().all(|row| row.alpha_blending.clip),
-			Graphic::RasterGPU(raster) => raster.iter_ref().all(|row| row.alpha_blending.clip),
+			Graphic::Vector(vector) => vector.iter().all(|row| row.alpha_blending.clip),
+			Graphic::Group(group) => group.iter().all(|row| row.alpha_blending.clip),
+			Graphic::RasterCPU(raster) => raster.iter().all(|row| row.alpha_blending.clip),
+			Graphic::RasterGPU(raster) => raster.iter().all(|row| row.alpha_blending.clip),
 		}
 	}
 
 	pub fn can_reduce_to_clip_path(&self) -> bool {
 		match self {
-			Graphic::Vector(vector) => vector.iter_ref().all(|row| {
+			Graphic::Vector(vector) => vector.iter().all(|row| {
 				let style = &row.element.style;
 				let alpha_blending = &row.alpha_blending;
 				(alpha_blending.opacity > 1. - f32::EPSILON) && style.fill().is_opaque() && style.stroke().is_none_or(|stroke| !stroke.has_renderable_stroke())
@@ -187,7 +187,7 @@ impl BoundingBox for Graphic {
 
 impl BoundingBox for Table<Graphic> {
 	fn bounding_box(&self, transform: DAffine2, include_stroke: bool) -> Option<[DVec2; 2]> {
-		self.iter_ref()
+		self.iter()
 			.filter_map(|element| element.element.bounding_box(transform * *element.transform, include_stroke))
 			.reduce(Quad::combine_bounds)
 	}
@@ -246,7 +246,7 @@ async fn to_group<Data: Into<Table<Graphic>> + 'n>(
 async fn flatten_group(_: impl Ctx, group: Table<Graphic>, fully_flatten: bool) -> Table<Graphic> {
 	// TODO: Avoid mutable reference, instead return a new Table<Graphic>?
 	fn flatten_group(output_group_table: &mut Table<Graphic>, current_group_table: Table<Graphic>, fully_flatten: bool, recursion_depth: usize) {
-		for current_row in current_group_table.iter_ref() {
+		for current_row in current_group_table.iter() {
 			let current_element = current_row.element.clone();
 			let reference = *current_row.source_node_id;
 
@@ -285,7 +285,7 @@ async fn flatten_group(_: impl Ctx, group: Table<Graphic>, fully_flatten: bool)
 async fn flatten_vector(_: impl Ctx, group: Table<Graphic>) -> Table<Vector> {
 	// TODO: Avoid mutable reference, instead return a new Table<Graphic>?
 	fn flatten_group(output_group_table: &mut Table<Vector>, current_group_table: Table<Graphic>) {
-		for current_graphic_row in current_group_table.iter_ref() {
+		for current_graphic_row in current_group_table.iter() {
 			let current_graphic = current_graphic_row.element.clone();
 			let source_node_id = *current_graphic_row.source_node_id;
 
@@ -301,7 +301,7 @@ async fn flatten_vector(_: impl Ctx, group: Table<Graphic>) -> Table<Vector> {
 				}
 				// Handle any leaf elements we encounter, which can be either non-group elements or groups that we don't want to flatten
 				Graphic::Vector(vector_table) => {
-					for current_vector_row in vector_table.iter_ref() {
+					for current_vector_row in vector_table.iter() {
 						output_group_table.push(TableRow {
 							element: current_vector_row.element.clone(),
 							transform: *current_graphic_row.transform * *current_vector_row.transform,
@@ -367,7 +367,7 @@ impl<T: Clone> AtIndex for Table<T> {
 
 	fn at_index(&self, index: usize) -> Option<Self::Output> {
 		let mut result_table = Self::default();
-		if let Some(row) = self.iter_ref().nth(index) {
+		if let Some(row) = self.iter().nth(index) {
 			result_table.push(row.into_cloned());
 			Some(result_table)
 		} else {
@@ -415,7 +415,7 @@ pub fn migrate_group<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Resul
 			// Try to deserialize as either table format
 			if let Ok(old_table) = serde_json::from_value::<Table<GraphicGroup>>(value.clone()) {
 				let mut group_table = Table::new();
-				for row in old_table.iter_ref() {
+				for row in old_table.iter() {
 					for (graphic, source_node_id) in &row.element.elements {
 						group_table.push(TableRow {
 							element: graphic.clone(),

node-graph/gcore/src/raster/image.rs

@@ -256,7 +256,7 @@ pub fn migrate_image_frame<'de, D: serde::Deserializer<'de>>(deserializer: D) ->
 		fn from(element: GraphicElement) -> Self {
 			match element {
 				GraphicElement::RasterFrame(RasterFrame::ImageFrame(image)) => Self {
-					image: image.iter_ref().next().unwrap().element.clone(),
+					image: image.iter().next().unwrap().element.clone(),
 				},
 				_ => panic!("Expected Image, found {:?}", element),
 			}
@@ -298,14 +298,14 @@ pub fn migrate_image_frame<'de, D: serde::Deserializer<'de>>(deserializer: D) ->
 		}
 		FormatVersions::ImageFrameTable(image_frame) => Table::new_from_element(Raster::new_cpu(
 			image_frame
-				.iter_ref()
+				.iter()
 				.next()
-				.unwrap_or(Table::new_from_element(ImageFrame::default()).iter_ref().next().unwrap())
+				.unwrap_or(Table::new_from_element(ImageFrame::default()).iter().next().unwrap())
 				.element
 				.image
 				.clone(),
 		)),
-		FormatVersions::ImageTable(table) => Table::new_from_element(Raster::new_cpu(table.iter_ref().next().unwrap().element.clone())),
+		FormatVersions::ImageTable(table) => Table::new_from_element(Raster::new_cpu(table.iter().next().unwrap().element.clone())),
 		FormatVersions::RasterTable(table) => table,
 	})
 }
@@ -354,7 +354,7 @@ pub fn migrate_image_frame_row<'de, D: serde::Deserializer<'de>>(deserializer: D
 		fn from(element: GraphicElement) -> Self {
 			match element {
 				GraphicElement::RasterFrame(RasterFrame::ImageFrame(image)) => Self {
-					image: image.iter_ref().next().unwrap().element.clone(),
+					image: image.iter().next().unwrap().element.clone(),
 				},
 				_ => panic!("Expected Image, found {:?}", element),
 			}
@@ -398,10 +398,10 @@ pub fn migrate_image_frame_row<'de, D: serde::Deserializer<'de>>(deserializer: D
 			source_node_id: None,
 		},
 		FormatVersions::ImageFrameTable(image_frame) => TableRow {
-			element: Raster::new_cpu(image_frame.iter_ref().next().unwrap().element.image.clone()),
+			element: Raster::new_cpu(image_frame.iter().next().unwrap().element.image.clone()),
 			..Default::default()
 		},
-		FormatVersions::RasterTable(image_frame_table) => image_frame_table.iter().next().unwrap_or_default(),
+		FormatVersions::RasterTable(image_frame_table) => image_frame_table.into_iter().next().unwrap_or_default(),
 		FormatVersions::RasterTableRow(image_table_row) => image_table_row,
 	})
 }

node-graph/gcore/src/raster_types.rs

@@ -204,7 +204,7 @@ where
 	Raster<T>: Storage,
 {
 	fn bounding_box(&self, transform: DAffine2, _include_stroke: bool) -> Option<[DVec2; 2]> {
-		self.iter_ref()
+		self.iter()
 			.filter(|row| !row.element.is_empty()) // Eliminate empty images
 			.flat_map(|row| {
 				let transform = transform * *row.transform;

node-graph/gcore/src/render_complexity.rs

@@ -12,7 +12,7 @@ pub trait RenderComplexity {
 
 impl<T: RenderComplexity> RenderComplexity for Table<T> {
 	fn render_complexity(&self) -> usize {
-		self.iter_ref().map(|row| row.element.render_complexity()).fold(0, usize::saturating_add)
+		self.iter().map(|row| row.element.render_complexity()).fold(0, usize::saturating_add)
 	}
 }
 

node-graph/gcore/src/table.rs

@@ -60,21 +60,42 @@ impl<T> Table<T> {
 		self.source_node_id.extend(table.source_node_id);
 	}
 
-	pub fn iter(self) -> impl DoubleEndedIterator<Item = TableRow<T>> {
-		self.element
-			.into_iter()
-			.zip(self.transform)
-			.zip(self.alpha_blending)
-			.zip(self.source_node_id)
-			.map(|(((element, transform), alpha_blending), source_node_id)| TableRow {
-				element,
-				transform,
-				alpha_blending,
-				source_node_id,
-			})
+	pub fn get(&self, index: usize) -> Option<TableRowRef<'_, T>> {
+		if index >= self.element.len() {
+			return None;
+		}
+
+		Some(TableRowRef {
+			element: &self.element[index],
+			transform: &self.transform[index],
+			alpha_blending: &self.alpha_blending[index],
+			source_node_id: &self.source_node_id[index],
+		})
+	}
+
+	pub fn get_mut(&mut self, index: usize) -> Option<TableRowMut<'_, T>> {
+		if index >= self.element.len() {
+			return None;
+		}
+
+		Some(TableRowMut {
+			element: &mut self.element[index],
+			transform: &mut self.transform[index],
+			alpha_blending: &mut self.alpha_blending[index],
+			source_node_id: &mut self.source_node_id[index],
+		})
+	}
+
+	pub fn len(&self) -> usize {
+		self.element.len()
+	}
+
+	pub fn is_empty(&self) -> bool {
+		self.element.is_empty()
 	}
 
-	pub fn iter_ref(&self) -> impl DoubleEndedIterator<Item = TableRowRef<'_, T>> + Clone {
+	/// Borrows a [`Table`] and returns an iterator of [`TableRowRef`]s, each containing references to the data of the respective row from the table.
+	pub fn iter(&self) -> impl DoubleEndedIterator<Item = TableRowRef<'_, T>> + Clone {
 		self.element
 			.iter()
 			.zip(self.transform.iter())
@@ -88,6 +109,7 @@ impl<T> Table<T> {
 			})
 	}
 
+	/// Mutably borrows a [`Table`] and returns an iterator of [`TableRowMut`]s, each containing mutable references to the data of the respective row from the table.
 	pub fn iter_mut(&mut self) -> impl DoubleEndedIterator<Item = TableRowMut<'_, T>> {
 		self.element
 			.iter_mut()
@@ -101,39 +123,44 @@ impl<T> Table<T> {
 				source_node_id,
 			})
 	}
+}
 
-	pub fn get(&self, index: usize) -> Option<TableRowRef<'_, T>> {
-		if index >= self.element.len() {
-			return None;
-		}
-
-		Some(TableRowRef {
-			element: &self.element[index],
-			transform: &self.transform[index],
-			alpha_blending: &self.alpha_blending[index],
-			source_node_id: &self.source_node_id[index],
-		})
-	}
+impl<T> IntoIterator for Table<T> {
+	type Item = TableRow<T>;
+	type IntoIter = TableRowIter<T>;
 
-	pub fn get_mut(&mut self, index: usize) -> Option<TableRowMut<'_, T>> {
-		if index >= self.element.len() {
-			return None;
+	/// Consumes a [`Table`] and returns an iterator of [`TableRow`]s, each containing the owned data of the respective row from the original table.
+	fn into_iter(self) -> Self::IntoIter {
+		TableRowIter {
+			element: self.element.into_iter(),
+			transform: self.transform.into_iter(),
+			alpha_blending: self.alpha_blending.into_iter(),
+			source_node_id: self.source_node_id.into_iter(),
 		}
-
-		Some(TableRowMut {
-			element: &mut self.element[index],
-			transform: &mut self.transform[index],
-			alpha_blending: &mut self.alpha_blending[index],
-			source_node_id: &mut self.source_node_id[index],
-		})
 	}
+}
 
-	pub fn len(&self) -> usize {
-		self.element.len()
-	}
+pub struct TableRowIter<T> {
+	element: std::vec::IntoIter<T>,
+	transform: std::vec::IntoIter<DAffine2>,
+	alpha_blending: std::vec::IntoIter<AlphaBlending>,
+	source_node_id: std::vec::IntoIter<Option<NodeId>>,
+}
+impl<T> Iterator for TableRowIter<T> {
+	type Item = TableRow<T>;
 
-	pub fn is_empty(&self) -> bool {
-		self.element.is_empty()
+	fn next(&mut self) -> Option<Self::Item> {
+		let element = self.element.next()?;
+		let transform = self.transform.next()?;
+		let alpha_blending = self.alpha_blending.next()?;
+		let source_node_id = self.source_node_id.next()?;
+
+		Some(TableRow {
+			element,
+			transform,
+			alpha_blending,
+			source_node_id,
+		})
 	}
 }
 

node-graph/gcore/src/transform_nodes.rs

@@ -63,7 +63,7 @@ async fn extract_transform<T>(
 	)]
 	vector: Table<T>,
 ) -> DAffine2 {
-	vector.iter_ref().next().map(|row| *row.transform).unwrap_or_default()
+	vector.iter().next().map(|row| *row.transform).unwrap_or_default()
 }
 
 #[node_macro::node(category("Math: Transform"))]