si_internal.hpp

Go to the documentation of this file.

#pragma once
#include <ratio>
#include <utility>
namespace Si {
namespace Internal {
#ifdef TYPE_SI_DISABLE_CHECKS
template <typename T, typename... Powers> using Unit = T;
#else
template <typename T, typename... Powers> class Unit {
  T _value;
 
public:
  explicit Unit(const T &value = T()) : _value(value) {}
  template <typename AnotherT>
  Unit(const Unit<AnotherT, Powers...> &unit)
      : _value(static_cast<AnotherT>(unit)) {}
  template <typename AnotherT> explicit operator AnotherT() const {
    return static_cast<AnotherT>(_value);
  }
  T operator+() const { return _value; }
  template <typename AnotherT>
  decltype(std::declval<T>() == std::declval<AnotherT>())
  operator==(const Unit<AnotherT, Powers...> &unit) const {
    return _value == static_cast<AnotherT>(unit);
  }
  template <typename AnotherT>
  decltype(std::declval<T>() != std::declval<AnotherT>())
  operator!=(const Unit<AnotherT, Powers...> &unit) const {
    return _value != static_cast<AnotherT>(unit);
  }
  template <typename AnotherT>
  decltype(std::declval<T>() < std::declval<AnotherT>())
  operator<(const Unit<AnotherT, Powers...> &unit) const {
    return _value < static_cast<AnotherT>(unit);
  }
  template <typename AnotherT>
  decltype(std::declval<T>() <= std::declval<AnotherT>())
  operator<=(const Unit<AnotherT, Powers...> &unit) const {
    return _value <= static_cast<AnotherT>(unit);
  }
  template <typename AnotherT>
  decltype(std::declval<T>() > std::declval<AnotherT>())
  operator>(const Unit<AnotherT, Powers...> &unit) const {
    return _value > static_cast<AnotherT>(unit);
  }
  template <typename AnotherT>
  decltype(std::declval<T>() >= std::declval<AnotherT>())
  operator>=(const Unit<AnotherT, Powers...> &unit) const {
    return _value >= static_cast<AnotherT>(unit);
  }
  template <typename AnotherT>
  Unit<decltype(std::declval<T>() + std::declval<AnotherT>()), Powers...>
  operator+(const Unit<AnotherT, Powers...> &unit) const {
    return Unit<decltype(std::declval<T>() + std::declval<AnotherT>()),
                Powers...>(_value + static_cast<AnotherT>(unit));
  }
  Unit &operator++() {
    ++_value;
    return *this;
  }
  Unit operator++(int) { return Unit(_value++); }
  template <typename AnotherT>
  Unit &operator+=(const Unit<AnotherT, Powers...> &unit) {
    _value += static_cast<AnotherT>(unit);
    return *this;
  }
  template <typename AnotherT>
  Unit<decltype(std::declval<T>() - std::declval<AnotherT>()), Powers...>
  operator-(const Unit<AnotherT, Powers...> &unit) const {
    return Unit<decltype(std::declval<T>() - std::declval<AnotherT>()),
                Powers...>(_value - static_cast<AnotherT>(unit));
  }
  template <typename AnotherT>
  Unit &operator-=(const Unit<AnotherT, Powers...> &unit) {
    _value -= static_cast<AnotherT>(unit);
    return *this;
  }
  Unit &operator--() {
    --_value;
    return *this;
  }
  Unit operator--(int) { return Unit(_value--); }
  Unit<decltype(std::declval<T>() * std::declval<T>()), Powers...>
  operator*(const T &value) const {
    return Unit<decltype(std::declval<T>() * std::declval<T>()), Powers...>(
        _value * value);
  }
  Unit<decltype(std::declval<T>() / std::declval<T>()), Powers...>
  operator/(const T &value) const {
    return Unit<decltype(std::declval<T>() / std::declval<T>()), Powers...>(
        _value / value);
  }
  Unit &operator*=(const T &value) {
    _value *= value;
    return *this;
  }
  Unit &operator/=(const T &value) {
    _value /= value;
    return *this;
  }
  template <typename AnotherT, typename... OtherPowers>
  Unit<decltype(std::declval<T>() * std::declval<AnotherT>()),
       std::ratio_add<Powers, OtherPowers>...>
  operator*(const Unit<AnotherT, OtherPowers...> &unit) const {
    return Unit<decltype(std::declval<T>() * std::declval<AnotherT>()),
                std::ratio_add<Powers, OtherPowers>...>(
        _value * static_cast<AnotherT>(unit));
  }
  template <typename AnotherT, typename... OtherPowers>
  Unit<decltype(std::declval<T>() / std::declval<AnotherT>()),
       std::ratio_subtract<Powers, OtherPowers>...>
  operator/(const Unit<AnotherT, OtherPowers...> &unit) const {
    return Unit<decltype(std::declval<T>() / std::declval<AnotherT>()),
                std::ratio_subtract<Powers, OtherPowers>...>(
        _value / static_cast<AnotherT>(unit));
  }
};
#endif
template <typename... Elements> struct Tuple {};
template <typename T, typename... Powers>
Tuple<Powers...> getPowers(Unit<T, Powers...>) {}
template <typename U> using Powers = decltype(getPowers(std::declval<U>()));
template <typename T>
using Dimensionless =
    Unit<T, std::ratio<0>, std::ratio<0>, std::ratio<0>, std::ratio<0>,
         std::ratio<0>, std::ratio<0>, std::ratio<0>>;
} // namespace Internal
} // namespace Si