StrongType.hpp

#pragma once
#include <iostream>
#include <type_traits>
 
namespace qip {
 
/*!
  @brief A light-weight easy-to-use single-file header-only template class for
  strong typing.
 
  @details
  It works using scoped enums; the enum value (+scope) are used to ensure
  uniqueness for a given user-defined strong type. The class template, defined in
  the qip namespace, takes an enum class value, and a base type. The base type is
  confined to be an arithmetic type (float, double, int, long, etc.) to allow for
  operator overloading. The 'using' declaration is optional, but makes things much
  easier.
 
  ```cpp
  using MyType = qip::StrongType<EnumClass::value, BaseType>;
  ```
 
  The newly-defined Strong Type will, for the most part, behave just like an
  instance of the underlying base type would. In particular, the usual arithmetic
  operations (+, -, \*, /, +=, \*= etc.) are all defined, and they work with
  iostreams. The main difference is that all implicit conversions are banned.
 
  ## Examples
 
  Usage is best shown with examples. Consider this dummy problem, where we define
  strong types for Energy, Mass, and Velocity.
 
  ```cpp
  #include "StrongType.hpp"
  enum class MechanicsTypes { energy, mass, velocity };
  // Use of enum class ensures each StrongType is unique
 
  using Energy   = qip::StrongType<MechanicsTypes::energy, double>;
  using Mass     = qip::StrongType<MechanicsTypes::mass, double>;
  using Velocity = qip::StrongType<MechanicsTypes::velocity, double>;
```
*/
template <auto enumV, typename BaseT>
struct StrongType {
private:
  static_assert(std::is_arithmetic_v<BaseT>,
                "StrongType only available for arithmetic types");
  static_assert(
    std::is_enum_v<decltype(enumV)>,
    "StrongType must be instantiated with scoped enum (enum class)");
  using StrongT = StrongType<enumV, BaseT>; // type alias
 
public:
  BaseT v;
 
  explicit constexpr StrongType(BaseT tv) : v(tv) {}
  explicit constexpr operator BaseT() const { return v; }
  constexpr BaseT &as_base() { return v; }
  [[nodiscard]] constexpr BaseT as_base() const { return v; }
 
  //! makes 'BaseType' publicly accessible
  using BaseType = BaseT;
 
  //! Provides operators for regular arithmetic operations
  constexpr StrongT &operator*=(const StrongT &rhs) {
    this->v *= rhs.v;
    return *this;
  }
  friend constexpr StrongT operator*(StrongT lhs, const StrongT &rhs) {
    return lhs *= rhs;
  }
  constexpr StrongT &operator/=(const StrongT &rhs) {
    this->v /= rhs.v;
    return *this;
  }
  friend constexpr StrongT operator/(StrongT lhs, const StrongT &rhs) {
    return lhs /= rhs;
  }
  constexpr StrongT &operator+=(const StrongT &rhs) {
    this->v += rhs.v;
    return *this;
  }
  friend constexpr StrongT operator+(StrongT lhs, const StrongT &rhs) {
    return lhs += rhs;
  }
  constexpr StrongT &operator-=(const StrongT &rhs) {
    this->v -= rhs.v;
    return *this;
  }
  friend constexpr StrongT operator-(StrongT lhs, const StrongT &rhs) {
    return lhs -= rhs;
  }
 
  //! Provides Base*Strong and Strong*Base operators for scalar multiplication.
  constexpr StrongT &operator*=(const BaseT &rhs) {
    this->v *= rhs;
    return *this;
  }
  friend constexpr StrongT operator*(StrongT lhs, const BaseT &rhs) {
    return lhs *= rhs;
  }
  friend constexpr StrongT operator*(const BaseT &lhs, StrongT rhs) {
    return rhs *= lhs;
  }
  //! Provide Strong/Base, but NOT Base/Strong (still scalar multiplication).
  // If StrongT is used for physical units, this will likely not be what you
  // want. In this case, just be explicit. Base/Strong is not scalar
  // multiplication.
  constexpr StrongT &operator/=(const BaseT &rhs) {
    this->v /= rhs;
    return *this;
  }
  friend constexpr StrongT operator/(StrongT lhs, const BaseT &rhs) {
    return lhs /= rhs;
  }
 
  //! Provides pre/post increment/decrement (++, --) operators
  constexpr StrongT &operator++() {
    ++v;
    return *this;
  }
  constexpr StrongT operator++(int) {
    StrongT result(*this);
    ++(*this);
    return result;
  }
  constexpr StrongT &operator--() {
    --v;
    return *this;
  }
  constexpr StrongT operator--(int) {
    StrongT result(*this);
    --(*this);
    return result;
  }
 
  //! Provides comparison operators
  friend constexpr bool operator==(const StrongT &lhs, const StrongT &rhs) {
    return lhs.v == rhs.v;
  }
  friend constexpr bool operator!=(const StrongT &lhs, const StrongT &rhs) {
    return !(lhs == rhs);
  }
  friend constexpr bool operator<(const StrongT &lhs, const StrongT &rhs) {
    return lhs.v < rhs.v;
  }
  friend constexpr bool operator>(const StrongT &lhs, const StrongT &rhs) {
    return rhs < lhs;
  }
  friend constexpr bool operator<=(const StrongT &lhs, const StrongT &rhs) {
    return !(rhs < lhs);
  }
  friend constexpr bool operator>=(const StrongT &lhs, const StrongT &rhs) {
    return !(lhs < rhs);
  }
 
  //! Provides comparison operators with BaseT rvalue literals (not lvalues).
  friend constexpr bool operator==(const StrongT &lhs, const BaseT &&rhs) {
    return lhs.v == rhs;
  }
  friend constexpr bool operator!=(const StrongT &lhs, const BaseT &&rhs) {
    return lhs.v != rhs;
  }
  friend constexpr bool operator<(const StrongT &lhs, const BaseT &&rhs) {
    return lhs.v < rhs;
  }
  friend constexpr bool operator>(const StrongT &lhs, const BaseT &&rhs) {
    return lhs.v > rhs;
  }
  friend constexpr bool operator<=(const StrongT &lhs, const BaseT &&rhs) {
    return lhs.v <= rhs;
  }
  friend constexpr bool operator>=(const StrongT &lhs, const BaseT &&rhs) {
    return lhs.v >= rhs;
  }
  friend constexpr bool operator==(const BaseT &&lhs, const StrongT &rhs) {
    return lhs == rhs.v;
  }
  friend constexpr bool operator!=(const BaseT &&lhs, const StrongT &rhs) {
    return lhs != rhs.v;
  }
  friend constexpr bool operator<(const BaseT &&lhs, const StrongT &rhs) {
    return lhs < rhs.v;
  }
  friend constexpr bool operator>(const BaseT &&lhs, const StrongT &rhs) {
    return lhs > rhs.v;
  }
  friend constexpr bool operator<=(const BaseT &&lhs, const StrongT &rhs) {
    return lhs <= rhs.v;
  }
  friend constexpr bool operator>=(const BaseT &&lhs, const StrongT &rhs) {
    return lhs >= rhs.v;
  }
 
  //! Provides iostream interface, works as it would for BaseT
  friend std::ostream &operator<<(std::ostream &os, const StrongT &rhs) {
    return os << rhs.v;
  }
  friend std::istream &operator>>(std::istream &is, StrongT &rhs) {
    return is >> rhs.v;
  }
};
 
} // namespace qip