mirror of
https://github.com/XRPLF/rippled.git
synced 2025-12-06 17:27:55 +00:00
Rename beast sources for consistency
This commit is contained in:
Vinnie Falco
441
modules/beast_core/time/Time.cpp
Normal file
441
modules/beast_core/time/Time.cpp
Normal file
@@ -0,0 +1,441 @@
|
||||
//------------------------------------------------------------------------------
|
||||
/*
|
||||
This file is part of Beast: https://github.com/vinniefalco/Beast
|
||||
Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
|
||||
|
||||
Portions of this file are from JUCE.
|
||||
Copyright (c) 2013 - Raw Material Software Ltd.
|
||||
Please visit http://www.juce.com
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any
|
||||
purpose with or without fee is hereby granted, provided that the above
|
||||
copyright notice and this permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
//==============================================================================
|
||||
|
||||
namespace TimeHelpers
|
||||
{
|
||||
static struct tm millisToLocal (const int64 millis) noexcept
|
||||
{
|
||||
struct tm result;
|
||||
const int64 seconds = millis / 1000;
|
||||
|
||||
if (seconds < literal64bit (86400) || seconds >= literal64bit (2145916800))
|
||||
{
|
||||
// use extended maths for dates beyond 1970 to 2037..
|
||||
const int timeZoneAdjustment = 31536000 - (int) (Time (1971, 0, 1, 0, 0).toMilliseconds() / 1000);
|
||||
const int64 jdm = seconds + timeZoneAdjustment + literal64bit (210866803200);
|
||||
|
||||
const int days = (int) (jdm / literal64bit (86400));
|
||||
const int a = 32044 + days;
|
||||
const int b = (4 * a + 3) / 146097;
|
||||
const int c = a - (b * 146097) / 4;
|
||||
const int d = (4 * c + 3) / 1461;
|
||||
const int e = c - (d * 1461) / 4;
|
||||
const int m = (5 * e + 2) / 153;
|
||||
|
||||
result.tm_mday = e - (153 * m + 2) / 5 + 1;
|
||||
result.tm_mon = m + 2 - 12 * (m / 10);
|
||||
result.tm_year = b * 100 + d - 6700 + (m / 10);
|
||||
result.tm_wday = (days + 1) % 7;
|
||||
result.tm_yday = -1;
|
||||
|
||||
int t = (int) (jdm % literal64bit (86400));
|
||||
result.tm_hour = t / 3600;
|
||||
t %= 3600;
|
||||
result.tm_min = t / 60;
|
||||
result.tm_sec = t % 60;
|
||||
result.tm_isdst = -1;
|
||||
}
|
||||
else
|
||||
{
|
||||
time_t now = static_cast <time_t> (seconds);
|
||||
|
||||
#if BEAST_WINDOWS
|
||||
#ifdef _INC_TIME_INL
|
||||
if (now >= 0 && now <= 0x793406fff)
|
||||
localtime_s (&result, &now);
|
||||
else
|
||||
zerostruct (result);
|
||||
#else
|
||||
result = *localtime (&now);
|
||||
#endif
|
||||
#else
|
||||
|
||||
localtime_r (&now, &result); // more thread-safe
|
||||
#endif
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static int extendedModulo (const int64 value, const int modulo) noexcept
|
||||
{
|
||||
return (int) (value >= 0 ? (value % modulo)
|
||||
: (value - ((value / modulo) + 1) * modulo));
|
||||
}
|
||||
|
||||
static inline String formatString (const String& format, const struct tm* const tm)
|
||||
{
|
||||
#if BEAST_ANDROID
|
||||
typedef CharPointer_UTF8 StringType;
|
||||
#elif BEAST_WINDOWS
|
||||
typedef CharPointer_UTF16 StringType;
|
||||
#else
|
||||
typedef CharPointer_UTF32 StringType;
|
||||
#endif
|
||||
|
||||
for (size_t bufferSize = 256; ; bufferSize += 256)
|
||||
{
|
||||
HeapBlock<StringType::CharType> buffer (bufferSize);
|
||||
|
||||
#if BEAST_ANDROID
|
||||
const size_t numChars = strftime (buffer, bufferSize - 1, format.toUTF8(), tm);
|
||||
#elif BEAST_WINDOWS
|
||||
const size_t numChars = wcsftime (buffer, bufferSize - 1, format.toWideCharPointer(), tm);
|
||||
#else
|
||||
const size_t numChars = wcsftime (buffer, bufferSize - 1, format.toUTF32(), tm);
|
||||
#endif
|
||||
|
||||
if (numChars > 0)
|
||||
return String (StringType (buffer),
|
||||
StringType (buffer) + (int) numChars);
|
||||
}
|
||||
}
|
||||
|
||||
static uint32 lastMSCounterValue = 0;
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
Time::Time() noexcept
|
||||
: millisSinceEpoch (0)
|
||||
{
|
||||
}
|
||||
|
||||
Time::Time (const Time& other) noexcept
|
||||
: millisSinceEpoch (other.millisSinceEpoch)
|
||||
{
|
||||
}
|
||||
|
||||
Time::Time (const int64 ms) noexcept
|
||||
: millisSinceEpoch (ms)
|
||||
{
|
||||
}
|
||||
|
||||
Time::Time (const int year,
|
||||
const int month,
|
||||
const int day,
|
||||
const int hours,
|
||||
const int minutes,
|
||||
const int seconds,
|
||||
const int milliseconds,
|
||||
const bool useLocalTime) noexcept
|
||||
{
|
||||
bassert (year > 100); // year must be a 4-digit version
|
||||
|
||||
if (year < 1971 || year >= 2038 || ! useLocalTime)
|
||||
{
|
||||
// use extended maths for dates beyond 1970 to 2037..
|
||||
const int timeZoneAdjustment = useLocalTime ? (31536000 - (int) (Time (1971, 0, 1, 0, 0).toMilliseconds() / 1000))
|
||||
: 0;
|
||||
const int a = (13 - month) / 12;
|
||||
const int y = year + 4800 - a;
|
||||
const int jd = day + (153 * (month + 12 * a - 2) + 2) / 5
|
||||
+ (y * 365) + (y / 4) - (y / 100) + (y / 400)
|
||||
- 32045;
|
||||
|
||||
const int64 s = ((int64) jd) * literal64bit (86400) - literal64bit (210866803200);
|
||||
|
||||
millisSinceEpoch = 1000 * (s + (hours * 3600 + minutes * 60 + seconds - timeZoneAdjustment))
|
||||
+ milliseconds;
|
||||
}
|
||||
else
|
||||
{
|
||||
struct tm t;
|
||||
t.tm_year = year - 1900;
|
||||
t.tm_mon = month;
|
||||
t.tm_mday = day;
|
||||
t.tm_hour = hours;
|
||||
t.tm_min = minutes;
|
||||
t.tm_sec = seconds;
|
||||
t.tm_isdst = -1;
|
||||
|
||||
millisSinceEpoch = 1000 * (int64) mktime (&t);
|
||||
|
||||
if (millisSinceEpoch < 0)
|
||||
millisSinceEpoch = 0;
|
||||
else
|
||||
millisSinceEpoch += milliseconds;
|
||||
}
|
||||
}
|
||||
|
||||
Time::~Time() noexcept
|
||||
{
|
||||
}
|
||||
|
||||
Time& Time::operator= (const Time& other) noexcept
|
||||
{
|
||||
millisSinceEpoch = other.millisSinceEpoch;
|
||||
return *this;
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
int64 Time::currentTimeMillis() noexcept
|
||||
{
|
||||
#if BEAST_WINDOWS
|
||||
struct _timeb t;
|
||||
#ifdef _INC_TIME_INL
|
||||
_ftime_s (&t);
|
||||
#else
|
||||
_ftime (&t);
|
||||
#endif
|
||||
return ((int64) t.time) * 1000 + t.millitm;
|
||||
#else
|
||||
struct timeval tv;
|
||||
gettimeofday (&tv, nullptr);
|
||||
return ((int64) tv.tv_sec) * 1000 + tv.tv_usec / 1000;
|
||||
#endif
|
||||
}
|
||||
|
||||
Time BEAST_CALLTYPE Time::getCurrentTime() noexcept
|
||||
{
|
||||
return Time (currentTimeMillis());
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
uint32 beast_millisecondsSinceStartup() noexcept;
|
||||
|
||||
uint32 Time::getMillisecondCounter() noexcept
|
||||
{
|
||||
const uint32 now = beast_millisecondsSinceStartup();
|
||||
|
||||
if (now < TimeHelpers::lastMSCounterValue)
|
||||
{
|
||||
// in multi-threaded apps this might be called concurrently, so
|
||||
// make sure that our last counter value only increases and doesn't
|
||||
// go backwards..
|
||||
if (now < TimeHelpers::lastMSCounterValue - 1000)
|
||||
TimeHelpers::lastMSCounterValue = now;
|
||||
}
|
||||
else
|
||||
{
|
||||
TimeHelpers::lastMSCounterValue = now;
|
||||
}
|
||||
|
||||
return now;
|
||||
}
|
||||
|
||||
uint32 Time::getApproximateMillisecondCounter() noexcept
|
||||
{
|
||||
if (TimeHelpers::lastMSCounterValue == 0)
|
||||
getMillisecondCounter();
|
||||
|
||||
return TimeHelpers::lastMSCounterValue;
|
||||
}
|
||||
|
||||
void Time::waitForMillisecondCounter (const uint32 targetTime) noexcept
|
||||
{
|
||||
for (;;)
|
||||
{
|
||||
const uint32 now = getMillisecondCounter();
|
||||
|
||||
if (now >= targetTime)
|
||||
break;
|
||||
|
||||
const int toWait = (int) (targetTime - now);
|
||||
|
||||
if (toWait > 2)
|
||||
{
|
||||
Thread::sleep (bmin (20, toWait >> 1));
|
||||
}
|
||||
else
|
||||
{
|
||||
// xxx should consider using mutex_pause on the mac as it apparently
|
||||
// makes it seem less like a spinlock and avoids lowering the thread pri.
|
||||
for (int i = 10; --i >= 0;)
|
||||
Thread::yield();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
double Time::highResolutionTicksToSeconds (const int64 ticks) noexcept
|
||||
{
|
||||
return ticks / (double) getHighResolutionTicksPerSecond();
|
||||
}
|
||||
|
||||
int64 Time::secondsToHighResolutionTicks (const double seconds) noexcept
|
||||
{
|
||||
return (int64) (seconds * (double) getHighResolutionTicksPerSecond());
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
String Time::toString (const bool includeDate,
|
||||
const bool includeTime,
|
||||
const bool includeSeconds,
|
||||
const bool use24HourClock) const noexcept
|
||||
{
|
||||
String result;
|
||||
|
||||
if (includeDate)
|
||||
{
|
||||
result << getDayOfMonth() << ' '
|
||||
<< getMonthName (true) << ' '
|
||||
<< getYear();
|
||||
|
||||
if (includeTime)
|
||||
result << ' ';
|
||||
}
|
||||
|
||||
if (includeTime)
|
||||
{
|
||||
const int mins = getMinutes();
|
||||
|
||||
result << (use24HourClock ? getHours() : getHoursInAmPmFormat())
|
||||
<< (mins < 10 ? ":0" : ":") << mins;
|
||||
|
||||
if (includeSeconds)
|
||||
{
|
||||
const int secs = getSeconds();
|
||||
result << (secs < 10 ? ":0" : ":") << secs;
|
||||
}
|
||||
|
||||
if (! use24HourClock)
|
||||
result << (isAfternoon() ? "pm" : "am");
|
||||
}
|
||||
|
||||
return result.trimEnd();
|
||||
}
|
||||
|
||||
String Time::formatted (const String& format) const
|
||||
{
|
||||
struct tm t (TimeHelpers::millisToLocal (millisSinceEpoch));
|
||||
return TimeHelpers::formatString (format, &t);
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
int Time::getYear() const noexcept { return TimeHelpers::millisToLocal (millisSinceEpoch).tm_year + 1900; }
|
||||
int Time::getMonth() const noexcept { return TimeHelpers::millisToLocal (millisSinceEpoch).tm_mon; }
|
||||
int Time::getDayOfYear() const noexcept { return TimeHelpers::millisToLocal (millisSinceEpoch).tm_yday; }
|
||||
int Time::getDayOfMonth() const noexcept { return TimeHelpers::millisToLocal (millisSinceEpoch).tm_mday; }
|
||||
int Time::getDayOfWeek() const noexcept { return TimeHelpers::millisToLocal (millisSinceEpoch).tm_wday; }
|
||||
int Time::getHours() const noexcept { return TimeHelpers::millisToLocal (millisSinceEpoch).tm_hour; }
|
||||
int Time::getMinutes() const noexcept { return TimeHelpers::millisToLocal (millisSinceEpoch).tm_min; }
|
||||
int Time::getSeconds() const noexcept { return TimeHelpers::extendedModulo (millisSinceEpoch / 1000, 60); }
|
||||
int Time::getMilliseconds() const noexcept { return TimeHelpers::extendedModulo (millisSinceEpoch, 1000); }
|
||||
|
||||
int Time::getHoursInAmPmFormat() const noexcept
|
||||
{
|
||||
const int hours = getHours();
|
||||
|
||||
if (hours == 0) return 12;
|
||||
if (hours <= 12) return hours;
|
||||
|
||||
return hours - 12;
|
||||
}
|
||||
|
||||
bool Time::isAfternoon() const noexcept
|
||||
{
|
||||
return getHours() >= 12;
|
||||
}
|
||||
|
||||
bool Time::isDaylightSavingTime() const noexcept
|
||||
{
|
||||
return TimeHelpers::millisToLocal (millisSinceEpoch).tm_isdst != 0;
|
||||
}
|
||||
|
||||
String Time::getTimeZone() const noexcept
|
||||
{
|
||||
String zone[2];
|
||||
|
||||
#if BEAST_WINDOWS
|
||||
_tzset();
|
||||
|
||||
#ifdef _INC_TIME_INL
|
||||
for (int i = 0; i < 2; ++i)
|
||||
{
|
||||
char name[128] = { 0 };
|
||||
size_t length;
|
||||
_get_tzname (&length, name, 127, i);
|
||||
zone[i] = name;
|
||||
}
|
||||
#else
|
||||
const char** const zonePtr = (const char**) _tzname;
|
||||
zone[0] = zonePtr[0];
|
||||
zone[1] = zonePtr[1];
|
||||
#endif
|
||||
#else
|
||||
tzset();
|
||||
const char** const zonePtr = (const char**) tzname;
|
||||
zone[0] = zonePtr[0];
|
||||
zone[1] = zonePtr[1];
|
||||
#endif
|
||||
|
||||
if (isDaylightSavingTime())
|
||||
{
|
||||
zone[0] = zone[1];
|
||||
|
||||
if (zone[0].length() > 3
|
||||
&& zone[0].containsIgnoreCase ("daylight")
|
||||
&& zone[0].contains ("GMT"))
|
||||
zone[0] = "BST";
|
||||
}
|
||||
|
||||
return zone[0].substring (0, 3);
|
||||
}
|
||||
|
||||
String Time::getMonthName (const bool threeLetterVersion) const
|
||||
{
|
||||
return getMonthName (getMonth(), threeLetterVersion);
|
||||
}
|
||||
|
||||
String Time::getWeekdayName (const bool threeLetterVersion) const
|
||||
{
|
||||
return getWeekdayName (getDayOfWeek(), threeLetterVersion);
|
||||
}
|
||||
|
||||
String Time::getMonthName (int monthNumber, const bool threeLetterVersion)
|
||||
{
|
||||
const char* const shortMonthNames[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
|
||||
const char* const longMonthNames[] = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" };
|
||||
|
||||
monthNumber %= 12;
|
||||
|
||||
return TRANS (threeLetterVersion ? shortMonthNames [monthNumber]
|
||||
: longMonthNames [monthNumber]);
|
||||
}
|
||||
|
||||
String Time::getWeekdayName (int day, const bool threeLetterVersion)
|
||||
{
|
||||
const char* const shortDayNames[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
|
||||
const char* const longDayNames[] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };
|
||||
|
||||
day %= 7;
|
||||
|
||||
return TRANS (threeLetterVersion ? shortDayNames [day]
|
||||
: longDayNames [day]);
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
Time& Time::operator+= (RelativeTime delta) { millisSinceEpoch += delta.inMilliseconds(); return *this; }
|
||||
Time& Time::operator-= (RelativeTime delta) { millisSinceEpoch -= delta.inMilliseconds(); return *this; }
|
||||
|
||||
Time operator+ (Time time, RelativeTime delta) { Time t (time); return t += delta; }
|
||||
Time operator- (Time time, RelativeTime delta) { Time t (time); return t -= delta; }
|
||||
Time operator+ (RelativeTime delta, Time time) { Time t (time); return t += delta; }
|
||||
const RelativeTime operator- (Time time1, Time time2) { return RelativeTime::milliseconds (time1.toMilliseconds() - time2.toMilliseconds()); }
|
||||
|
||||
bool operator== (Time time1, Time time2) { return time1.toMilliseconds() == time2.toMilliseconds(); }
|
||||
bool operator!= (Time time1, Time time2) { return time1.toMilliseconds() != time2.toMilliseconds(); }
|
||||
bool operator< (Time time1, Time time2) { return time1.toMilliseconds() < time2.toMilliseconds(); }
|
||||
bool operator> (Time time1, Time time2) { return time1.toMilliseconds() > time2.toMilliseconds(); }
|
||||
bool operator<= (Time time1, Time time2) { return time1.toMilliseconds() <= time2.toMilliseconds(); }
|
||||
bool operator>= (Time time1, Time time2) { return time1.toMilliseconds() >= time2.toMilliseconds(); }
|
||||
Reference in New Issue
Block a user