From a9ace6856de57f1124daaa77aacd6f36a64c68f7 Mon Sep 17 00:00:00 2001
From: Liam <byteslice@airmail.cc>
Date: Wed, 12 Oct 2022 20:26:04 -0400
Subject: kernel: remove KWritableEvent

---
 src/core/hle/kernel/k_event.cpp | 44 +++++++++++++++++++++++------------------
 1 file changed, 25 insertions(+), 19 deletions(-)

(limited to 'src/core/hle/kernel/k_event.cpp')

diff --git a/src/core/hle/kernel/k_event.cpp b/src/core/hle/kernel/k_event.cpp
index e52fafbc7..78ca59463 100644
--- a/src/core/hle/kernel/k_event.cpp
+++ b/src/core/hle/kernel/k_event.cpp
@@ -8,39 +8,45 @@
 namespace Kernel {
 
 KEvent::KEvent(KernelCore& kernel_)
-    : KAutoObjectWithSlabHeapAndContainer{kernel_}, readable_event{kernel_}, writable_event{
-                                                                                 kernel_} {}
+    : KAutoObjectWithSlabHeapAndContainer{kernel_}, m_readable_event{kernel_} {}
 
 KEvent::~KEvent() = default;
 
-void KEvent::Initialize(std::string&& name_, KProcess* owner_) {
-    // Increment reference count.
-    // Because reference count is one on creation, this will result
-    // in a reference count of two. Thus, when both readable and
-    // writable events are closed this object will be destroyed.
-    Open();
+void KEvent::Initialize(KProcess* owner) {
+    // Create our readable event.
+    KAutoObject::Create(std::addressof(m_readable_event));
 
-    // Create our sub events.
-    KAutoObject::Create(std::addressof(readable_event));
-    KAutoObject::Create(std::addressof(writable_event));
-
-    // Initialize our sub sessions.
-    readable_event.Initialize(this, name_ + ":Readable");
-    writable_event.Initialize(this, name_ + ":Writable");
+    // Initialize our readable event.
+    m_readable_event.Initialize(this);
 
     // Set our owner process.
-    owner = owner_;
-    owner->Open();
+    m_owner = owner;
+    m_owner->Open();
 
     // Mark initialized.
-    name = std::move(name_);
-    initialized = true;
+    m_initialized = true;
 }
 
 void KEvent::Finalize() {
     KAutoObjectWithSlabHeapAndContainer<KEvent, KAutoObjectWithList>::Finalize();
 }
 
+Result KEvent::Signal() {
+    KScopedSchedulerLock sl{kernel};
+
+    R_SUCCEED_IF(m_readable_event_destroyed);
+
+    return m_readable_event.Signal();
+}
+
+Result KEvent::Clear() {
+    KScopedSchedulerLock sl{kernel};
+
+    R_SUCCEED_IF(m_readable_event_destroyed);
+
+    return m_readable_event.Clear();
+}
+
 void KEvent::PostDestroy(uintptr_t arg) {
     // Release the event count resource the owner process holds.
     KProcess* owner = reinterpret_cast<KProcess*>(arg);
-- 
cgit v1.2.3