Mirrors/yuzu
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

core: Replace all instances of ResultCode with Result

Browse source
This commit is contained in:
german77 2022-06-25 22:44:19 -05:00
parent abfd690601
commit a7d9be1384
140 changed files with 1133 additions and 1173 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/core/hle/service/time/clock_types.h
View file

@ -22,7 +22,7 @@ struct SteadyClockTimePoint {
s64 time_point;
Common::UUID clock_source_id;
ResultCode GetSpanBetween(SteadyClockTimePoint other, s64& span) const {
Result GetSpanBetween(SteadyClockTimePoint other, s64& span) const {
span = 0;
if (clock_source_id != other.clock_source_id) {
@ -92,9 +92,9 @@ struct ClockSnapshot {
TimeType type;
INSERT_PADDING_BYTES_NOINIT(0x2);
static ResultCode GetCurrentTime(s64& current_time,
const SteadyClockTimePoint& steady_clock_time_point,
const SystemClockContext& context) {
static Result GetCurrentTime(s64& current_time,
const SteadyClockTimePoint& steady_clock_time_point,
const SystemClockContext& context) {
if (steady_clock_time_point.clock_source_id != context.steady_time_point.clock_source_id) {
current_time = 0;
return ERROR_TIME_MISMATCH;

20
src/core/hle/service/time/errors.h
View file

@ -7,15 +7,15 @@
namespace Service::Time {
constexpr ResultCode ERROR_PERMISSION_DENIED{ErrorModule::Time, 1};
constexpr ResultCode ERROR_TIME_MISMATCH{ErrorModule::Time, 102};
constexpr ResultCode ERROR_UNINITIALIZED_CLOCK{ErrorModule::Time, 103};
constexpr ResultCode ERROR_TIME_NOT_FOUND{ErrorModule::Time, 200};
constexpr ResultCode ERROR_OVERFLOW{ErrorModule::Time, 201};
constexpr ResultCode ERROR_LOCATION_NAME_TOO_LONG{ErrorModule::Time, 801};
constexpr ResultCode ERROR_OUT_OF_RANGE{ErrorModule::Time, 902};
constexpr ResultCode ERROR_TIME_ZONE_CONVERSION_FAILED{ErrorModule::Time, 903};
constexpr ResultCode ERROR_TIME_ZONE_NOT_FOUND{ErrorModule::Time, 989};
constexpr ResultCode ERROR_NOT_IMPLEMENTED{ErrorModule::Time, 990};
constexpr Result ERROR_PERMISSION_DENIED{ErrorModule::Time, 1};
constexpr Result ERROR_TIME_MISMATCH{ErrorModule::Time, 102};
constexpr Result ERROR_UNINITIALIZED_CLOCK{ErrorModule::Time, 103};
constexpr Result ERROR_TIME_NOT_FOUND{ErrorModule::Time, 200};
constexpr Result ERROR_OVERFLOW{ErrorModule::Time, 201};
constexpr Result ERROR_LOCATION_NAME_TOO_LONG{ErrorModule::Time, 801};
constexpr Result ERROR_OUT_OF_RANGE{ErrorModule::Time, 902};
constexpr Result ERROR_TIME_ZONE_CONVERSION_FAILED{ErrorModule::Time, 903};
constexpr Result ERROR_TIME_ZONE_NOT_FOUND{ErrorModule::Time, 989};
constexpr Result ERROR_NOT_IMPLEMENTED{ErrorModule::Time, 990};
} // namespace Service::Time

2
src/core/hle/service/time/local_system_clock_context_writer.h
View file

@ -14,7 +14,7 @@ public:
: SystemClockContextUpdateCallback{}, shared_memory{shared_memory_} {}
protected:
ResultCode Update() override {
Result Update() override {
shared_memory.UpdateLocalSystemClockContext(context);
return ResultSuccess;
}

2
src/core/hle/service/time/network_system_clock_context_writer.h
View file

@ -15,7 +15,7 @@ public:
: SystemClockContextUpdateCallback{}, shared_memory{shared_memory_} {}
protected:
ResultCode Update() override {
Result Update() override {
shared_memory.UpdateNetworkSystemClockContext(context);
return ResultSuccess;
}

22
src/core/hle/service/time/standard_user_system_clock_core.cpp
View file

@ -27,9 +27,9 @@ StandardUserSystemClockCore::~StandardUserSystemClockCore() {
service_context.CloseEvent(auto_correction_event);
}
ResultCode StandardUserSystemClockCore::SetAutomaticCorrectionEnabled(Core::System& system,
bool value) {
if (const ResultCode result{ApplyAutomaticCorrection(system, value)}; result != ResultSuccess) {
Result StandardUserSystemClockCore::SetAutomaticCorrectionEnabled(Core::System& system,
bool value) {
if (const Result result{ApplyAutomaticCorrection(system, value)}; result != ResultSuccess) {
return result;
}
@ -38,27 +38,27 @@ ResultCode StandardUserSystemClockCore::SetAutomaticCorrectionEnabled(Core::Syst
return ResultSuccess;
}
ResultCode StandardUserSystemClockCore::GetClockContext(Core::System& system,
SystemClockContext& ctx) const {
if (const ResultCode result{ApplyAutomaticCorrection(system, false)}; result != ResultSuccess) {
Result StandardUserSystemClockCore::GetClockContext(Core::System& system,
SystemClockContext& ctx) const {
if (const Result result{ApplyAutomaticCorrection(system, false)}; result != ResultSuccess) {
return result;
}
return local_system_clock_core.GetClockContext(system, ctx);
}
ResultCode StandardUserSystemClockCore::Flush(const SystemClockContext&) {
Result StandardUserSystemClockCore::Flush(const SystemClockContext&) {
UNIMPLEMENTED();
return ERROR_NOT_IMPLEMENTED;
}
ResultCode StandardUserSystemClockCore::SetClockContext(const SystemClockContext&) {
Result StandardUserSystemClockCore::SetClockContext(const SystemClockContext&) {
UNIMPLEMENTED();
return ERROR_NOT_IMPLEMENTED;
}
ResultCode StandardUserSystemClockCore::ApplyAutomaticCorrection(Core::System& system,
bool value) const {
Result StandardUserSystemClockCore::ApplyAutomaticCorrection(Core::System& system,
bool value) const {
if (auto_correction_enabled == value) {
return ResultSuccess;
}
@ -68,7 +68,7 @@ ResultCode StandardUserSystemClockCore::ApplyAutomaticCorrection(Core::System& s
}
SystemClockContext ctx{};
if (const ResultCode result{network_system_clock_core.GetClockContext(system, ctx)};
if (const Result result{network_system_clock_core.GetClockContext(system, ctx)};
result != ResultSuccess) {
return result;
}

10
src/core/hle/service/time/standard_user_system_clock_core.h
View file

@ -28,9 +28,9 @@ public:
~StandardUserSystemClockCore() override;
ResultCode SetAutomaticCorrectionEnabled(Core::System& system, bool value);
Result SetAutomaticCorrectionEnabled(Core::System& system, bool value);
ResultCode GetClockContext(Core::System& system, SystemClockContext& ctx) const override;
Result GetClockContext(Core::System& system, SystemClockContext& ctx) const override;
bool IsAutomaticCorrectionEnabled() const {
return auto_correction_enabled;
@ -41,11 +41,11 @@ public:
}
protected:
ResultCode Flush(const SystemClockContext&) override;
Result Flush(const SystemClockContext&) override;
ResultCode SetClockContext(const SystemClockContext&) override;
Result SetClockContext(const SystemClockContext&) override;
ResultCode ApplyAutomaticCorrection(Core::System& system, bool value) const;
Result ApplyAutomaticCorrection(Core::System& system, bool value) const;
const SteadyClockTimePoint& GetAutomaticCorrectionUpdatedTime() const {
return auto_correction_time;

6
src/core/hle/service/time/system_clock_context_update_callback.cpp
View file

@ -30,8 +30,8 @@ void SystemClockContextUpdateCallback::BroadcastOperationEvent() {
}
}
ResultCode SystemClockContextUpdateCallback::Update(const SystemClockContext& value) {
ResultCode result{ResultSuccess};
Result SystemClockContextUpdateCallback::Update(const SystemClockContext& value) {
Result result{ResultSuccess};
if (NeedUpdate(value)) {
context = value;
@ -47,7 +47,7 @@ ResultCode SystemClockContextUpdateCallback::Update(const SystemClockContext& va
return result;
}
ResultCode SystemClockContextUpdateCallback::Update() {
Result SystemClockContextUpdateCallback::Update() {
return ResultSuccess;
}

4
src/core/hle/service/time/system_clock_context_update_callback.h
View file

@ -28,10 +28,10 @@ public:
void BroadcastOperationEvent();
ResultCode Update(const SystemClockContext& value);
Result Update(const SystemClockContext& value);
protected:
virtual ResultCode Update();
virtual Result Update();
SystemClockContext context{};

14
src/core/hle/service/time/system_clock_core.cpp
View file

@ -14,13 +14,13 @@ SystemClockCore::SystemClockCore(SteadyClockCore& steady_clock_core_)
SystemClockCore::~SystemClockCore() = default;
ResultCode SystemClockCore::GetCurrentTime(Core::System& system, s64& posix_time) const {
Result SystemClockCore::GetCurrentTime(Core::System& system, s64& posix_time) const {
posix_time = 0;
const SteadyClockTimePoint current_time_point{steady_clock_core.GetCurrentTimePoint(system)};
SystemClockContext clock_context{};
if (const ResultCode result{GetClockContext(system, clock_context)}; result != ResultSuccess) {
if (const Result result{GetClockContext(system, clock_context)}; result != ResultSuccess) {
return result;
}
@ -33,26 +33,26 @@ ResultCode SystemClockCore::GetCurrentTime(Core::System& system, s64& posix_time
return ResultSuccess;
}
ResultCode SystemClockCore::SetCurrentTime(Core::System& system, s64 posix_time) {
Result SystemClockCore::SetCurrentTime(Core::System& system, s64 posix_time) {
const SteadyClockTimePoint current_time_point{steady_clock_core.GetCurrentTimePoint(system)};
const SystemClockContext clock_context{posix_time - current_time_point.time_point,
current_time_point};
if (const ResultCode result{SetClockContext(clock_context)}; result != ResultSuccess) {
if (const Result result{SetClockContext(clock_context)}; result != ResultSuccess) {
return result;
}
return Flush(clock_context);
}
ResultCode SystemClockCore::Flush(const SystemClockContext& clock_context) {
Result SystemClockCore::Flush(const SystemClockContext& clock_context) {
if (!system_clock_context_update_callback) {
return ResultSuccess;
}
return system_clock_context_update_callback->Update(clock_context);
}
ResultCode SystemClockCore::SetSystemClockContext(const SystemClockContext& clock_context) {
if (const ResultCode result{SetClockContext(clock_context)}; result != ResultSuccess) {
Result SystemClockCore::SetSystemClockContext(const SystemClockContext& clock_context) {
if (const Result result{SetClockContext(clock_context)}; result != ResultSuccess) {
return result;
}
return Flush(clock_context);

14
src/core/hle/service/time/system_clock_core.h
View file

@ -29,28 +29,28 @@ public:
return steady_clock_core;
}
ResultCode GetCurrentTime(Core::System& system, s64& posix_time) const;
Result GetCurrentTime(Core::System& system, s64& posix_time) const;
ResultCode SetCurrentTime(Core::System& system, s64 posix_time);
Result SetCurrentTime(Core::System& system, s64 posix_time);
virtual ResultCode GetClockContext([[maybe_unused]] Core::System& system,
SystemClockContext& value) const {
virtual Result GetClockContext([[maybe_unused]] Core::System& system,
SystemClockContext& value) const {
value = context;
return ResultSuccess;
}
virtual ResultCode SetClockContext(const SystemClockContext& value) {
virtual Result SetClockContext(const SystemClockContext& value) {
context = value;
return ResultSuccess;
}
virtual ResultCode Flush(const SystemClockContext& clock_context);
virtual Result Flush(const SystemClockContext& clock_context);
void SetUpdateCallbackInstance(std::shared_ptr<SystemClockContextUpdateCallback> callback) {
system_clock_context_update_callback = std::move(callback);
}
ResultCode SetSystemClockContext(const SystemClockContext& context);
Result SetSystemClockContext(const SystemClockContext& context);
bool IsInitialized() const {
return is_initialized;

25
src/core/hle/service/time/time.cpp
View file

@ -43,8 +43,7 @@ private:
}
s64 posix_time{};
if (const ResultCode result{clock_core.GetCurrentTime(system, posix_time)};
result.IsError()) {
if (const Result result{clock_core.GetCurrentTime(system, posix_time)}; result.IsError()) {
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(result);
return;
@ -65,7 +64,7 @@ private:
}
Clock::SystemClockContext system_clock_context{};
if (const ResultCode result{clock_core.GetClockContext(system, system_clock_context)};
if (const Result result{clock_core.GetClockContext(system, system_clock_context)};
result.IsError()) {
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(result);
@ -116,7 +115,7 @@ private:
Clock::SteadyClockCore& clock_core;
};
ResultCode Module::Interface::GetClockSnapshotFromSystemClockContextInternal(
Result Module::Interface::GetClockSnapshotFromSystemClockContextInternal(
Kernel::KThread* thread, Clock::SystemClockContext user_context,
Clock::SystemClockContext network_context, Clock::TimeType type,
Clock::ClockSnapshot& clock_snapshot) {
@ -129,7 +128,7 @@ ResultCode Module::Interface::GetClockSnapshotFromSystemClockContextInternal(
time_manager.GetStandardUserSystemClockCore().IsAutomaticCorrectionEnabled();
clock_snapshot.type = type;
if (const ResultCode result{
if (const Result result{
time_manager.GetTimeZoneContentManager().GetTimeZoneManager().GetDeviceLocationName(
clock_snapshot.location_name)};
result != ResultSuccess) {
@ -138,7 +137,7 @@ ResultCode Module::Interface::GetClockSnapshotFromSystemClockContextInternal(
clock_snapshot.user_context = user_context;
if (const ResultCode result{Clock::ClockSnapshot::GetCurrentTime(
if (const Result result{Clock::ClockSnapshot::GetCurrentTime(
clock_snapshot.user_time, clock_snapshot.steady_clock_time_point,
clock_snapshot.user_context)};
result != ResultSuccess) {
@ -146,7 +145,7 @@ ResultCode Module::Interface::GetClockSnapshotFromSystemClockContextInternal(
}
TimeZone::CalendarInfo userCalendarInfo{};
if (const ResultCode result{
if (const Result result{
time_manager.GetTimeZoneContentManager().GetTimeZoneManager().ToCalendarTimeWithMyRules(
clock_snapshot.user_time, userCalendarInfo)};
result != ResultSuccess) {
@ -165,7 +164,7 @@ ResultCode Module::Interface::GetClockSnapshotFromSystemClockContextInternal(
}
TimeZone::CalendarInfo networkCalendarInfo{};
if (const ResultCode result{
if (const Result result{
time_manager.GetTimeZoneContentManager().GetTimeZoneManager().ToCalendarTimeWithMyRules(
clock_snapshot.network_time, networkCalendarInfo)};
result != ResultSuccess) {
@ -262,7 +261,7 @@ void Module::Interface::GetClockSnapshot(Kernel::HLERequestContext& ctx) {
LOG_DEBUG(Service_Time, "called, type={}", type);
Clock::SystemClockContext user_context{};
if (const ResultCode result{
if (const Result result{
system.GetTimeManager().GetStandardUserSystemClockCore().GetClockContext(system,
user_context)};
result.IsError()) {
@ -272,7 +271,7 @@ void Module::Interface::GetClockSnapshot(Kernel::HLERequestContext& ctx) {
}
Clock::SystemClockContext network_context{};
if (const ResultCode result{
if (const Result result{
system.GetTimeManager().GetStandardNetworkSystemClockCore().GetClockContext(
system, network_context)};
result.IsError()) {
@ -282,7 +281,7 @@ void Module::Interface::GetClockSnapshot(Kernel::HLERequestContext& ctx) {
}
Clock::ClockSnapshot clock_snapshot{};
if (const ResultCode result{GetClockSnapshotFromSystemClockContextInternal(
if (const Result result{GetClockSnapshotFromSystemClockContextInternal(
&ctx.GetThread(), user_context, network_context, type, clock_snapshot)};
result.IsError()) {
IPC::ResponseBuilder rb{ctx, 2};
@ -308,7 +307,7 @@ void Module::Interface::GetClockSnapshotFromSystemClockContext(Kernel::HLEReques
LOG_DEBUG(Service_Time, "called, type={}", type);
Clock::ClockSnapshot clock_snapshot{};
if (const ResultCode result{GetClockSnapshotFromSystemClockContextInternal(
if (const Result result{GetClockSnapshotFromSystemClockContextInternal(
&ctx.GetThread(), user_context, network_context, type, clock_snapshot)};
result != ResultSuccess) {
IPC::ResponseBuilder rb{ctx, 2};
@ -365,7 +364,7 @@ void Module::Interface::CalculateSpanBetween(Kernel::HLERequestContext& ctx) {
Clock::TimeSpanType time_span_type{};
s64 span{};
if (const ResultCode result{snapshot_a.steady_clock_time_point.GetSpanBetween(
if (const Result result{snapshot_a.steady_clock_time_point.GetSpanBetween(
snapshot_b.steady_clock_time_point, span)};
result != ResultSuccess) {
if (snapshot_a.network_time && snapshot_b.network_time) {

2
src/core/hle/service/time/time.h
View file

@ -36,7 +36,7 @@ public:
void GetSharedMemoryNativeHandle(Kernel::HLERequestContext& ctx);
private:
ResultCode GetClockSnapshotFromSystemClockContextInternal(
Result GetClockSnapshotFromSystemClockContextInternal(
Kernel::KThread* thread, Clock::SystemClockContext user_context,
Clock::SystemClockContext network_context, Clock::TimeType type,
Clock::ClockSnapshot& cloc_snapshot);

10
src/core/hle/service/time/time_zone_content_manager.cpp
View file

@ -90,10 +90,10 @@ void TimeZoneContentManager::Initialize(TimeManager& time_manager) {
}
}
ResultCode TimeZoneContentManager::LoadTimeZoneRule(TimeZoneRule& rules,
const std::string& location_name) const {
Result TimeZoneContentManager::LoadTimeZoneRule(TimeZoneRule& rules,
const std::string& location_name) const {
FileSys::VirtualFile vfs_file;
if (const ResultCode result{GetTimeZoneInfoFile(location_name, vfs_file)};
if (const Result result{GetTimeZoneInfoFile(location_name, vfs_file)};
result != ResultSuccess) {
return result;
}
@ -106,8 +106,8 @@ bool TimeZoneContentManager::IsLocationNameValid(const std::string& location_nam
location_name_cache.end();
}
ResultCode TimeZoneContentManager::GetTimeZoneInfoFile(const std::string& location_name,
FileSys::VirtualFile& vfs_file) const {
Result TimeZoneContentManager::GetTimeZoneInfoFile(const std::string& location_name,
FileSys::VirtualFile& vfs_file) const {
if (!IsLocationNameValid(location_name)) {
return ERROR_TIME_NOT_FOUND;
}

6
src/core/hle/service/time/time_zone_content_manager.h
View file

@ -32,12 +32,12 @@ public:
return time_zone_manager;
}
ResultCode LoadTimeZoneRule(TimeZoneRule& rules, const std::string& location_name) const;
Result LoadTimeZoneRule(TimeZoneRule& rules, const std::string& location_name) const;
private:
bool IsLocationNameValid(const std::string& location_name) const;
ResultCode GetTimeZoneInfoFile(const std::string& location_name,
FileSys::VirtualFile& vfs_file) const;
Result GetTimeZoneInfoFile(const std::string& location_name,
FileSys::VirtualFile& vfs_file) const;
Core::System& system;
TimeZoneManager time_zone_manager;

46
src/core/hle/service/time/time_zone_manager.cpp
View file

@ -666,8 +666,8 @@ static bool ParseTimeZoneBinary(TimeZoneRule& time_zone_rule, FileSys::VirtualFi
return true;
}
static ResultCode CreateCalendarTime(s64 time, int gmt_offset, CalendarTimeInternal& calendar_time,
CalendarAdditionalInfo& calendar_additional_info) {
static Result CreateCalendarTime(s64 time, int gmt_offset, CalendarTimeInternal& calendar_time,
CalendarAdditionalInfo& calendar_additional_info) {
s64 year{epoch_year};
s64 time_days{time / seconds_per_day};
s64 remaining_seconds{time % seconds_per_day};
@ -741,9 +741,9 @@ static ResultCode CreateCalendarTime(s64 time, int gmt_offset, CalendarTimeInter
return ResultSuccess;
}
static ResultCode ToCalendarTimeInternal(const TimeZoneRule& rules, s64 time,
CalendarTimeInternal& calendar_time,
CalendarAdditionalInfo& calendar_additional_info) {
static Result ToCalendarTimeInternal(const TimeZoneRule& rules, s64 time,
CalendarTimeInternal& calendar_time,
CalendarAdditionalInfo& calendar_additional_info) {
if ((rules.go_ahead && time < rules.ats[0]) ||
(rules.go_back && time > rules.ats[rules.time_count - 1])) {
s64 seconds{};
@ -766,7 +766,7 @@ static ResultCode ToCalendarTimeInternal(const TimeZoneRule& rules, s64 time,
if (new_time < rules.ats[0] && new_time > rules.ats[rules.time_count - 1]) {
return ERROR_TIME_NOT_FOUND;
}
if (const ResultCode result{
if (const Result result{
ToCalendarTimeInternal(rules, new_time, calendar_time, calendar_additional_info)};
result != ResultSuccess) {
return result;
@ -797,8 +797,8 @@ static ResultCode ToCalendarTimeInternal(const TimeZoneRule& rules, s64 time,
tti_index = rules.types[low - 1];
}
if (const ResultCode result{CreateCalendarTime(time, rules.ttis[tti_index].gmt_offset,
calendar_time, calendar_additional_info)};
if (const Result result{CreateCalendarTime(time, rules.ttis[tti_index].gmt_offset,
calendar_time, calendar_additional_info)};
result != ResultSuccess) {
return result;
}
@ -811,9 +811,9 @@ static ResultCode ToCalendarTimeInternal(const TimeZoneRule& rules, s64 time,
return ResultSuccess;
}
static ResultCode ToCalendarTimeImpl(const TimeZoneRule& rules, s64 time, CalendarInfo& calendar) {
static Result ToCalendarTimeImpl(const TimeZoneRule& rules, s64 time, CalendarInfo& calendar) {
CalendarTimeInternal calendar_time{};
const ResultCode result{
const Result result{
ToCalendarTimeInternal(rules, time, calendar_time, calendar.additional_info)};
calendar.time.year = static_cast<s16>(calendar_time.year);
@ -830,13 +830,13 @@ static ResultCode ToCalendarTimeImpl(const TimeZoneRule& rules, s64 time, Calend
TimeZoneManager::TimeZoneManager() = default;
TimeZoneManager::~TimeZoneManager() = default;
ResultCode TimeZoneManager::ToCalendarTime(const TimeZoneRule& rules, s64 time,
CalendarInfo& calendar) const {
Result TimeZoneManager::ToCalendarTime(const TimeZoneRule& rules, s64 time,
CalendarInfo& calendar) const {
return ToCalendarTimeImpl(rules, time, calendar);
}
ResultCode TimeZoneManager::SetDeviceLocationNameWithTimeZoneRule(const std::string& location_name,
FileSys::VirtualFile& vfs_file) {
Result TimeZoneManager::SetDeviceLocationNameWithTimeZoneRule(const std::string& location_name,
FileSys::VirtualFile& vfs_file) {
TimeZoneRule rule{};
if (ParseTimeZoneBinary(rule, vfs_file)) {
device_location_name = location_name;
@ -846,12 +846,12 @@ ResultCode TimeZoneManager::SetDeviceLocationNameWithTimeZoneRule(const std::str
return ERROR_TIME_ZONE_CONVERSION_FAILED;
}
ResultCode TimeZoneManager::SetUpdatedTime(const Clock::SteadyClockTimePoint& value) {
Result TimeZoneManager::SetUpdatedTime(const Clock::SteadyClockTimePoint& value) {
time_zone_update_time_point = value;
return ResultSuccess;
}
ResultCode TimeZoneManager::ToCalendarTimeWithMyRules(s64 time, CalendarInfo& calendar) const {
Result TimeZoneManager::ToCalendarTimeWithMyRules(s64 time, CalendarInfo& calendar) const {
if (is_initialized) {
return ToCalendarTime(time_zone_rule, time, calendar);
} else {
@ -859,16 +859,16 @@ ResultCode TimeZoneManager::ToCalendarTimeWithMyRules(s64 time, CalendarInfo& ca
}
}
ResultCode TimeZoneManager::ParseTimeZoneRuleBinary(TimeZoneRule& rules,
FileSys::VirtualFile& vfs_file) const {
Result TimeZoneManager::ParseTimeZoneRuleBinary(TimeZoneRule& rules,
FileSys::VirtualFile& vfs_file) const {
if (!ParseTimeZoneBinary(rules, vfs_file)) {
return ERROR_TIME_ZONE_CONVERSION_FAILED;
}
return ResultSuccess;
}
ResultCode TimeZoneManager::ToPosixTime(const TimeZoneRule& rules,
const CalendarTime& calendar_time, s64& posix_time) const {
Result TimeZoneManager::ToPosixTime(const TimeZoneRule& rules, const CalendarTime& calendar_time,
s64& posix_time) const {
posix_time = 0;
CalendarTimeInternal internal_time{
@ -1020,8 +1020,8 @@ ResultCode TimeZoneManager::ToPosixTime(const TimeZoneRule& rules,
return ResultSuccess;
}
ResultCode TimeZoneManager::ToPosixTimeWithMyRule(const CalendarTime& calendar_time,
s64& posix_time) const {
Result TimeZoneManager::ToPosixTimeWithMyRule(const CalendarTime& calendar_time,
s64& posix_time) const {
if (is_initialized) {
return ToPosixTime(time_zone_rule, calendar_time, posix_time);
}
@ -1029,7 +1029,7 @@ ResultCode TimeZoneManager::ToPosixTimeWithMyRule(const CalendarTime& calendar_t
return ERROR_UNINITIALIZED_CLOCK;
}
ResultCode TimeZoneManager::GetDeviceLocationName(LocationName& value) const {
Result TimeZoneManager::GetDeviceLocationName(LocationName& value) const {
if (!is_initialized) {
return ERROR_UNINITIALIZED_CLOCK;
}

20
src/core/hle/service/time/time_zone_manager.h
View file

@ -29,16 +29,16 @@ public:
is_initialized = true;
}
ResultCode SetDeviceLocationNameWithTimeZoneRule(const std::string& location_name,
FileSys::VirtualFile& vfs_file);
ResultCode SetUpdatedTime(const Clock::SteadyClockTimePoint& value);
ResultCode GetDeviceLocationName(TimeZone::LocationName& value) const;
ResultCode ToCalendarTime(const TimeZoneRule& rules, s64 time, CalendarInfo& calendar) const;
ResultCode ToCalendarTimeWithMyRules(s64 time, CalendarInfo& calendar) const;
ResultCode ParseTimeZoneRuleBinary(TimeZoneRule& rules, FileSys::VirtualFile& vfs_file) const;
ResultCode ToPosixTime(const TimeZoneRule& rules, const CalendarTime& calendar_time,
s64& posix_time) const;
ResultCode ToPosixTimeWithMyRule(const CalendarTime& calendar_time, s64& posix_time) const;
Result SetDeviceLocationNameWithTimeZoneRule(const std::string& location_name,
FileSys::VirtualFile& vfs_file);
Result SetUpdatedTime(const Clock::SteadyClockTimePoint& value);
Result GetDeviceLocationName(TimeZone::LocationName& value) const;
Result ToCalendarTime(const TimeZoneRule& rules, s64 time, CalendarInfo& calendar) const;
Result ToCalendarTimeWithMyRules(s64 time, CalendarInfo& calendar) const;
Result ParseTimeZoneRuleBinary(TimeZoneRule& rules, FileSys::VirtualFile& vfs_file) const;
Result ToPosixTime(const TimeZoneRule& rules, const CalendarTime& calendar_time,
s64& posix_time) const;
Result ToPosixTimeWithMyRule(const CalendarTime& calendar_time, s64& posix_time) const;
private:
bool is_initialized{};

15
src/core/hle/service/time/time_zone_service.cpp
View file

@ -32,7 +32,7 @@ void ITimeZoneService::GetDeviceLocationName(Kernel::HLERequestContext& ctx) {
LOG_DEBUG(Service_Time, "called");
TimeZone::LocationName location_name{};
if (const ResultCode result{
if (const Result result{
time_zone_content_manager.GetTimeZoneManager().GetDeviceLocationName(location_name)};
result != ResultSuccess) {
IPC::ResponseBuilder rb{ctx, 2};
@ -61,7 +61,7 @@ void ITimeZoneService::LoadTimeZoneRule(Kernel::HLERequestContext& ctx) {
LOG_DEBUG(Service_Time, "called, location_name={}", location_name);
TimeZone::TimeZoneRule time_zone_rule{};
if (const ResultCode result{
if (const Result result{
time_zone_content_manager.LoadTimeZoneRule(time_zone_rule, location_name)};
result != ResultSuccess) {
IPC::ResponseBuilder rb{ctx, 2};
@ -88,7 +88,7 @@ void ITimeZoneService::ToCalendarTime(Kernel::HLERequestContext& ctx) {
std::memcpy(&time_zone_rule, buffer.data(), buffer.size());
TimeZone::CalendarInfo calendar_info{};
if (const ResultCode result{time_zone_content_manager.GetTimeZoneManager().ToCalendarTime(
if (const Result result{time_zone_content_manager.GetTimeZoneManager().ToCalendarTime(
time_zone_rule, posix_time, calendar_info)};
result != ResultSuccess) {
IPC::ResponseBuilder rb{ctx, 2};
@ -108,7 +108,7 @@ void ITimeZoneService::ToCalendarTimeWithMyRule(Kernel::HLERequestContext& ctx)
LOG_DEBUG(Service_Time, "called, posix_time=0x{:016X}", posix_time);
TimeZone::CalendarInfo calendar_info{};
if (const ResultCode result{
if (const Result result{
time_zone_content_manager.GetTimeZoneManager().ToCalendarTimeWithMyRules(
posix_time, calendar_info)};
result != ResultSuccess) {
@ -131,7 +131,7 @@ void ITimeZoneService::ToPosixTime(Kernel::HLERequestContext& ctx) {
std::memcpy(&time_zone_rule, ctx.ReadBuffer().data(), sizeof(TimeZone::TimeZoneRule));
s64 posix_time{};
if (const ResultCode result{time_zone_content_manager.GetTimeZoneManager().ToPosixTime(
if (const Result result{time_zone_content_manager.GetTimeZoneManager().ToPosixTime(
time_zone_rule, calendar_time, posix_time)};
result != ResultSuccess) {
IPC::ResponseBuilder rb{ctx, 2};
@ -154,9 +154,8 @@ void ITimeZoneService::ToPosixTimeWithMyRule(Kernel::HLERequestContext& ctx) {
const auto calendar_time{rp.PopRaw<TimeZone::CalendarTime>()};
s64 posix_time{};
if (const ResultCode result{
time_zone_content_manager.GetTimeZoneManager().ToPosixTimeWithMyRule(calendar_time,
posix_time)};
if (const Result result{time_zone_content_manager.GetTimeZoneManager().ToPosixTimeWithMyRule(
calendar_time, posix_time)};
result != ResultSuccess) {
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(result);