summaryrefslogtreecommitdiffstatshomepage
path: root/src/emu/attotime.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/emu/attotime.h')
-rw-r--r--src/emu/attotime.h78
1 files changed, 42 insertions, 36 deletions
diff --git a/src/emu/attotime.h b/src/emu/attotime.h
index c3efeca4ad5..39fcf6e5310 100644
--- a/src/emu/attotime.h
+++ b/src/emu/attotime.h
@@ -38,9 +38,10 @@
#include "emucore.h"
#include "xtal.h"
-#include <math.h>
-#undef min
-#undef max
+#include "eminline.h"
+
+#include <cmath>
+
//**************************************************************************
// CONSTANTS
@@ -84,22 +85,22 @@ template <typename T> inline constexpr attoseconds_t ATTOSECONDS_IN_NSEC(T &&x)
//**************************************************************************
// TYPE DEFINITIONS
-//***************************************************************************/
+//**************************************************************************
// the attotime structure itself
class attotime
{
public:
// construction/destruction
- constexpr attotime() : m_seconds(0), m_attoseconds(0) { }
+ constexpr attotime() noexcept : m_seconds(0), m_attoseconds(0) { }
/** Constructs with @p secs seconds and @p attos attoseconds. */
- constexpr attotime(seconds_t secs, attoseconds_t attos) : m_seconds(secs), m_attoseconds(attos) { }
+ constexpr attotime(seconds_t secs, attoseconds_t attos) noexcept : m_seconds(secs), m_attoseconds(attos) { }
- constexpr attotime(const attotime& that) : m_seconds(that.m_seconds), m_attoseconds(that.m_attoseconds) { }
+ constexpr attotime(const attotime& that) noexcept : m_seconds(that.m_seconds), m_attoseconds(that.m_attoseconds) { }
// assignment
- attotime& operator=(const attotime& that)
+ attotime &operator=(const attotime& that) noexcept
{
this->m_seconds = that.m_seconds;
this->m_attoseconds = that.m_attoseconds;
@@ -107,36 +108,41 @@ public:
}
// queries
- constexpr bool is_zero() const { return (m_seconds == 0 && m_attoseconds == 0); }
+ constexpr bool is_zero() const noexcept { return (m_seconds == 0 && m_attoseconds == 0); }
/** Test if value is above @ref ATTOTIME_MAX_SECONDS (considered an overflow) */
- constexpr bool is_never() const { return (m_seconds >= ATTOTIME_MAX_SECONDS); }
+ constexpr bool is_never() const noexcept { return (m_seconds >= ATTOTIME_MAX_SECONDS); }
// conversion to other forms
- constexpr double as_double() const { return double(m_seconds) + ATTOSECONDS_TO_DOUBLE(m_attoseconds); }
- constexpr attoseconds_t as_attoseconds() const;
- constexpr double as_hz() const { return m_seconds == 0 ? ATTOSECONDS_TO_HZ(m_attoseconds) : is_never() ? 0.0 : 1.0 / as_double(); }
+ constexpr double as_double() const noexcept { return double(m_seconds) + ATTOSECONDS_TO_DOUBLE(m_attoseconds); }
+ constexpr attoseconds_t as_attoseconds() const noexcept;
+ double as_hz() const noexcept { assert(!is_zero()); return m_seconds == 0 ? ATTOSECONDS_TO_HZ(m_attoseconds) : is_never() ? 0.0 : 1.0 / as_double(); }
+ double as_khz() const noexcept { assert(!is_zero()); return m_seconds == 0 ? double(ATTOSECONDS_PER_MILLISECOND) / double(m_attoseconds) : is_never() ? 0.0 : 1e-3 / as_double(); }
+ double as_mhz() const noexcept { assert(!is_zero()); return m_seconds == 0 ? double(ATTOSECONDS_PER_MICROSECOND) / double(m_attoseconds) : is_never() ? 0.0 : 1e-6 / as_double(); }
u64 as_ticks(u32 frequency) const;
u64 as_ticks(const XTAL &xtal) const { return as_ticks(xtal.value()); }
/** Convert to string using at @p precision */
const char *as_string(int precision = 9) const;
+ /** Convert to string for human readability in logs */
+ std::string to_string() const;
+
/** @return the attoseconds portion. */
- constexpr attoseconds_t attoseconds() const { return m_attoseconds; }
+ constexpr attoseconds_t attoseconds() const noexcept { return m_attoseconds; }
/** @return the seconds portion. */
- constexpr seconds_t seconds() const { return m_seconds; }
+ constexpr seconds_t seconds() const noexcept { return m_seconds; }
static attotime from_double(double _time);
static attotime from_ticks(u64 ticks, u32 frequency);
static attotime from_ticks(u64 ticks, const XTAL &xtal) { return from_ticks(ticks, xtal.value()); }
- /** Create an attotime from a integer count of seconds @seconds */
+ /** Create an attotime from an integer count of seconds @p seconds */
static constexpr attotime from_seconds(s32 seconds) { return attotime(seconds, 0); }
- /** Create an attotime from a integer count of milliseconds @msec */
+ /** Create an attotime from an integer count of milliseconds @p msec */
static constexpr attotime from_msec(s64 msec) { return attotime(msec / 1000, (msec % 1000) * (ATTOSECONDS_PER_SECOND / 1000)); }
- /** Create an attotime from a integer count of microseconds @usec */
+ /** Create an attotime from an integer count of microseconds @p usec */
static constexpr attotime from_usec(s64 usec) { return attotime(usec / 1000000, (usec % 1000000) * (ATTOSECONDS_PER_SECOND / 1000000)); }
- /** Create an attotime from a integer count of nanoseconds @nsec */
+ /** Create an attotime from an integer count of nanoseconds @p nsec */
static constexpr attotime from_nsec(s64 nsec) { return attotime(nsec / 1000000000, (nsec % 1000000000) * (ATTOSECONDS_PER_SECOND / 1000000000)); }
- /** Create an attotime from at the given frequency @frequency */
+ /** Create an attotime from at the given frequency @p frequency */
static attotime from_hz(u32 frequency) { return (frequency > 1) ? attotime(0, HZ_TO_ATTOSECONDS(frequency)) : (frequency == 1) ? attotime(1, 0) : attotime::never; }
static attotime from_hz(int frequency) { return (frequency > 0) ? from_hz(u32(frequency)) : attotime::never; }
static attotime from_hz(const XTAL &xtal) { return (xtal.dvalue() > 1.0) ? attotime(0, HZ_TO_ATTOSECONDS(xtal)) : from_hz(xtal.dvalue()); }
@@ -154,8 +160,8 @@ public:
}
// math
- attotime &operator+=(const attotime &right);
- attotime &operator-=(const attotime &right);
+ attotime &operator+=(const attotime &right) noexcept;
+ attotime &operator-=(const attotime &right) noexcept;
attotime &operator*=(u32 factor);
attotime &operator/=(u32 factor);
@@ -175,7 +181,7 @@ public:
//**************************************************************************
/** handle addition between two attotimes */
-inline attotime operator+(const attotime &left, const attotime &right)
+inline constexpr attotime operator+(const attotime &left, const attotime &right) noexcept
{
attotime result;
@@ -200,7 +206,7 @@ inline attotime operator+(const attotime &left, const attotime &right)
return result;
}
-inline attotime &attotime::operator+=(const attotime &right)
+inline attotime &attotime::operator+=(const attotime &right) noexcept
{
// if one of the items is never, return never
if (this->m_seconds >= ATTOTIME_MAX_SECONDS || right.m_seconds >= ATTOTIME_MAX_SECONDS)
@@ -225,7 +231,7 @@ inline attotime &attotime::operator+=(const attotime &right)
/** handle subtraction between two attotimes */
-inline attotime operator-(const attotime &left, const attotime &right)
+inline constexpr attotime operator-(const attotime &left, const attotime &right) noexcept
{
attotime result;
@@ -246,7 +252,7 @@ inline attotime operator-(const attotime &left, const attotime &right)
return result;
}
-inline attotime &attotime::operator-=(const attotime &right)
+inline attotime &attotime::operator-=(const attotime &right) noexcept
{
// if time1 is never, return never
if (this->m_seconds >= ATTOTIME_MAX_SECONDS)
@@ -291,39 +297,39 @@ inline attotime operator/(const attotime &left, u32 factor)
/** handle comparisons between attotimes */
-inline constexpr bool operator==(const attotime &left, const attotime &right)
+inline constexpr bool operator==(const attotime &left, const attotime &right) noexcept
{
return (left.m_seconds == right.m_seconds && left.m_attoseconds == right.m_attoseconds);
}
-inline constexpr bool operator!=(const attotime &left, const attotime &right)
+inline constexpr bool operator!=(const attotime &left, const attotime &right) noexcept
{
return (left.m_seconds != right.m_seconds || left.m_attoseconds != right.m_attoseconds);
}
-inline constexpr bool operator<(const attotime &left, const attotime &right)
+inline constexpr bool operator<(const attotime &left, const attotime &right) noexcept
{
return (left.m_seconds < right.m_seconds || (left.m_seconds == right.m_seconds && left.m_attoseconds < right.m_attoseconds));
}
-inline constexpr bool operator<=(const attotime &left, const attotime &right)
+inline constexpr bool operator<=(const attotime &left, const attotime &right) noexcept
{
return (left.m_seconds < right.m_seconds || (left.m_seconds == right.m_seconds && left.m_attoseconds <= right.m_attoseconds));
}
-inline constexpr bool operator>(const attotime &left, const attotime &right)
+inline constexpr bool operator>(const attotime &left, const attotime &right) noexcept
{
return (left.m_seconds > right.m_seconds || (left.m_seconds == right.m_seconds && left.m_attoseconds > right.m_attoseconds));
}
-inline constexpr bool operator>=(const attotime &left, const attotime &right)
+inline constexpr bool operator>=(const attotime &left, const attotime &right) noexcept
{
return (left.m_seconds > right.m_seconds || (left.m_seconds == right.m_seconds && left.m_attoseconds >= right.m_attoseconds));
}
/** Convert to an attoseconds value, clamping to +/- 1 second */
-inline constexpr attoseconds_t attotime::as_attoseconds() const
+inline constexpr attoseconds_t attotime::as_attoseconds() const noexcept
{
return
(m_seconds == 0) ? m_attoseconds : // positive values between 0 and 1 second
@@ -341,7 +347,7 @@ inline u64 attotime::as_ticks(u32 frequency) const
}
-/** Create an attotime from a tick count @ticks at the given frequency @frequency */
+/** Create an attotime from a tick count @p ticks at the given frequency @p frequency */
inline attotime attotime::from_ticks(u64 ticks, u32 frequency)
{
if (frequency > 0)
@@ -352,7 +358,7 @@ inline attotime attotime::from_ticks(u64 ticks, u32 frequency)
return attotime(0, ticks * attos_per_tick);
u32 remainder;
- s32 secs = divu_64x32_rem(ticks, frequency, &remainder);
+ s32 secs = divu_64x32_rem(ticks, frequency, remainder);
return attotime(secs, u64(remainder) * attos_per_tick);
}
else
@@ -369,4 +375,4 @@ inline attotime attotime::from_double(double _time)
}
-#endif // MAME_EMU_ATTOTIME_H
+#endif // MAME_EMU_ATTOTIME_H