From c9b193a4f2dd9346c427502944e5395fb464b4f9 Mon Sep 17 00:00:00 2001
From: Nico Burns <nico@nicoburns.com>
Date: Sat, 15 Feb 2025 12:17:58 +1300
Subject: [PATCH 1/5] Implement MallocSizeOf trait for euclid type

Signed-off-by: Nico Burns <nico@nicoburns.com>
---
 Cargo.toml          |  2 ++
 src/angle.rs        |  9 +++++++++
 src/box2d.rs        |  9 +++++++++
 src/box3d.rs        |  9 +++++++++
 src/homogen.rs      |  9 +++++++++
 src/length.rs       |  9 +++++++++
 src/point.rs        | 16 ++++++++++++++++
 src/rect.rs         |  9 +++++++++
 src/rigid.rs        |  9 +++++++++
 src/rotation.rs     | 16 ++++++++++++++++
 src/scale.rs        |  9 +++++++++
 src/side_offsets.rs | 12 ++++++++++++
 src/size.rs         | 16 ++++++++++++++++
 src/transform2d.rs  | 14 ++++++++++++++
 src/transform3d.rs  | 24 ++++++++++++++++++++++++
 src/translation.rs  | 16 ++++++++++++++++
 src/vector.rs       | 16 ++++++++++++++++
 17 files changed, 204 insertions(+)

diff --git a/Cargo.toml b/Cargo.toml
index 56701e2..486d356 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -16,10 +16,12 @@ default = ["std"]
 unstable = []
 std = ["num-traits/std"]
 libm = ["num-traits/libm"]
+malloc_size_of = ["dep:malloc_size_of"]
 
 [dependencies]
 num-traits = { version = "0.2.15", default-features = false }
 serde = { version = "1.0", default-features = false, features = ["serde_derive"], optional = true }
+malloc_size_of = { version = "0.1", default-features = false, optional = true }
 mint = { version = "0.5.1", optional = true }
 arbitrary = { version = "1", optional = true }
 bytemuck = { version = "1.9", optional = true }
diff --git a/src/angle.rs b/src/angle.rs
index 00964dc..81c43d1 100644
--- a/src/angle.rs
+++ b/src/angle.rs
@@ -17,6 +17,8 @@ use core::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Rem, Sub, S
 
 #[cfg(feature = "bytemuck")]
 use bytemuck::{Pod, Zeroable};
+#[cfg(feature = "malloc_size_of")]
+use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
 use num_traits::real::Real;
 use num_traits::{Float, FloatConst, NumCast, One, Zero};
 #[cfg(feature = "serde")]
@@ -52,6 +54,13 @@ where
     }
 }
 
+#[cfg(feature = "malloc_size_of")]
+impl<T: MallocSizeOf> MallocSizeOf for Angle<T> {
+    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+        self.radians.size_of(ops)
+    }
+}
+
 impl<T> Angle<T> {
     #[inline]
     pub fn radians(radians: T) -> Self {
diff --git a/src/box2d.rs b/src/box2d.rs
index f930b08..685f6aa 100644
--- a/src/box2d.rs
+++ b/src/box2d.rs
@@ -19,6 +19,8 @@ use crate::vector::{vec2, Vector2D};
 
 #[cfg(feature = "bytemuck")]
 use bytemuck::{Pod, Zeroable};
+#[cfg(feature = "malloc_size_of")]
+use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
 use num_traits::{Float, NumCast};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -151,6 +153,13 @@ impl<T, U> Box2D<T, U> {
     }
 }
 
+#[cfg(feature = "malloc_size_of")]
+impl<T: MallocSizeOf, U> MallocSizeOf for Box2D<T, U> {
+    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+        self.min.size_of(ops) + self.max.size_of(ops)
+    }
+}
+
 impl<T, U> Box2D<T, U>
 where
     T: PartialOrd,
diff --git a/src/box3d.rs b/src/box3d.rs
index eb43556..fbdcb1b 100644
--- a/src/box3d.rs
+++ b/src/box3d.rs
@@ -17,6 +17,8 @@ use crate::vector::Vector3D;
 
 #[cfg(feature = "bytemuck")]
 use bytemuck::{Pod, Zeroable};
+#[cfg(feature = "malloc_size_of")]
+use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
 use num_traits::{Float, NumCast};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -90,6 +92,13 @@ unsafe impl<T: Zeroable, U> Zeroable for Box3D<T, U> {}
 #[cfg(feature = "bytemuck")]
 unsafe impl<T: Pod, U: 'static> Pod for Box3D<T, U> {}
 
+#[cfg(feature = "malloc_size_of")]
+impl<T: MallocSizeOf, U> MallocSizeOf for Box3D<T, U> {
+    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+        self.min.size_of(ops) + self.max.size_of(ops)
+    }
+}
+
 impl<T, U> Box3D<T, U> {
     /// Constructor.
     #[inline]
diff --git a/src/homogen.rs b/src/homogen.rs
index 19b6074..0033bfb 100644
--- a/src/homogen.rs
+++ b/src/homogen.rs
@@ -19,6 +19,8 @@ use core::fmt;
 use core::hash::Hash;
 use core::marker::PhantomData;
 use core::ops::Div;
+#[cfg(feature = "malloc_size_of")]
+use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
 #[cfg(feature = "serde")]
 use serde;
 
@@ -103,6 +105,13 @@ unsafe impl<T: Zeroable, U> Zeroable for HomogeneousVector<T, U> {}
 #[cfg(feature = "bytemuck")]
 unsafe impl<T: Pod, U: 'static> Pod for HomogeneousVector<T, U> {}
 
+#[cfg(feature = "malloc_size_of")]
+impl<T: MallocSizeOf, U> MallocSizeOf for HomogeneousVector<T, U> {
+    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+        self.x.size_of(ops) + self.y.size_of(ops) + self.z.size_of(ops) + self.w.size_of(ops)
+    }
+}
+
 impl<T, U> Eq for HomogeneousVector<T, U> where T: Eq {}
 
 impl<T, U> PartialEq for HomogeneousVector<T, U>
diff --git a/src/length.rs b/src/length.rs
index 840cb12..49e1a7f 100644
--- a/src/length.rs
+++ b/src/length.rs
@@ -23,6 +23,8 @@ use core::iter::Sum;
 use core::marker::PhantomData;
 use core::ops::{Add, Div, Mul, Neg, Sub};
 use core::ops::{AddAssign, DivAssign, MulAssign, SubAssign};
+#[cfg(feature = "malloc_size_of")]
+use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
 use num_traits::{NumCast, Saturating};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
@@ -91,6 +93,13 @@ unsafe impl<T: Zeroable, U> Zeroable for Length<T, U> {}
 #[cfg(feature = "bytemuck")]
 unsafe impl<T: Pod, U: 'static> Pod for Length<T, U> {}
 
+#[cfg(feature = "malloc_size_of")]
+impl<T: MallocSizeOf, U> MallocSizeOf for Length<T, U> {
+    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+        self.0.size_of(ops)
+    }
+}
+
 impl<T, U> Length<T, U> {
     /// Associate a value with a unit of measure.
     #[inline]
diff --git a/src/point.rs b/src/point.rs
index 277fc35..deb39c9 100644
--- a/src/point.rs
+++ b/src/point.rs
@@ -20,6 +20,8 @@ use core::fmt;
 use core::hash::Hash;
 use core::marker::PhantomData;
 use core::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
+#[cfg(feature = "malloc_size_of")]
+use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
 #[cfg(feature = "mint")]
 use mint;
 use num_traits::real::Real;
@@ -103,6 +105,13 @@ unsafe impl<T: Zeroable, U> Zeroable for Point2D<T, U> {}
 #[cfg(feature = "bytemuck")]
 unsafe impl<T: Pod, U: 'static> Pod for Point2D<T, U> {}
 
+#[cfg(feature = "malloc_size_of")]
+impl<T: MallocSizeOf, U> MallocSizeOf for Point2D<T, U> {
+    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+        self.x.size_of(ops) + self.y.size_of(ops)
+    }
+}
+
 impl<T, U> Eq for Point2D<T, U> where T: Eq {}
 
 impl<T, U> PartialEq for Point2D<T, U>
@@ -896,6 +905,13 @@ unsafe impl<T: Zeroable, U> Zeroable for Point3D<T, U> {}
 #[cfg(feature = "bytemuck")]
 unsafe impl<T: Pod, U: 'static> Pod for Point3D<T, U> {}
 
+#[cfg(feature = "malloc_size_of")]
+impl<T: MallocSizeOf, U> MallocSizeOf for Point3D<T, U> {
+    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+        self.x.size_of(ops) + self.y.size_of(ops) + self.z.size_of(ops)
+    }
+}
+
 impl<T, U> Eq for Point3D<T, U> where T: Eq {}
 
 impl<T, U> PartialEq for Point3D<T, U>
diff --git a/src/rect.rs b/src/rect.rs
index 1021044..1b870ba 100644
--- a/src/rect.rs
+++ b/src/rect.rs
@@ -18,6 +18,8 @@ use crate::vector::Vector2D;
 
 #[cfg(feature = "bytemuck")]
 use bytemuck::{Pod, Zeroable};
+#[cfg(feature = "malloc_size_of")]
+use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
 use num_traits::{Float, NumCast};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -79,6 +81,13 @@ impl<T: Hash, U> Hash for Rect<T, U> {
     }
 }
 
+#[cfg(feature = "malloc_size_of")]
+impl<T: MallocSizeOf, U> MallocSizeOf for Rect<T, U> {
+    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+        self.origin.size_of(ops) + self.size.size_of(ops)
+    }
+}
+
 impl<T: Copy, U> Copy for Rect<T, U> {}
 
 impl<T: Clone, U> Clone for Rect<T, U> {
diff --git a/src/rigid.rs b/src/rigid.rs
index 00fea7c..61b82d4 100644
--- a/src/rigid.rs
+++ b/src/rigid.rs
@@ -10,6 +10,8 @@ use core::{fmt, hash};
 
 #[cfg(feature = "bytemuck")]
 use bytemuck::{Pod, Zeroable};
+#[cfg(feature = "malloc_size_of")]
+use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
 use num_traits::real::Real;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -242,6 +244,13 @@ unsafe impl<T: Zeroable, Src, Dst> Zeroable for RigidTransform3D<T, Src, Dst> {}
 #[cfg(feature = "bytemuck")]
 unsafe impl<T: Pod, Src: 'static, Dst: 'static> Pod for RigidTransform3D<T, Src, Dst> {}
 
+#[cfg(feature = "malloc_size_of")]
+impl<T: MallocSizeOf, Src, Dst> MallocSizeOf for RigidTransform3D<T, Src, Dst> {
+    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+        self.rotation.size_of(ops) + self.translation.size_of(ops)
+    }
+}
+
 impl<T: Real + ApproxEq<T>, Src, Dst> From<Rotation3D<T, Src, Dst>>
     for RigidTransform3D<T, Src, Dst>
 {
diff --git a/src/rotation.rs b/src/rotation.rs
index dca6489..7103fd9 100644
--- a/src/rotation.rs
+++ b/src/rotation.rs
@@ -20,6 +20,8 @@ use core::ops::{Add, Mul, Neg, Sub};
 
 #[cfg(feature = "bytemuck")]
 use bytemuck::{Pod, Zeroable};
+#[cfg(feature = "malloc_size_of")]
+use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
 use num_traits::real::Real;
 use num_traits::{NumCast, One, Zero};
 #[cfg(feature = "serde")]
@@ -89,6 +91,13 @@ unsafe impl<T: Zeroable, Src, Dst> Zeroable for Rotation2D<T, Src, Dst> {}
 #[cfg(feature = "bytemuck")]
 unsafe impl<T: Pod, Src: 'static, Dst: 'static> Pod for Rotation2D<T, Src, Dst> {}
 
+#[cfg(feature = "malloc_size_of")]
+impl<T: MallocSizeOf, Src, Dst> MallocSizeOf for Rotation2D<T, Src, Dst> {
+    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+        self.angle.size_of(ops)
+    }
+}
+
 impl<T, Src, Dst> Rotation2D<T, Src, Dst> {
     /// Creates a rotation from an angle in radians.
     #[inline]
@@ -345,6 +354,13 @@ unsafe impl<T: Zeroable, Src, Dst> Zeroable for Rotation3D<T, Src, Dst> {}
 #[cfg(feature = "bytemuck")]
 unsafe impl<T: Pod, Src: 'static, Dst: 'static> Pod for Rotation3D<T, Src, Dst> {}
 
+#[cfg(feature = "malloc_size_of")]
+impl<T: MallocSizeOf, Src, Dst> MallocSizeOf for Rotation3D<T, Src, Dst> {
+    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+        self.i.size_of(ops) + self.j.size_of(ops) + self.k.size_of(ops) + self.r.size_of(ops)
+    }
+}
+
 impl<T, Src, Dst> Rotation3D<T, Src, Dst> {
     /// Creates a rotation around from a quaternion representation.
     ///
diff --git a/src/scale.rs b/src/scale.rs
index 0a4d2c0..983b366 100644
--- a/src/scale.rs
+++ b/src/scale.rs
@@ -21,6 +21,8 @@ use core::ops::{Add, Div, Mul, Sub};
 
 #[cfg(feature = "bytemuck")]
 use bytemuck::{Pod, Zeroable};
+#[cfg(feature = "malloc_size_of")]
+use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
 use num_traits::NumCast;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -340,6 +342,13 @@ unsafe impl<T: Zeroable, Src, Dst> Zeroable for Scale<T, Src, Dst> {}
 #[cfg(feature = "bytemuck")]
 unsafe impl<T: Pod, Src: 'static, Dst: 'static> Pod for Scale<T, Src, Dst> {}
 
+#[cfg(feature = "malloc_size_of")]
+impl<T: MallocSizeOf, Src, Dst> MallocSizeOf for Scale<T, Src, Dst> {
+    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+        self.0.size_of(ops)
+    }
+}
+
 // scale0 * scale1
 // (A,B) * (B,C) = (A,C)
 impl<T: Mul, A, B, C> Mul<Scale<T, B, C>> for Scale<T, A, B> {
diff --git a/src/side_offsets.rs b/src/side_offsets.rs
index 298441a..7f5e6fe 100644
--- a/src/side_offsets.rs
+++ b/src/side_offsets.rs
@@ -23,6 +23,8 @@ use core::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAss
 
 #[cfg(feature = "bytemuck")]
 use bytemuck::{Pod, Zeroable};
+#[cfg(feature = "malloc_size_of")]
+use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
@@ -66,6 +68,16 @@ unsafe impl<T: Zeroable, U> Zeroable for SideOffsets2D<T, U> {}
 #[cfg(feature = "bytemuck")]
 unsafe impl<T: Pod, U: 'static> Pod for SideOffsets2D<T, U> {}
 
+#[cfg(feature = "malloc_size_of")]
+impl<T: MallocSizeOf, U> MallocSizeOf for SideOffsets2D<T, U> {
+    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+        self.top.size_of(ops)
+            + self.right.size_of(ops)
+            + self.bottom.size_of(ops)
+            + self.left.size_of(ops)
+    }
+}
+
 impl<T: Copy, U> Copy for SideOffsets2D<T, U> {}
 
 impl<T: Clone, U> Clone for SideOffsets2D<T, U> {
diff --git a/src/size.rs b/src/size.rs
index 7670e88..6eb5618 100644
--- a/src/size.rs
+++ b/src/size.rs
@@ -24,6 +24,8 @@ use core::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAss
 
 #[cfg(feature = "bytemuck")]
 use bytemuck::{Pod, Zeroable};
+#[cfg(feature = "malloc_size_of")]
+use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
 #[cfg(feature = "mint")]
 use mint;
 use num_traits::{Float, NumCast, Signed};
@@ -107,6 +109,13 @@ unsafe impl<T: Zeroable, U> Zeroable for Size2D<T, U> {}
 #[cfg(feature = "bytemuck")]
 unsafe impl<T: Pod, U: 'static> Pod for Size2D<T, U> {}
 
+#[cfg(feature = "malloc_size_of")]
+impl<T: MallocSizeOf, U> MallocSizeOf for Size2D<T, U> {
+    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+        self.width.size_of(ops) + self.height.size_of(ops)
+    }
+}
+
 impl<T, U> Eq for Size2D<T, U> where T: Eq {}
 
 impl<T, U> PartialEq for Size2D<T, U>
@@ -1019,6 +1028,13 @@ unsafe impl<T: Zeroable, U> Zeroable for Size3D<T, U> {}
 #[cfg(feature = "bytemuck")]
 unsafe impl<T: Pod, U: 'static> Pod for Size3D<T, U> {}
 
+#[cfg(feature = "malloc_size_of")]
+impl<T: MallocSizeOf, U> MallocSizeOf for Size3D<T, U> {
+    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+        self.width.size_of(ops) + self.height.size_of(ops) + self.depth.size_of(ops)
+    }
+}
+
 impl<T, U> Eq for Size3D<T, U> where T: Eq {}
 
 impl<T, U> PartialEq for Size3D<T, U>
diff --git a/src/transform2d.rs b/src/transform2d.rs
index 8d23e99..38d3ba1 100644
--- a/src/transform2d.rs
+++ b/src/transform2d.rs
@@ -26,6 +26,8 @@ use core::ops::{Add, Div, Mul, Sub};
 
 #[cfg(feature = "bytemuck")]
 use bytemuck::{Pod, Zeroable};
+#[cfg(feature = "malloc_size_of")]
+use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
 #[cfg(feature = "mint")]
 use mint;
 use num_traits::NumCast;
@@ -98,6 +100,18 @@ unsafe impl<T: Zeroable, Src, Dst> Zeroable for Transform2D<T, Src, Dst> {}
 #[cfg(feature = "bytemuck")]
 unsafe impl<T: Pod, Src: 'static, Dst: 'static> Pod for Transform2D<T, Src, Dst> {}
 
+#[cfg(feature = "malloc_size_of")]
+impl<T: MallocSizeOf, Src, Dst> MallocSizeOf for Transform2D<T, Src, Dst> {
+    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+        self.m11.size_of(ops)
+            + self.m12.size_of(ops)
+            + self.m21.size_of(ops)
+            + self.m22.size_of(ops)
+            + self.m31.size_of(ops)
+            + self.m32.size_of(ops)
+    }
+}
+
 impl<T: Copy, Src, Dst> Copy for Transform2D<T, Src, Dst> {}
 
 impl<T: Clone, Src, Dst> Clone for Transform2D<T, Src, Dst> {
diff --git a/src/transform3d.rs b/src/transform3d.rs
index 52b1e32..a897c58 100644
--- a/src/transform3d.rs
+++ b/src/transform3d.rs
@@ -30,6 +30,8 @@ use core::ops::{Add, Div, Mul, Neg, Sub};
 
 #[cfg(feature = "bytemuck")]
 use bytemuck::{Pod, Zeroable};
+#[cfg(feature = "malloc_size_of")]
+use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
 #[cfg(feature = "mint")]
 use mint;
 use num_traits::NumCast;
@@ -114,6 +116,28 @@ unsafe impl<T: Zeroable, Src, Dst> Zeroable for Transform3D<T, Src, Dst> {}
 #[cfg(feature = "bytemuck")]
 unsafe impl<T: Pod, Src: 'static, Dst: 'static> Pod for Transform3D<T, Src, Dst> {}
 
+#[cfg(feature = "malloc_size_of")]
+impl<T: MallocSizeOf, Src, Dst> MallocSizeOf for Transform3D<T, Src, Dst> {
+    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+        self.m11.size_of(ops)
+            + self.m12.size_of(ops)
+            + self.m13.size_of(ops)
+            + self.m14.size_of(ops)
+            + self.m21.size_of(ops)
+            + self.m22.size_of(ops)
+            + self.m23.size_of(ops)
+            + self.m24.size_of(ops)
+            + self.m31.size_of(ops)
+            + self.m32.size_of(ops)
+            + self.m33.size_of(ops)
+            + self.m34.size_of(ops)
+            + self.m41.size_of(ops)
+            + self.m42.size_of(ops)
+            + self.m43.size_of(ops)
+            + self.m44.size_of(ops)
+    }
+}
+
 impl<T: Copy, Src, Dst> Copy for Transform3D<T, Src, Dst> {}
 
 impl<T: Clone, Src, Dst> Clone for Transform3D<T, Src, Dst> {
diff --git a/src/translation.rs b/src/translation.rs
index 6c915a4..662d9a4 100644
--- a/src/translation.rs
+++ b/src/translation.rs
@@ -20,6 +20,8 @@ use core::ops::{Add, AddAssign, Neg, Sub, SubAssign};
 
 #[cfg(feature = "bytemuck")]
 use bytemuck::{Pod, Zeroable};
+#[cfg(feature = "malloc_size_of")]
+use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
 use num_traits::NumCast;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -75,6 +77,13 @@ where
     }
 }
 
+#[cfg(feature = "malloc_size_of")]
+impl<T: MallocSizeOf, Src, Dst> MallocSizeOf for Translation2D<T, Src, Dst> {
+    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+        self.x.size_of(ops) + self.y.size_of(ops)
+    }
+}
+
 impl<T: Copy, Src, Dst> Copy for Translation2D<T, Src, Dst> {}
 
 impl<T: Clone, Src, Dst> Clone for Translation2D<T, Src, Dst> {
@@ -435,6 +444,13 @@ where
     }
 }
 
+#[cfg(feature = "malloc_size_of")]
+impl<T: MallocSizeOf, Src, Dst> MallocSizeOf for Translation3D<T, Src, Dst> {
+    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+        self.x.size_of(ops) + self.y.size_of(ops) + self.z.size_of(ops)
+    }
+}
+
 impl<T: Copy, Src, Dst> Copy for Translation3D<T, Src, Dst> {}
 
 impl<T: Clone, Src, Dst> Clone for Translation3D<T, Src, Dst> {
diff --git a/src/vector.rs b/src/vector.rs
index 4d832c1..7a009e7 100644
--- a/src/vector.rs
+++ b/src/vector.rs
@@ -25,6 +25,8 @@ use core::hash::Hash;
 use core::iter::Sum;
 use core::marker::PhantomData;
 use core::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
+#[cfg(feature = "malloc_size_of")]
+use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
 #[cfg(feature = "mint")]
 use mint;
 use num_traits::real::Real;
@@ -60,6 +62,13 @@ impl<T: Clone, U> Clone for Vector2D<T, U> {
     }
 }
 
+#[cfg(feature = "malloc_size_of")]
+impl<T: MallocSizeOf, U> MallocSizeOf for Vector2D<T, U> {
+    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+        self.x.size_of(ops) + self.y.size_of(ops)
+    }
+}
+
 #[cfg(feature = "serde")]
 impl<'de, T, U> serde::Deserialize<'de> for Vector2D<T, U>
 where
@@ -1032,6 +1041,13 @@ unsafe impl<T: Zeroable, U> Zeroable for Vector3D<T, U> {}
 #[cfg(feature = "bytemuck")]
 unsafe impl<T: Pod, U: 'static> Pod for Vector3D<T, U> {}
 
+#[cfg(feature = "malloc_size_of")]
+impl<T: MallocSizeOf, U> MallocSizeOf for Vector3D<T, U> {
+    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
+        self.x.size_of(ops) + self.y.size_of(ops) + self.z.size_of(ops)
+    }
+}
+
 impl<T: Eq, U> Eq for Vector3D<T, U> {}
 
 impl<T: PartialEq, U> PartialEq for Vector3D<T, U> {

From efc3a12ed8a6483ae3c7c23633a559526536156f Mon Sep 17 00:00:00 2001
From: Nico Burns <nico@nicoburns.com>
Date: Sat, 15 Feb 2025 12:19:13 +1300
Subject: [PATCH 2/5] Add CI task for checking malloc_size_of feature

Signed-off-by: Nico Burns <nico@nicoburns.com>
---
 .github/workflows/main.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 25b8fd7..fbbd9b9 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -23,6 +23,8 @@ jobs:
             features: --features bytemuck
           - version: stable
             features: --features arbitrary
+          - version: stable
+            features: --features malloc_size_of
           - version: nightly
             features: --features unstable
           - version: nightly

From ac66249dc22c24626493b61665f6b9961e854d2b Mon Sep 17 00:00:00 2001
From: Nico Burns <nico@nicoburns.com>
Date: Sat, 15 Feb 2025 12:20:27 +1300
Subject: [PATCH 3/5] Bump version number

Signed-off-by: Nico Burns <nico@nicoburns.com>
---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 486d356..a5d9593 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "euclid"
-version = "0.22.11"
+version = "0.22.12"
 authors = ["The Servo Project Developers"]
 edition = "2021"
 rust-version = "1.56.0"

From b74a9a289e8ad50546b90b3107933513fb0ae80f Mon Sep 17 00:00:00 2001
From: Nico Burns <nico@nicoburns.com>
Date: Wed, 19 Feb 2025 18:15:30 +1300
Subject: [PATCH 4/5] Remove use of dep syntax for MSRV compatibility

Signed-off-by: Nico Burns <nico@nicoburns.com>
---
 Cargo.toml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index a5d9593..cb8c5d0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -16,7 +16,6 @@ default = ["std"]
 unstable = []
 std = ["num-traits/std"]
 libm = ["num-traits/libm"]
-malloc_size_of = ["dep:malloc_size_of"]
 
 [dependencies]
 num-traits = { version = "0.2.15", default-features = false }

From 68ed42361193d314d60e523202c4429cbea7044a Mon Sep 17 00:00:00 2001
From: Nico Burns <nico@nicoburns.com>
Date: Wed, 19 Feb 2025 18:36:59 +1300
Subject: [PATCH 5/5] Bump MSRV to 1.63

Signed-off-by: Nico Burns <nico@nicoburns.com>
---
 .github/workflows/main.yml | 2 +-
 Cargo.toml                 | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index fbbd9b9..af9b0cb 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -15,7 +15,7 @@ jobs:
     strategy:
       matrix:
         features: ["", "--features serde", "--no-default-features --features libm"]
-        version: ["1.56.0", "stable", "beta", "nightly"]
+        version: ["1.63.0", "stable", "beta", "nightly"]
         include:
           - version: stable
             features: --features mint
diff --git a/Cargo.toml b/Cargo.toml
index cb8c5d0..e943da6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3,7 +3,7 @@ name = "euclid"
 version = "0.22.12"
 authors = ["The Servo Project Developers"]
 edition = "2021"
-rust-version = "1.56.0"
+rust-version = "1.63.0"
 description = "Geometry primitives"
 documentation = "https://docs.rs/euclid/"
 repository = "https://github.com/servo/euclid"