summaryrefslogtreecommitdiffstatshomepage
path: root/src/lib/netlist/plib/ptime.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/netlist/plib/ptime.h')
-rw-r--r--src/lib/netlist/plib/ptime.h119
1 files changed, 86 insertions, 33 deletions
diff --git a/src/lib/netlist/plib/ptime.h b/src/lib/netlist/plib/ptime.h
index 214f121c2df..7168477f49f 100644
--- a/src/lib/netlist/plib/ptime.h
+++ b/src/lib/netlist/plib/ptime.h
@@ -8,6 +8,8 @@
/// \file ptime.h
///
+#include <type_traits>
+
#include "pconfig.h"
#include "pmath.h" // std::floor
#include "ptypes.h"
@@ -19,6 +21,19 @@
namespace plib
{
+ template <typename T, typename U>
+ struct ptime_le
+ {
+ const static bool value = sizeof(T) <= sizeof(U);
+ };
+
+#if 0
+ template<typename T, typename U>
+ struct ptime_res {
+ using type = typename std::conditional<sizeof(T) >= sizeof(U), T, U>::type;
+ };
+#endif
+
template <typename TYPE, TYPE RES>
struct ptime final
{
@@ -27,6 +42,9 @@ namespace plib
using internal_type = TYPE;
using mult_type = TYPE;
+ template <typename altTYPE, altTYPE altRES>
+ friend struct ptime;
+
constexpr ptime() noexcept : m_time(0) {}
~ptime() noexcept = default;
@@ -43,56 +61,88 @@ namespace plib
constexpr explicit ptime(const internal_type nom, const internal_type den) noexcept
: m_time(nom * (RES / den)) { }
- C14CONSTEXPR ptime &operator+=(const ptime &rhs) noexcept { m_time += rhs.m_time; return *this; }
- C14CONSTEXPR ptime &operator-=(const ptime &rhs) noexcept { m_time -= rhs.m_time; return *this; }
- C14CONSTEXPR ptime &operator*=(const mult_type factor) noexcept { m_time *= static_cast<internal_type>(factor); return *this; }
+ // FIXME: check for overflow
+ template <typename O>
+ constexpr explicit ptime(const ptime<O, RES> &rhs) noexcept
+ : m_time(rhs.m_time) { }
- friend constexpr const ptime operator-(ptime lhs, const ptime rhs) noexcept
+ template <typename O>
+ C14CONSTEXPR ptime &operator+=(const ptime<O, RES> &rhs) noexcept
+ {
+ static_assert(ptime_le<ptime<O, RES>, ptime>::value, "Invalid ptime type");
+ m_time += rhs.m_time;
+ return *this;
+ }
+ template <typename O>
+ C14CONSTEXPR ptime &operator-=(const ptime<O, RES> &rhs) noexcept
{
- return ptime(lhs.m_time - rhs.m_time);
+ static_assert(ptime_le<ptime<O, RES>, ptime>::value, "Invalid ptime type");
+ m_time -= rhs.m_time;
+ return *this;
}
- friend constexpr const ptime operator+(ptime lhs, const ptime rhs) noexcept
+ template <typename M>
+ C14CONSTEXPR ptime &operator*=(const M &factor) noexcept
{
- return ptime(lhs.m_time + rhs.m_time);
+ static_assert(plib::is_integral<M>::value, "Factor must be an integral type");
+ m_time *= factor;
+ return *this;
}
- friend constexpr const ptime operator*(ptime lhs, const mult_type factor) noexcept
+ template <typename O>
+ constexpr ptime operator-(const ptime<O, RES> &rhs) const noexcept
{
- return ptime(lhs.m_time * factor);
+ static_assert(ptime_le<ptime<O, RES>, ptime>::value, "Invalid ptime type");
+ return ptime(m_time - rhs.m_time);
}
- friend constexpr mult_type operator/(const ptime lhs, const ptime rhs) noexcept
+ template <typename O>
+ constexpr ptime operator+(const ptime<O, RES> &rhs) const noexcept
{
- return static_cast<mult_type>(lhs.m_time / rhs.m_time);
+ static_assert(ptime_le<ptime<O, RES>, ptime>::value, "Invalid ptime type");
+ return ptime(m_time + rhs.m_time);
}
- friend constexpr bool operator<(const ptime lhs, const ptime rhs) noexcept
+ template <typename M>
+ constexpr ptime operator*(const M &factor) const noexcept
+ {
+ static_assert(plib::is_integral<M>::value, "Factor must be an integral type");
+ return ptime(m_time * static_cast<mult_type>(factor));
+ }
+
+ template <typename O>
+ constexpr mult_type operator/(const ptime<O, RES> &rhs) const noexcept
+ {
+ static_assert(ptime_le<ptime<O, RES>, ptime>::value, "Invalid ptime type");
+ return static_cast<mult_type>(m_time / rhs.m_time);
+ }
+
+ friend constexpr bool operator<(const ptime &lhs, const ptime &rhs) noexcept
{
return (lhs.m_time < rhs.m_time);
}
- friend constexpr bool operator>(const ptime lhs, const ptime rhs) noexcept
+ friend constexpr bool operator>(const ptime &lhs, const ptime &rhs) noexcept
{
return (rhs < lhs);
}
- friend constexpr bool operator<=(const ptime lhs, const ptime rhs) noexcept
+ friend constexpr bool operator<=(const ptime &lhs, const ptime &rhs) noexcept
{
return !(lhs > rhs);
}
- friend constexpr bool operator>=(const ptime lhs, const ptime rhs) noexcept
+ friend constexpr bool operator>=(const ptime &lhs, const ptime &rhs) noexcept
{
return !(lhs < rhs);
}
- friend constexpr bool operator==(const ptime lhs, const ptime rhs) noexcept
+ friend constexpr bool operator==(const ptime &lhs, const ptime &rhs) noexcept
{
return lhs.m_time == rhs.m_time;
}
- friend constexpr bool operator!=(const ptime lhs, const ptime rhs) noexcept
+ friend constexpr bool operator!=(const ptime &lhs, const ptime &rhs) noexcept
{
return !(lhs == rhs);
}
@@ -118,37 +168,41 @@ namespace plib
constexpr double as_float() const noexcept { return as_fp<float>(); }
constexpr double as_long_double() const noexcept { return as_fp<long double>(); }
+
+ constexpr ptime shl(unsigned shift) const noexcept { return ptime(m_time << shift); }
+ constexpr ptime shr(unsigned shift) const noexcept { return ptime(m_time >> shift); }
+
// for save states ....
C14CONSTEXPR internal_type *get_internaltype_ptr() noexcept { return &m_time; }
- static constexpr const ptime from_nsec(const internal_type ns) noexcept { return ptime(ns, UINT64_C(1000000000)); }
- static constexpr const ptime from_usec(const internal_type us) noexcept { return ptime(us, UINT64_C( 1000000)); }
- static constexpr const ptime from_msec(const internal_type ms) noexcept { return ptime(ms, UINT64_C( 1000)); }
- static constexpr const ptime from_sec(const internal_type s) noexcept { return ptime(s, UINT64_C( 1)); }
- static constexpr const ptime from_hz(const internal_type hz) noexcept { return ptime(1 , hz); }
- static constexpr const ptime from_raw(const internal_type raw) noexcept { return ptime(raw); }
+ static constexpr ptime from_nsec(internal_type ns) noexcept { return ptime(ns, UINT64_C(1000000000)); }
+ static constexpr ptime from_usec(internal_type us) noexcept { return ptime(us, UINT64_C( 1000000)); }
+ static constexpr ptime from_msec(internal_type ms) noexcept { return ptime(ms, UINT64_C( 1000)); }
+ static constexpr ptime from_sec(internal_type s) noexcept { return ptime(s, UINT64_C( 1)); }
+ static constexpr ptime from_hz(internal_type hz) noexcept { return ptime(1 , hz); }
+ static constexpr ptime from_raw(internal_type raw) noexcept { return ptime(raw); }
template <typename FT>
- static constexpr const typename std::enable_if<std::is_floating_point<FT>::value
+ static constexpr typename std::enable_if<std::is_floating_point<FT>::value
#if PUSE_FLOAT128
|| std::is_same<FT, __float128>::value
#endif
, ptime>::type
- from_fp(const FT t) noexcept { return ptime(static_cast<internal_type>(plib::floor(t * static_cast<FT>(RES) + static_cast<FT>(0.5))), RES); }
+ from_fp(FT t) noexcept { return ptime(static_cast<internal_type>(plib::floor(t * static_cast<FT>(RES) + static_cast<FT>(0.5))), RES); }
- static constexpr const ptime from_double(const double t) noexcept
+ static constexpr ptime from_double(double t) noexcept
{ return from_fp<double>(t); }
- static constexpr const ptime from_float(const float t) noexcept
+ static constexpr ptime from_float(float t) noexcept
{ return from_fp<float>(t); }
- static constexpr const ptime from_long_double(const long double t) noexcept
+ static constexpr ptime from_long_double(long double t) noexcept
{ return from_fp<long double>(t); }
- static constexpr const ptime zero() noexcept { return ptime(0, RES); }
- static constexpr const ptime quantum() noexcept { return ptime(1, RES); }
- static constexpr const ptime never() noexcept { return ptime(plib::numeric_limits<internal_type>::max(), RES); }
- static constexpr const internal_type resolution() noexcept { return RES; }
+ static constexpr ptime zero() noexcept { return ptime(0, RES); }
+ static constexpr ptime quantum() noexcept { return ptime(1, RES); }
+ static constexpr ptime never() noexcept { return ptime(plib::numeric_limits<internal_type>::max(), RES); }
+ static constexpr internal_type resolution() noexcept { return RES; }
constexpr internal_type in_nsec() const noexcept { return m_time / (RES / UINT64_C(1000000000)); }
constexpr internal_type in_usec() const noexcept { return m_time / (RES / UINT64_C( 1000000)); }
@@ -161,7 +215,6 @@ namespace plib
internal_type m_time;
};
-
} // namespace plib