implement full std::format support

Author: SizzinSeal

include/units/Pose.hpp

@@ -73,4 +73,32 @@ using VelocityPose = AbstractPose<std::ratio<1>>;
 // AccelerationPose (Length / Time^2, Angle / Time^2)
 using AccelerationPose = AbstractPose<std::ratio<2>>;
 
-} // namespace units
+} // namespace units
+
+template <> struct std::formatter<units::Pose, char> : std::formatter<double, char> {
+        // Parse specifiers (using the base class's parse function)
+        template <typename ParseContext> constexpr auto parse(ParseContext& ctx) {
+            // Call parse on the current object (base class subobject)
+            return std::formatter<double, char>::parse(ctx);
+        }
+
+        // Format the units::Pose object
+        template <typename FormatContext> auto format(const units::Pose& vector, FormatContext& ctx) const {
+            auto it = ctx.out();
+            it = format_to(it, "(");
+
+            // Create temporary formatter objects for Length and Angle
+            std::formatter<Length, char> fmtLength {};
+            std::formatter<Angle, char> fmtAngle {};
+
+            // Use the temporary objects to format each component.
+            it = fmtLength.format(vector.x, ctx);
+            it = format_to(it, ", ");
+            it = fmtLength.format(vector.y, ctx);
+            it = format_to(it, ", ");
+            it = fmtAngle.format(vector.orientation, ctx);
+            it = format_to(it, ")");
+
+            return it;
+        }
+};

include/units/Vector2D.hpp

@@ -2,6 +2,8 @@
 
 #include "units/Angle.hpp"
 
+namespace units {
+
 /**
  * @class Vector2D
  *
@@ -276,12 +278,19 @@ constexpr Vector2D<Q3> operator*(Q1 lhs, const Vector2D<Q2>& rhs) {
  */
 template <isQuantity Q> constexpr Vector2D<Q> operator*(double lhs, const Vector2D<Q>& rhs) { return rhs * lhs; }
 
-namespace std {
-template <typename T> struct formatter<Vector2D<T>> : formatter<T> {
+// define some common vector types
+typedef Vector2D<Length> V2Position;
+typedef Vector2D<LinearVelocity> V2Velocity;
+typedef Vector2D<LinearAcceleration> V2Acceleration;
+typedef Vector2D<Force> V2Force;
+
+} // namespace units
+
+template <typename T> struct std::formatter<units::Vector2D<T>> : std::formatter<T> {
         // Optionally parse format specifiers for T
         constexpr auto parse(auto& ctx) { return formatter<T>::parse(ctx); }
 
-        auto format(const Vector2D<T>& vector, format_context& ctx) const {
+        auto format(const units::Vector2D<T>& vector, format_context& ctx) const {
             auto it = ctx.out();
             it = format_to(it, "(");
 
@@ -295,11 +304,4 @@ template <typename T> struct formatter<Vector2D<T>> : formatter<T> {
 
             return it;
         }
-};
-} // namespace std
-
-// define some common vector types
-typedef Vector2D<Length> V2Position;
-typedef Vector2D<LinearVelocity> V2Velocity;
-typedef Vector2D<LinearAcceleration> V2Acceleration;
-typedef Vector2D<Force> V2Force;
+};

include/units/Vector3D.hpp

@@ -351,4 +351,28 @@ typedef Vector3D<Length> V3Position;
 typedef Vector3D<LinearVelocity> V3Velocity;
 typedef Vector3D<LinearAcceleration> V3Acceleration;
 typedef Vector3D<Force> V3Force;
-} // namespace units
+} // namespace units
+
+template <typename T> struct std::formatter<units::Vector3D<T>> : std::formatter<T> {
+        // Optionally parse format specifiers for T
+        constexpr auto parse(auto& ctx) { return formatter<T>::parse(ctx); }
+
+        auto format(const units::Vector3D<T>& vector, format_context& ctx) const {
+            auto it = ctx.out();
+            it = format_to(it, "(");
+
+            // Format vector.x using the base formatter<T>
+            it = static_cast<const formatter<T>*>(this)->format(vector.x, ctx);
+            it = format_to(it, ", ");
+
+            // Format vector.y using the base formatter<T>
+            it = static_cast<const formatter<T>*>(this)->format(vector.y, ctx);
+            it = format_to(it, ", ");
+
+            // Format vector.z using the base formatter<T>
+            it = static_cast<const formatter<T>*>(this)->format(vector.z, ctx);
+            it = format_to(it, ")");
+
+            return it;
+        }
+};

src/main.cpp

@@ -15,7 +15,7 @@ void initialize() {
     std::cout << std::format("{:.2f}", units::pow<5>(505_cm) * 15_celsius) << std::endl;
     Number a(2.123);
     std::cout << std::format("{:.2f}", a) << std::endl;
-    Vector2D<Length> v2a = V2Position(2_in, 2_in) / 2;
+    units::Vector2D<Length> v2a = units::V2Position(2_in, 2_in) / 2;
     std::cout << std::format("{}", v2a) << std::endl;
 }
 
@@ -50,11 +50,11 @@ constexpr void v3dTests() {
 
 constexpr void v2dTests() {
     // check Vector2D overloads
-    Vector2D<Length> v2a = V2Position(2_in, 2_in) / 2;
-    Vector2D<Length> v2b = 2 * V2Position(2_in, 2_in) * 2;
-    Vector2D<Area> v2c = 2_in * V2Position(2_in, 2_in);
-    Vector2D<Area> v2d = V2Position(2_in, 2_in) * 2_in;
-    Vector2D<Number> v2e = V2Position(2_in, 2_in) / 2_in;
+    units::Vector2D<Length> v2a = units::V2Position(2_in, 2_in) / 2;
+    units::Vector2D<Length> v2b = 2 * units::V2Position(2_in, 2_in) * 2;
+    units::Vector2D<Area> v2c = 2_in * units::V2Position(2_in, 2_in);
+    units::Vector2D<Area> v2d = units::V2Position(2_in, 2_in) * 2_in;
+    units::Vector2D<Number> v2e = units::V2Position(2_in, 2_in) / 2_in;
 }
 
 constexpr void angleTests() {