Merge pull request #21 from ion098/ostream-support

feat: ✨ Allow printing unnamed unit types

Author: jmakif

include/units/Angle.hpp

@@ -16,6 +16,16 @@ class Angle : public Quantity<std::ratio<0>, std::ratio<0>, std::ratio<0>, std::
                        std::ratio<0>, std::ratio<0>>(value) {};
 };
 
+template <> struct LookupName<Quantity<std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<1>,
+                                       std::ratio<0>, std::ratio<0>, std::ratio<0>>> {
+        using Named = Angle;
+};
+
+inline std::ostream& operator<<(std::ostream& os, const Angle& quantity) {
+    os << quantity.internal() << " rad";
+    return os;
+}
+
 constexpr Angle rad = Angle(1.0);
 constexpr Angle deg = Angle(M_PI / 180);
 constexpr Angle rot = Angle(M_TWOPI);

include/units/Temperature.hpp

@@ -2,8 +2,29 @@
 
 #include "units/units.hpp"
 
-using Temperature = Quantity<std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<1>,
-                             std::ratio<0>, std::ratio<0>>;
+class Temperature : public Quantity<std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<0>,
+                                    std::ratio<1>, std::ratio<0>, std::ratio<0>> {
+    public:
+        explicit constexpr Temperature(double value)
+            : Quantity<std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<1>,
+                       std::ratio<0>, std::ratio<0>>(value) {}
+
+        constexpr Temperature(Quantity<std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<0>,
+                                       std::ratio<1>, std::ratio<0>, std::ratio<0>>
+                                  value)
+            : Quantity<std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<1>,
+                       std::ratio<0>, std::ratio<0>>(value) {};
+};
+
+template <> struct LookupName<Quantity<std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<0>,
+                                       std::ratio<1>, std::ratio<0>, std::ratio<0>>> {
+        using Named = Temperature;
+};
+
+inline std::ostream& operator<<(std::ostream& os, const Temperature& quantity) {
+    os << quantity.internal() << " k";
+    return os;
+}
 
 constexpr Temperature kelvin = Temperature(1.0);
 

include/units/units.hpp

@@ -121,7 +121,7 @@ template <typename Q> using Named = typename LookupName<Q>::Named;
 template <typename Mass = std::ratio<0>, typename Length = std::ratio<0>, typename Time = std::ratio<0>,
           typename Current = std::ratio<0>, typename Angle = std::ratio<0>, typename Temperature = std::ratio<0>,
           typename Luminosity = std::ratio<0>, typename Moles = std::ratio<0>>
-void quantityChecker(Quantity<Mass, Length, Time, Current, Angle, Temperature, Luminosity, Moles> q) {}
+void quantityChecker(Quantity<Mass, Length, Time, Current, Angle, Temperature, Luminosity, Moles>) {}
 
 // isQuantity concept
 template <typename Q>
@@ -164,6 +164,47 @@ template <isQuantity Q, typename quotient> using Rooted = Named<
              std::ratio_divide<typename Q::angle, quotient>, std::ratio_divide<typename Q::temperature, quotient>,
              std::ratio_divide<typename Q::luminosity, quotient>, std::ratio_divide<typename Q::moles, quotient>>>;
 
+template <isQuantity Q> inline std::ostream& operator<<(std::ostream& os, const Q& quantity) {
+    if constexpr (!std::is_same_v<Named<Q>, Q>) {
+        os << Named<Q>(quantity);
+    } else {
+        os << quantity.internal();
+        if constexpr (Q::mass::num != 0) {
+            os << " kg^" << Q::mass::num;
+            if constexpr (Q::mass::den != 1) os << "/" << Q::mass::den;
+        }
+        if constexpr (Q::length::num != 0) {
+            os << "*m^" << Q::length::num;
+            if constexpr (Q::length::den != 1) os << "/" << Q::length::den;
+        }
+        if constexpr (Q::time::num != 0) {
+            os << "*s^" << Q::time::num;
+            if constexpr (Q::time::den != 1) os << "/" << Q::time::den;
+        }
+        if constexpr (Q::current::num != 0) {
+            os << "*A^" << Q::current::num;
+            if constexpr (Q::current::den != 1) os << "/" << Q::current::den;
+        }
+        if constexpr (Q::angle::num != 0) {
+            os << "*rad^" << Q::angle::num;
+            if constexpr (Q::angle::den != 1) os << "/" << Q::angle::den;
+        }
+        if constexpr (Q::temperature::num != 0) {
+            os << "*K^" << Q::temperature::num;
+            if constexpr (Q::temperature::den != 1) os << "/" << Q::temperature::den;
+        }
+        if constexpr (Q::luminosity::num != 0) {
+            os << "*cd^" << Q::luminosity::num;
+            if constexpr (Q::luminosity::den != 1) os << "/" << Q::luminosity::den;
+        }
+        if constexpr (Q::moles::num != 0) {
+            os << "*mol^" << Q::moles::num;
+            if constexpr (Q::moles::den != 1) os << "/" << Q::moles::den;
+        }
+    }
+    return os;
+}
+
 template <isQuantity Q, isQuantity R> constexpr Q operator+(Q lhs, R rhs)
     requires Isomorphic<Q, R>
 {
@@ -243,7 +284,7 @@ template <isQuantity Q, isQuantity R> constexpr bool operator>(const Q& lhs, con
                                            std::ratio<o>, std::ratio<j>, std::ratio<n>>> {                             \
             using Named = Name;                                                                                        \
     };                                                                                                                 \
-    constexpr Name suffix = Name(1.0);                                                                                 \
+    [[maybe_unused]] constexpr Name suffix = Name(1.0);                                                                \
     constexpr Name operator""_##suffix(long double value) {                                                            \
         return Name(Quantity<std::ratio<m>, std::ratio<l>, std::ratio<t>, std::ratio<i>, std::ratio<a>, std::ratio<o>, \
                              std::ratio<j>, std::ratio<n>>(static_cast<double>(value)));                               \
@@ -253,14 +294,14 @@ template <isQuantity Q, isQuantity R> constexpr bool operator>(const Q& lhs, con
                              std::ratio<j>, std::ratio<n>>(static_cast<double>(value)));                               \
     }                                                                                                                  \
     inline std::ostream& operator<<(std::ostream& os, const Name& quantity) {                                          \
-        os << quantity.internal() << "_" << #suffix;                                                                   \
+        os << quantity.internal() << " " << #suffix;                                                                   \
         return os;                                                                                                     \
     }                                                                                                                  \
     constexpr inline Name from_##suffix(double value) { return Name(value); }                                          \
     constexpr inline double to_##suffix(Name quantity) { return quantity.internal(); }
 
 #define NEW_UNIT_LITERAL(Name, suffix, multiple)                                                                       \
-    constexpr Name suffix = multiple;                                                                                  \
+    [[maybe_unused]] constexpr Name suffix = multiple;                                                                 \
     constexpr Name operator""_##suffix(long double value) { return static_cast<double>(value) * multiple; }            \
     constexpr Name operator""_##suffix(unsigned long long value) { return static_cast<double>(value) * multiple; }     \
     constexpr inline Name from_##suffix(double value) { return value * multiple; }                                     \