WowTime.cpp

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "WowTime.h"
#include "ByteBuffer.h"
#include "Errors.h"
#include "Util.h"
 
uint32 WowTime::GetPackedTime() const
{
 return ((_year % 100) & 0x1F) << 24
 | (_month & 0xF) << 20
 | (_monthDay & 0x3F) << 14
 | (_weekDay & 0x7) << 11
 | (_hour & 0x1F) << 6
 | (_minute & 0x3F)
 | (_flags & 0x3) << 29;
}
 
void WowTime::SetPackedTime(uint32 packedTime)
{
 _year = (packedTime >> 24) & 0x1F;
 if (_year == 31)
 _year = -1;
 
 _month = (packedTime >> 20) & 0xF;
 if (_month == 15)
 _month = -1;
 
 _monthDay = (packedTime >> 14) & 0x3F;
 if (_monthDay == 63)
 _monthDay = -1;
 
 _weekDay = (packedTime >> 11) & 0x7;
 if (_weekDay == 7)
 _weekDay = -1;
 
 _hour = (packedTime >> 6) & 0x1F;
 if (_hour == 31)
 _hour = -1;
 
 _minute = packedTime & 0x3F;
 if (_minute == 63)
 _minute = -1;
 
 _flags = (packedTime >> 29) & 0x3;
 if (_flags == 3)
 _flags = -1;
}
 
std::time_t WowTime::GetUnixTimeFromUtcTime() const
{
 if (_year < 0 || _month < 0 || _monthDay < 0)
 return 0;
 
 std::tm buf{};
 buf.tm_year = _year + 100;
 buf.tm_mon = _month;
 buf.tm_mday = _monthDay + 1;
 if (_hour >= 0)
 {
 buf.tm_hour = _hour;
 if (_minute >= 0)
 buf.tm_min = _minute;
 }
 buf.tm_isdst = -1;
 buf.tm_wday = _weekDay;
 
 return timegm(&buf);
}
 
void WowTime::SetUtcTimeFromUnixTime(std::time_t unixTime)
{
 std::tm buf;
 if (!::gmtime_r(&unixTime, &buf))
 return;
 
 _year = (buf.tm_year - 100) % 100;
 _month = buf.tm_mon;
 _monthDay = buf.tm_mday - 1;
 _weekDay = buf.tm_wday;
 _hour = buf.tm_hour;
 _minute = buf.tm_min;
}
 
void WowTime::SetYear(int32 year)
{
 ASSERT(year == -1 || (year >= 0 && year < 32));
 _year = year;
}
 
void WowTime::SetMonth(int8 month)
{
 ASSERT(month == -1 || (month >= 0 && month < 12));
 _month = month;
}
 
void WowTime::SetMonthDay(int8 monthDay)
{
 ASSERT(monthDay == -1 || (monthDay >= 0 && monthDay < 32));
 _monthDay = monthDay;
}
 
void WowTime::SetWeekDay(int8 weekDay)
{
 ASSERT(weekDay == -1 || (weekDay >= 0 && weekDay < 7));
 _weekDay = weekDay;
}
 
void WowTime::SetHour(int8 hour)
{
 ASSERT(hour == -1 || (hour >= 0 && hour < 24));
 _hour = hour;
}
 
void WowTime::SetMinute(int8 minute)
{
 ASSERT(minute == -1 || (minute >= 0 && minute < 60));
 _minute = minute;
}
 
void WowTime::SetFlags(int8 flags)
{
 ASSERT(flags == -1 || (flags >= 0 && flags < 3));
 _flags = flags;
}
 
std::strong_ordering operator<=>(WowTime const& left, WowTime const& right)
{
 auto compareFieldIfSet = [&]<typename T>(T WowTime::*field) -> std::strong_ordering
 {
 if (left.*field < 0 || right.*field < 0)
 return std::strong_ordering::equal;
 
 return left.*field <=> right.*field;
 };
 
 if (std::strong_ordering cmp = compareFieldIfSet(&WowTime::_year); advstd::is_neq(cmp))
 return cmp;
 
 if (std::strong_ordering cmp = compareFieldIfSet(&WowTime::_month); advstd::is_neq(cmp))
 return cmp;
 
 if (std::strong_ordering cmp = compareFieldIfSet(&WowTime::_monthDay); advstd::is_neq(cmp))
 return cmp;
 
 if (std::strong_ordering cmp = compareFieldIfSet(&WowTime::_weekDay); advstd::is_neq(cmp))
 return cmp;
 
 if (std::strong_ordering cmp = compareFieldIfSet(&WowTime::_year); advstd::is_neq(cmp))
 return cmp;
 
 if (std::strong_ordering cmp = compareFieldIfSet(&WowTime::_hour); advstd::is_neq(cmp))
 return cmp;
 
 return std::strong_ordering::equal;
}
 
bool WowTime::IsInRange(WowTime const& from, WowTime const& to) const
{
 if (from > to)
 return *this >= from || *this < to;
 
 return *this >= from && *this < to;
}
 
WowTime& WowTime::operator+=(Seconds seconds)
{
 time_t unixTime = GetUnixTimeFromUtcTime();
 unixTime += seconds.count();
 SetUtcTimeFromUnixTime(unixTime);
 return *this;
}
 
WowTime WowTime::operator+(Seconds seconds) const
{
 return WowTime(*this) += seconds;
}
 
WowTime& WowTime::operator-=(Seconds seconds)
{
 time_t unixTime = GetUnixTimeFromUtcTime();
 unixTime -= seconds.count();
 SetUtcTimeFromUnixTime(unixTime);
 return *this;
}
 
WowTime WowTime::operator-(Seconds seconds) const
{
 return WowTime(*this) -= seconds;
}
 
ByteBuffer& operator<<(ByteBuffer& data, WowTime const& wowTime)
{
 data << uint32(wowTime.GetPackedTime());
 return data;
}
 
ByteBuffer& operator>>(ByteBuffer& data, WowTime& wowTime)
{
 uint32 packedTime = 0;
 data >> packedTime;
 wowTime.SetPackedTime(packedTime);
 return data;
}