From 3271099fea41d5adc0003c02c8481b334772296a Mon Sep 17 00:00:00 2001
From: Morph <39850852+Morph1984@users.noreply.github.com>
Date: Fri, 4 Feb 2022 23:44:02 -0500
Subject: common: Implement NewUUID

This is a fixed and revised implementation of UUID that uses an array of bytes as its internal representation of a UUID instead of a u128 (which was an array of 2 u64s).
In addition to this, the generation of RFC 4122 Version 4 compliant UUIDs is also implemented.
---
 src/common/CMakeLists.txt |   2 +
 src/common/new_uuid.cpp   | 182 ++++++++++++++++++++++++++++++++++++++++++++++
 src/common/new_uuid.h     | 138 +++++++++++++++++++++++++++++++++++
 3 files changed, 322 insertions(+)
 create mode 100644 src/common/new_uuid.cpp
 create mode 100644 src/common/new_uuid.h

(limited to 'src')

diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
index adf70eb8b..3dd460191 100644
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -99,6 +99,8 @@ add_library(common STATIC
     microprofile.cpp
     microprofile.h
     microprofileui.h
+    new_uuid.cpp
+    new_uuid.h
     nvidia_flags.cpp
     nvidia_flags.h
     page_table.cpp
diff --git a/src/common/new_uuid.cpp b/src/common/new_uuid.cpp
new file mode 100644
index 000000000..0442681c8
--- /dev/null
+++ b/src/common/new_uuid.cpp
@@ -0,0 +1,182 @@
+// Copyright 2022 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <bit>
+#include <random>
+
+#include <fmt/format.h>
+
+#include "common/assert.h"
+#include "common/new_uuid.h"
+#include "common/tiny_mt.h"
+
+namespace Common {
+
+namespace {
+
+constexpr size_t RawStringSize = sizeof(NewUUID) * 2;
+constexpr size_t FormattedStringSize = RawStringSize + 4;
+
+u8 HexCharToByte(char c) {
+    if (c >= '0' && c <= '9') {
+        return static_cast<u8>(c - '0');
+    }
+    if (c >= 'a' && c <= 'f') {
+        return static_cast<u8>(c - 'a' + 10);
+    }
+    if (c >= 'A' && c <= 'F') {
+        return static_cast<u8>(c - 'A' + 10);
+    }
+    ASSERT_MSG(false, "{} is not a hexadecimal digit!", c);
+    return u8{0};
+}
+
+std::array<u8, 0x10> ConstructFromRawString(std::string_view raw_string) {
+    std::array<u8, 0x10> uuid;
+
+    for (size_t i = 0; i < RawStringSize; i += 2) {
+        uuid[i / 2] =
+            static_cast<u8>((HexCharToByte(raw_string[i]) << 4) | HexCharToByte(raw_string[i + 1]));
+    }
+
+    return uuid;
+}
+
+std::array<u8, 0x10> ConstructFromFormattedString(std::string_view formatted_string) {
+    std::array<u8, 0x10> uuid;
+
+    size_t i = 0;
+
+    // Process the first 8 characters.
+    const auto* str = formatted_string.data();
+
+    for (; i < 4; ++i) {
+        uuid[i] = static_cast<u8>((HexCharToByte(*(str++)) << 4));
+        uuid[i] |= HexCharToByte(*(str++));
+    }
+
+    // Process the next 4 characters.
+    ++str;
+
+    for (; i < 6; ++i) {
+        uuid[i] = static_cast<u8>((HexCharToByte(*(str++)) << 4));
+        uuid[i] |= HexCharToByte(*(str++));
+    }
+
+    // Process the next 4 characters.
+    ++str;
+
+    for (; i < 8; ++i) {
+        uuid[i] = static_cast<u8>((HexCharToByte(*(str++)) << 4));
+        uuid[i] |= HexCharToByte(*(str++));
+    }
+
+    // Process the next 4 characters.
+    ++str;
+
+    for (; i < 10; ++i) {
+        uuid[i] = static_cast<u8>((HexCharToByte(*(str++)) << 4));
+        uuid[i] |= HexCharToByte(*(str++));
+    }
+
+    // Process the last 12 characters.
+    ++str;
+
+    for (; i < 16; ++i) {
+        uuid[i] = static_cast<u8>((HexCharToByte(*(str++)) << 4));
+        uuid[i] |= HexCharToByte(*(str++));
+    }
+
+    return uuid;
+}
+
+std::array<u8, 0x10> ConstructUUID(std::string_view uuid_string) {
+    const auto length = uuid_string.length();
+
+    if (length == 0) {
+        return {};
+    }
+
+    // Check if the input string contains 32 hexadecimal characters.
+    if (length == RawStringSize) {
+        return ConstructFromRawString(uuid_string);
+    }
+
+    // Check if the input string has the length of a RFC 4122 formatted UUID string.
+    if (length == FormattedStringSize) {
+        return ConstructFromFormattedString(uuid_string);
+    }
+
+    ASSERT_MSG(false, "UUID string has an invalid length of {} characters!", length);
+
+    return {};
+}
+
+} // Anonymous namespace
+
+NewUUID::NewUUID(std::string_view uuid_string) : uuid{ConstructUUID(uuid_string)} {}
+
+std::string NewUUID::RawString() const {
+    return fmt::format("{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}"
+                       "{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}",
+                       uuid[0], uuid[1], uuid[2], uuid[3], uuid[4], uuid[5], uuid[6], uuid[7],
+                       uuid[8], uuid[9], uuid[10], uuid[11], uuid[12], uuid[13], uuid[14],
+                       uuid[15]);
+}
+
+std::string NewUUID::FormattedString() const {
+    return fmt::format("{:02x}{:02x}{:02x}{:02x}"
+                       "-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-"
+                       "{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}",
+                       uuid[0], uuid[1], uuid[2], uuid[3], uuid[4], uuid[5], uuid[6], uuid[7],
+                       uuid[8], uuid[9], uuid[10], uuid[11], uuid[12], uuid[13], uuid[14],
+                       uuid[15]);
+}
+
+size_t NewUUID::Hash() const noexcept {
+    u64 hash;
+    u64 temp;
+
+    std::memcpy(&hash, uuid.data(), sizeof(u64));
+    std::memcpy(&temp, uuid.data() + 8, sizeof(u64));
+
+    return hash ^ std::rotl(temp, 1);
+}
+
+NewUUID NewUUID::MakeRandom() {
+    std::random_device device;
+
+    return MakeRandomWithSeed(device());
+}
+
+NewUUID NewUUID::MakeRandomWithSeed(u32 seed) {
+    // Create and initialize our RNG.
+    TinyMT rng;
+    rng.Initialize(seed);
+
+    NewUUID uuid;
+
+    // Populate the UUID with random bytes.
+    rng.GenerateRandomBytes(uuid.uuid.data(), sizeof(NewUUID));
+
+    return uuid;
+}
+
+NewUUID NewUUID::MakeRandomRFC4122V4() {
+    auto uuid = MakeRandom();
+
+    // According to Proposed Standard RFC 4122 Section 4.4, we must:
+
+    // 1. Set the two most significant bits (bits 6 and 7) of the
+    //    clock_seq_hi_and_reserved to zero and one, respectively.
+    uuid.uuid[8] = 0x80 | (uuid.uuid[8] & 0x3F);
+
+    // 2. Set the four most significant bits (bits 12 through 15) of the
+    //    time_hi_and_version field to the 4-bit version number from Section 4.1.3.
+    uuid.uuid[6] = 0x40 | (uuid.uuid[6] & 0xF);
+
+    return uuid;
+}
+
+} // namespace Common
diff --git a/src/common/new_uuid.h b/src/common/new_uuid.h
new file mode 100644
index 000000000..bd4468ad2
--- /dev/null
+++ b/src/common/new_uuid.h
@@ -0,0 +1,138 @@
+// Copyright 2022 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <functional>
+#include <string>
+#include <string_view>
+
+#include "common/common_types.h"
+
+namespace Common {
+
+struct NewUUID {
+    std::array<u8, 0x10> uuid{};
+
+    /// Constructs an invalid UUID.
+    constexpr NewUUID() = default;
+
+    /// Constructs a UUID from a reference to a 128 bit array.
+    constexpr explicit NewUUID(const std::array<u8, 16>& uuid_) : uuid{uuid_} {}
+
+    /**
+     * Constructs a UUID from either:
+     * 1. A 32 hexadecimal character string representing the bytes of the UUID
+     * 2. A RFC 4122 formatted UUID string, in the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+     *
+     * The input string may contain uppercase or lowercase characters, but they must:
+     * 1. Contain valid hexadecimal characters (0-9, a-f, A-F)
+     * 2. Not contain the "0x" hexadecimal prefix
+     *
+     * Should the input string not meet the above requirements,
+     * an assert will be triggered and an invalid UUID is set instead.
+     */
+    explicit NewUUID(std::string_view uuid_string);
+
+    ~NewUUID() = default;
+
+    constexpr NewUUID(const NewUUID&) noexcept = default;
+    constexpr NewUUID(NewUUID&&) noexcept = default;
+
+    constexpr NewUUID& operator=(const NewUUID&) noexcept = default;
+    constexpr NewUUID& operator=(NewUUID&&) noexcept = default;
+
+    /**
+     * Returns whether the stored UUID is valid or not.
+     *
+     * @returns True if the stored UUID is valid, false otherwise.
+     */
+    constexpr bool IsValid() const {
+        return uuid != std::array<u8, 0x10>{};
+    }
+
+    /**
+     * Returns whether the stored UUID is invalid or not.
+     *
+     * @returns True if the stored UUID is invalid, false otherwise.
+     */
+    constexpr bool IsInvalid() const {
+        return !IsValid();
+    }
+
+    /**
+     * Returns a 32 hexadecimal character string representing the bytes of the UUID.
+     *
+     * @returns A 32 hexadecimal character string of the UUID.
+     */
+    std::string RawString() const;
+
+    /**
+     * Returns a RFC 4122 formatted UUID string in the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
+     *
+     * @returns A RFC 4122 formatted UUID string.
+     */
+    std::string FormattedString() const;
+
+    /**
+     * Returns a 64-bit hash of the UUID for use in hash table data structures.
+     *
+     * @returns A 64-bit hash of the UUID.
+     */
+    size_t Hash() const noexcept;
+
+    /**
+     * Creates a default UUID "yuzu Default UID".
+     *
+     * @returns A UUID with its bytes set to the ASCII values of "yuzu Default UID".
+     */
+    static constexpr NewUUID MakeDefault() {
+        return NewUUID{
+            {'y', 'u', 'z', 'u', ' ', 'D', 'e', 'f', 'a', 'u', 'l', 't', ' ', 'U', 'I', 'D'},
+        };
+    }
+
+    /**
+     * Creates a random UUID.
+     *
+     * @returns A random UUID.
+     */
+    static NewUUID MakeRandom();
+
+    /**
+     * Creates a random UUID with a seed.
+     *
+     * @param seed A seed to initialize the Mersenne-Twister RNG
+     *
+     * @returns A random UUID.
+     */
+    static NewUUID MakeRandomWithSeed(u32 seed);
+
+    /**
+     * Creates a random UUID. The generated UUID is RFC 4122 Version 4 compliant.
+     *
+     * @returns A random UUID that is RFC 4122 Version 4 compliant.
+     */
+    static NewUUID MakeRandomRFC4122V4();
+
+    friend constexpr bool operator==(const NewUUID& lhs, const NewUUID& rhs) = default;
+};
+static_assert(sizeof(NewUUID) == 0x10, "UUID has incorrect size.");
+
+/// An invalid UUID. This UUID has all its bytes set to 0.
+constexpr NewUUID InvalidUUID = {};
+
+} // namespace Common
+
+namespace std {
+
+template <>
+struct hash<Common::NewUUID> {
+    size_t operator()(const Common::NewUUID& uuid) const noexcept {
+        return uuid.Hash();
+    }
+};
+
+} // namespace std
-- 
cgit v1.2.3


From cb30fe50cd074fe05dd1d6e4b0d58116d3d98489 Mon Sep 17 00:00:00 2001
From: Morph <39850852+Morph1984@users.noreply.github.com>
Date: Sat, 5 Feb 2022 00:40:28 -0500
Subject: input/hid: Migrate to the new UUID implementation

---
 src/common/input.h                        |  8 ++++----
 src/core/hid/emulated_controller.cpp      | 23 ++++++++++++-----------
 src/core/hid/emulated_controller.h        |  6 +++---
 src/core/hid/hid_types.h                  |  2 +-
 src/input_common/drivers/gc_adapter.cpp   |  2 +-
 src/input_common/drivers/keyboard.cpp     |  6 +++---
 src/input_common/drivers/mouse.cpp        |  2 +-
 src/input_common/drivers/sdl_driver.cpp   |  6 +++---
 src/input_common/drivers/tas_input.cpp    |  4 ++--
 src/input_common/drivers/touch_screen.cpp |  2 +-
 src/input_common/drivers/udp_client.cpp   |  8 ++++----
 src/input_common/drivers/udp_client.h     |  4 ++--
 src/input_common/input_engine.cpp         | 10 +++++-----
 src/input_common/input_engine.h           |  6 +++---
 src/input_common/input_mapping.cpp        |  6 +++---
 src/input_common/input_poller.cpp         | 18 +++++++++---------
 16 files changed, 57 insertions(+), 56 deletions(-)

(limited to 'src')

diff --git a/src/common/input.h b/src/common/input.h
index 54fcb24b0..95d30497d 100644
--- a/src/common/input.h
+++ b/src/common/input.h
@@ -10,8 +10,8 @@
 #include <unordered_map>
 #include <utility>
 #include "common/logging/log.h"
+#include "common/new_uuid.h"
 #include "common/param_package.h"
-#include "common/uuid.h"
 
 namespace Common::Input {
 
@@ -97,7 +97,7 @@ struct AnalogStatus {
 
 // Button data
 struct ButtonStatus {
-    Common::UUID uuid{};
+    Common::NewUUID uuid{};
     bool value{};
     bool inverted{};
     bool toggle{};
@@ -109,7 +109,7 @@ using BatteryStatus = BatteryLevel;
 
 // Analog and digital joystick data
 struct StickStatus {
-    Common::UUID uuid{};
+    Common::NewUUID uuid{};
     AnalogStatus x{};
     AnalogStatus y{};
     bool left{};
@@ -120,7 +120,7 @@ struct StickStatus {
 
 // Analog and digital trigger data
 struct TriggerStatus {
-    Common::UUID uuid{};
+    Common::NewUUID uuid{};
     AnalogStatus analog{};
     ButtonStatus pressed{};
 };
diff --git a/src/core/hid/emulated_controller.cpp b/src/core/hid/emulated_controller.cpp
index a7cdf45e6..44e9f22b9 100644
--- a/src/core/hid/emulated_controller.cpp
+++ b/src/core/hid/emulated_controller.cpp
@@ -204,7 +204,7 @@ void EmulatedController::ReloadInput() {
         if (!button_devices[index]) {
             continue;
         }
-        const auto uuid = Common::UUID{button_params[index].Get("guid", "")};
+        const auto uuid = Common::NewUUID{button_params[index].Get("guid", "")};
         button_devices[index]->SetCallback({
             .on_change =
                 [this, index, uuid](const Common::Input::CallbackStatus& callback) {
@@ -218,7 +218,7 @@ void EmulatedController::ReloadInput() {
         if (!stick_devices[index]) {
             continue;
         }
-        const auto uuid = Common::UUID{stick_params[index].Get("guid", "")};
+        const auto uuid = Common::NewUUID{stick_params[index].Get("guid", "")};
         stick_devices[index]->SetCallback({
             .on_change =
                 [this, index, uuid](const Common::Input::CallbackStatus& callback) {
@@ -232,7 +232,7 @@ void EmulatedController::ReloadInput() {
         if (!trigger_devices[index]) {
             continue;
         }
-        const auto uuid = Common::UUID{trigger_params[index].Get("guid", "")};
+        const auto uuid = Common::NewUUID{trigger_params[index].Get("guid", "")};
         trigger_devices[index]->SetCallback({
             .on_change =
                 [this, index, uuid](const Common::Input::CallbackStatus& callback) {
@@ -269,7 +269,8 @@ void EmulatedController::ReloadInput() {
     }
 
     // Use a common UUID for TAS
-    const auto tas_uuid = Common::UUID{0x0, 0x7A5};
+    static constexpr Common::NewUUID TAS_UUID = Common::NewUUID{
+        {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xA5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}};
 
     // Register TAS devices. No need to force update
     for (std::size_t index = 0; index < tas_button_devices.size(); ++index) {
@@ -278,8 +279,8 @@ void EmulatedController::ReloadInput() {
         }
         tas_button_devices[index]->SetCallback({
             .on_change =
-                [this, index, tas_uuid](const Common::Input::CallbackStatus& callback) {
-                    SetButton(callback, index, tas_uuid);
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetButton(callback, index, TAS_UUID);
                 },
         });
     }
@@ -290,8 +291,8 @@ void EmulatedController::ReloadInput() {
         }
         tas_stick_devices[index]->SetCallback({
             .on_change =
-                [this, index, tas_uuid](const Common::Input::CallbackStatus& callback) {
-                    SetStick(callback, index, tas_uuid);
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetStick(callback, index, TAS_UUID);
                 },
         });
     }
@@ -489,7 +490,7 @@ void EmulatedController::SetMotionParam(std::size_t index, Common::ParamPackage
 }
 
 void EmulatedController::SetButton(const Common::Input::CallbackStatus& callback, std::size_t index,
-                                   Common::UUID uuid) {
+                                   Common::NewUUID uuid) {
     if (index >= controller.button_values.size()) {
         return;
     }
@@ -638,7 +639,7 @@ void EmulatedController::SetButton(const Common::Input::CallbackStatus& callback
 }
 
 void EmulatedController::SetStick(const Common::Input::CallbackStatus& callback, std::size_t index,
-                                  Common::UUID uuid) {
+                                  Common::NewUUID uuid) {
     if (index >= controller.stick_values.size()) {
         return;
     }
@@ -688,7 +689,7 @@ void EmulatedController::SetStick(const Common::Input::CallbackStatus& callback,
 }
 
 void EmulatedController::SetTrigger(const Common::Input::CallbackStatus& callback,
-                                    std::size_t index, Common::UUID uuid) {
+                                    std::size_t index, Common::NewUUID uuid) {
     if (index >= controller.trigger_values.size()) {
         return;
     }
diff --git a/src/core/hid/emulated_controller.h b/src/core/hid/emulated_controller.h
index d8642c5b3..ed61e9522 100644
--- a/src/core/hid/emulated_controller.h
+++ b/src/core/hid/emulated_controller.h
@@ -354,7 +354,7 @@ private:
      * @param index Button ID of the to be updated
      */
     void SetButton(const Common::Input::CallbackStatus& callback, std::size_t index,
-                   Common::UUID uuid);
+                   Common::NewUUID uuid);
 
     /**
      * Updates the analog stick status of the controller
@@ -362,7 +362,7 @@ private:
      * @param index stick ID of the to be updated
      */
     void SetStick(const Common::Input::CallbackStatus& callback, std::size_t index,
-                  Common::UUID uuid);
+                  Common::NewUUID uuid);
 
     /**
      * Updates the trigger status of the controller
@@ -370,7 +370,7 @@ private:
      * @param index trigger ID of the to be updated
      */
     void SetTrigger(const Common::Input::CallbackStatus& callback, std::size_t index,
-                    Common::UUID uuid);
+                    Common::NewUUID uuid);
 
     /**
      * Updates the motion status of the controller
diff --git a/src/core/hid/hid_types.h b/src/core/hid/hid_types.h
index 778b328b9..a4ccdf11c 100644
--- a/src/core/hid/hid_types.h
+++ b/src/core/hid/hid_types.h
@@ -7,8 +7,8 @@
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "common/new_uuid.h"
 #include "common/point.h"
-#include "common/uuid.h"
 
 namespace Core::HID {
 
diff --git a/src/input_common/drivers/gc_adapter.cpp b/src/input_common/drivers/gc_adapter.cpp
index 7ab4540a8..7a269b526 100644
--- a/src/input_common/drivers/gc_adapter.cpp
+++ b/src/input_common/drivers/gc_adapter.cpp
@@ -248,7 +248,7 @@ bool GCAdapter::Setup() {
         std::size_t port = 0;
         for (GCController& pad : pads) {
             pad.identifier = {
-                .guid = Common::UUID{Common::INVALID_UUID},
+                .guid = Common::NewUUID{},
                 .port = port++,
                 .pad = 0,
             };
diff --git a/src/input_common/drivers/keyboard.cpp b/src/input_common/drivers/keyboard.cpp
index 4c1e5bbec..449509270 100644
--- a/src/input_common/drivers/keyboard.cpp
+++ b/src/input_common/drivers/keyboard.cpp
@@ -9,17 +9,17 @@
 namespace InputCommon {
 
 constexpr PadIdentifier key_identifier = {
-    .guid = Common::UUID{Common::INVALID_UUID},
+    .guid = Common::NewUUID{},
     .port = 0,
     .pad = 0,
 };
 constexpr PadIdentifier keyboard_key_identifier = {
-    .guid = Common::UUID{Common::INVALID_UUID},
+    .guid = Common::NewUUID{},
     .port = 1,
     .pad = 0,
 };
 constexpr PadIdentifier keyboard_modifier_identifier = {
-    .guid = Common::UUID{Common::INVALID_UUID},
+    .guid = Common::NewUUID{},
     .port = 1,
     .pad = 1,
 };
diff --git a/src/input_common/drivers/mouse.cpp b/src/input_common/drivers/mouse.cpp
index d8ae7f0c1..ae63088ba 100644
--- a/src/input_common/drivers/mouse.cpp
+++ b/src/input_common/drivers/mouse.cpp
@@ -20,7 +20,7 @@ constexpr int motion_wheel_y = 4;
 constexpr int touch_axis_x = 10;
 constexpr int touch_axis_y = 11;
 constexpr PadIdentifier identifier = {
-    .guid = Common::UUID{Common::INVALID_UUID},
+    .guid = Common::NewUUID{},
     .port = 0,
     .pad = 0,
 };
diff --git a/src/input_common/drivers/sdl_driver.cpp b/src/input_common/drivers/sdl_driver.cpp
index b031a8523..b9a8317d4 100644
--- a/src/input_common/drivers/sdl_driver.cpp
+++ b/src/input_common/drivers/sdl_driver.cpp
@@ -120,7 +120,7 @@ public:
      */
     const PadIdentifier GetPadIdentifier() const {
         return {
-            .guid = Common::UUID{guid},
+            .guid = Common::NewUUID{guid},
             .port = static_cast<std::size_t>(port),
             .pad = 0,
         };
@@ -502,7 +502,7 @@ std::vector<Common::ParamPackage> SDLDriver::GetInputDevices() const {
 Common::Input::VibrationError SDLDriver::SetRumble(
     const PadIdentifier& identifier, const Common::Input::VibrationStatus& vibration) {
     const auto joystick =
-        GetSDLJoystickByGUID(identifier.guid.Format(), static_cast<int>(identifier.port));
+        GetSDLJoystickByGUID(identifier.guid.RawString(), static_cast<int>(identifier.port));
     const auto process_amplitude_exp = [](f32 amplitude, f32 factor) {
         return (amplitude + std::pow(amplitude, factor)) * 0.5f * 0xFFFF;
     };
@@ -599,7 +599,7 @@ Common::ParamPackage SDLDriver::BuildParamPackageForAnalog(PadIdentifier identif
     Common::ParamPackage params;
     params.Set("engine", GetEngineName());
     params.Set("port", static_cast<int>(identifier.port));
-    params.Set("guid", identifier.guid.Format());
+    params.Set("guid", identifier.guid.RawString());
     params.Set("axis_x", axis_x);
     params.Set("axis_y", axis_y);
     params.Set("offset_x", offset_x);
diff --git a/src/input_common/drivers/tas_input.cpp b/src/input_common/drivers/tas_input.cpp
index 944e141bf..6d36cf5da 100644
--- a/src/input_common/drivers/tas_input.cpp
+++ b/src/input_common/drivers/tas_input.cpp
@@ -50,7 +50,7 @@ constexpr std::array<std::pair<std::string_view, TasButton>, 18> text_to_tas_but
 Tas::Tas(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
     for (size_t player_index = 0; player_index < PLAYER_NUMBER; player_index++) {
         PadIdentifier identifier{
-            .guid = Common::UUID{},
+            .guid = Common::NewUUID{},
             .port = player_index,
             .pad = 0,
         };
@@ -203,7 +203,7 @@ void Tas::UpdateThread() {
             }
 
             PadIdentifier identifier{
-                .guid = Common::UUID{},
+                .guid = Common::NewUUID{},
                 .port = player_index,
                 .pad = 0,
             };
diff --git a/src/input_common/drivers/touch_screen.cpp b/src/input_common/drivers/touch_screen.cpp
index 880781825..1030e74d9 100644
--- a/src/input_common/drivers/touch_screen.cpp
+++ b/src/input_common/drivers/touch_screen.cpp
@@ -8,7 +8,7 @@
 namespace InputCommon {
 
 constexpr PadIdentifier identifier = {
-    .guid = Common::UUID{Common::INVALID_UUID},
+    .guid = Common::NewUUID{},
     .port = 0,
     .pad = 0,
 };
diff --git a/src/input_common/drivers/udp_client.cpp b/src/input_common/drivers/udp_client.cpp
index 333173e3d..cbcfa7a4b 100644
--- a/src/input_common/drivers/udp_client.cpp
+++ b/src/input_common/drivers/udp_client.cpp
@@ -351,10 +351,10 @@ PadIdentifier UDPClient::GetPadIdentifier(std::size_t pad_index) const {
     };
 }
 
-Common::UUID UDPClient::GetHostUUID(const std::string& host) const {
+Common::NewUUID UDPClient::GetHostUUID(const std::string& host) const {
     const auto ip = boost::asio::ip::make_address_v4(host);
-    const auto hex_host = fmt::format("{:06x}", ip.to_uint());
-    return Common::UUID{hex_host};
+    const auto hex_host = fmt::format("00000000-0000-0000-0000-0000{:06x}", ip.to_uint());
+    return Common::NewUUID{hex_host};
 }
 
 void UDPClient::Reset() {
@@ -385,7 +385,7 @@ std::vector<Common::ParamPackage> UDPClient::GetInputDevices() const {
             Common::ParamPackage identifier{};
             identifier.Set("engine", GetEngineName());
             identifier.Set("display", fmt::format("UDP Controller {}", pad_identifier.pad));
-            identifier.Set("guid", pad_identifier.guid.Format());
+            identifier.Set("guid", pad_identifier.guid.RawString());
             identifier.Set("port", static_cast<int>(pad_identifier.port));
             identifier.Set("pad", static_cast<int>(pad_identifier.pad));
             devices.emplace_back(identifier);
diff --git a/src/input_common/drivers/udp_client.h b/src/input_common/drivers/udp_client.h
index e9c178139..98abeedd1 100644
--- a/src/input_common/drivers/udp_client.h
+++ b/src/input_common/drivers/udp_client.h
@@ -126,7 +126,7 @@ private:
     struct ClientConnection {
         ClientConnection();
         ~ClientConnection();
-        Common::UUID uuid{"7F000001"};
+        Common::NewUUID uuid{"00000000-0000-0000-0000-00007F000001"};
         std::string host{"127.0.0.1"};
         u16 port{26760};
         s8 active{-1};
@@ -148,7 +148,7 @@ private:
     void OnPadData(Response::PadData, std::size_t client);
     void StartCommunication(std::size_t client, const std::string& host, u16 port);
     PadIdentifier GetPadIdentifier(std::size_t pad_index) const;
-    Common::UUID GetHostUUID(const std::string& host) const;
+    Common::NewUUID GetHostUUID(const std::string& host) const;
 
     Common::Input::ButtonNames GetUIButtonName(const Common::ParamPackage& params) const;
 
diff --git a/src/input_common/input_engine.cpp b/src/input_common/input_engine.cpp
index 0508b408d..65ae1b848 100644
--- a/src/input_common/input_engine.cpp
+++ b/src/input_common/input_engine.cpp
@@ -96,7 +96,7 @@ bool InputEngine::GetButton(const PadIdentifier& identifier, int button) const {
     std::lock_guard lock{mutex};
     const auto controller_iter = controller_list.find(identifier);
     if (controller_iter == controller_list.cend()) {
-        LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
+        LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.RawString(),
                   identifier.pad, identifier.port);
         return false;
     }
@@ -113,7 +113,7 @@ bool InputEngine::GetHatButton(const PadIdentifier& identifier, int button, u8 d
     std::lock_guard lock{mutex};
     const auto controller_iter = controller_list.find(identifier);
     if (controller_iter == controller_list.cend()) {
-        LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
+        LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.RawString(),
                   identifier.pad, identifier.port);
         return false;
     }
@@ -130,7 +130,7 @@ f32 InputEngine::GetAxis(const PadIdentifier& identifier, int axis) const {
     std::lock_guard lock{mutex};
     const auto controller_iter = controller_list.find(identifier);
     if (controller_iter == controller_list.cend()) {
-        LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
+        LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.RawString(),
                   identifier.pad, identifier.port);
         return 0.0f;
     }
@@ -147,7 +147,7 @@ BatteryLevel InputEngine::GetBattery(const PadIdentifier& identifier) const {
     std::lock_guard lock{mutex};
     const auto controller_iter = controller_list.find(identifier);
     if (controller_iter == controller_list.cend()) {
-        LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
+        LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.RawString(),
                   identifier.pad, identifier.port);
         return BatteryLevel::Charging;
     }
@@ -159,7 +159,7 @@ BasicMotion InputEngine::GetMotion(const PadIdentifier& identifier, int motion)
     std::lock_guard lock{mutex};
     const auto controller_iter = controller_list.find(identifier);
     if (controller_iter == controller_list.cend()) {
-        LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
+        LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.RawString(),
                   identifier.pad, identifier.port);
         return {};
     }
diff --git a/src/input_common/input_engine.h b/src/input_common/input_engine.h
index fe2faee5a..05e45b877 100644
--- a/src/input_common/input_engine.h
+++ b/src/input_common/input_engine.h
@@ -10,13 +10,13 @@
 
 #include "common/common_types.h"
 #include "common/input.h"
+#include "common/new_uuid.h"
 #include "common/param_package.h"
-#include "common/uuid.h"
 #include "input_common/main.h"
 
 // Pad Identifier of data source
 struct PadIdentifier {
-    Common::UUID guid{Common::INVALID_UUID};
+    Common::NewUUID guid{};
     std::size_t port{};
     std::size_t pad{};
 
@@ -59,7 +59,7 @@ namespace std {
 template <>
 struct hash<PadIdentifier> {
     size_t operator()(const PadIdentifier& pad_id) const noexcept {
-        u64 hash_value = pad_id.guid.uuid[1] ^ pad_id.guid.uuid[0];
+        u64 hash_value = pad_id.guid.Hash();
         hash_value ^= (static_cast<u64>(pad_id.port) << 32);
         hash_value ^= static_cast<u64>(pad_id.pad);
         return static_cast<size_t>(hash_value);
diff --git a/src/input_common/input_mapping.cpp b/src/input_common/input_mapping.cpp
index a7a6ad8c2..fb78093b8 100644
--- a/src/input_common/input_mapping.cpp
+++ b/src/input_common/input_mapping.cpp
@@ -57,7 +57,7 @@ void MappingFactory::RegisterButton(const MappingData& data) {
     Common::ParamPackage new_input;
     new_input.Set("engine", data.engine);
     if (data.pad.guid.IsValid()) {
-        new_input.Set("guid", data.pad.guid.Format());
+        new_input.Set("guid", data.pad.guid.RawString());
     }
     new_input.Set("port", static_cast<int>(data.pad.port));
     new_input.Set("pad", static_cast<int>(data.pad.pad));
@@ -93,7 +93,7 @@ void MappingFactory::RegisterStick(const MappingData& data) {
     Common::ParamPackage new_input;
     new_input.Set("engine", data.engine);
     if (data.pad.guid.IsValid()) {
-        new_input.Set("guid", data.pad.guid.Format());
+        new_input.Set("guid", data.pad.guid.RawString());
     }
     new_input.Set("port", static_cast<int>(data.pad.port));
     new_input.Set("pad", static_cast<int>(data.pad.pad));
@@ -138,7 +138,7 @@ void MappingFactory::RegisterMotion(const MappingData& data) {
     Common::ParamPackage new_input;
     new_input.Set("engine", data.engine);
     if (data.pad.guid.IsValid()) {
-        new_input.Set("guid", data.pad.guid.Format());
+        new_input.Set("guid", data.pad.guid.RawString());
     }
     new_input.Set("port", static_cast<int>(data.pad.port));
     new_input.Set("pad", static_cast<int>(data.pad.pad));
diff --git a/src/input_common/input_poller.cpp b/src/input_common/input_poller.cpp
index 2f3c0735a..313703f5f 100644
--- a/src/input_common/input_poller.cpp
+++ b/src/input_common/input_poller.cpp
@@ -691,7 +691,7 @@ private:
 std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateButtonDevice(
     const Common::ParamPackage& params) {
     const PadIdentifier identifier = {
-        .guid = Common::UUID{params.Get("guid", "")},
+        .guid = Common::NewUUID{params.Get("guid", "")},
         .port = static_cast<std::size_t>(params.Get("port", 0)),
         .pad = static_cast<std::size_t>(params.Get("pad", 0)),
     };
@@ -714,7 +714,7 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateButtonDevice(
 std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateHatButtonDevice(
     const Common::ParamPackage& params) {
     const PadIdentifier identifier = {
-        .guid = Common::UUID{params.Get("guid", "")},
+        .guid = Common::NewUUID{params.Get("guid", "")},
         .port = static_cast<std::size_t>(params.Get("port", 0)),
         .pad = static_cast<std::size_t>(params.Get("pad", 0)),
     };
@@ -736,7 +736,7 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateStickDevice(
     const auto range = std::clamp(params.Get("range", 1.0f), 0.25f, 1.50f);
     const auto threshold = std::clamp(params.Get("threshold", 0.5f), 0.0f, 1.0f);
     const PadIdentifier identifier = {
-        .guid = Common::UUID{params.Get("guid", "")},
+        .guid = Common::NewUUID{params.Get("guid", "")},
         .port = static_cast<std::size_t>(params.Get("port", 0)),
         .pad = static_cast<std::size_t>(params.Get("pad", 0)),
     };
@@ -768,7 +768,7 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateStickDevice(
 std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateAnalogDevice(
     const Common::ParamPackage& params) {
     const PadIdentifier identifier = {
-        .guid = Common::UUID{params.Get("guid", "")},
+        .guid = Common::NewUUID{params.Get("guid", "")},
         .port = static_cast<std::size_t>(params.Get("port", 0)),
         .pad = static_cast<std::size_t>(params.Get("pad", 0)),
     };
@@ -789,7 +789,7 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateAnalogDevice(
 std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateTriggerDevice(
     const Common::ParamPackage& params) {
     const PadIdentifier identifier = {
-        .guid = Common::UUID{params.Get("guid", "")},
+        .guid = Common::NewUUID{params.Get("guid", "")},
         .port = static_cast<std::size_t>(params.Get("port", 0)),
         .pad = static_cast<std::size_t>(params.Get("pad", 0)),
     };
@@ -820,7 +820,7 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateTouchDevice(
     const auto range = std::clamp(params.Get("range", 1.0f), 0.25f, 1.50f);
     const auto threshold = std::clamp(params.Get("threshold", 0.5f), 0.0f, 1.0f);
     const PadIdentifier identifier = {
-        .guid = Common::UUID{params.Get("guid", "")},
+        .guid = Common::NewUUID{params.Get("guid", "")},
         .port = static_cast<std::size_t>(params.Get("port", 0)),
         .pad = static_cast<std::size_t>(params.Get("pad", 0)),
     };
@@ -857,7 +857,7 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateTouchDevice(
 std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateBatteryDevice(
     const Common::ParamPackage& params) {
     const PadIdentifier identifier = {
-        .guid = Common::UUID{params.Get("guid", "")},
+        .guid = Common::NewUUID{params.Get("guid", "")},
         .port = static_cast<std::size_t>(params.Get("port", 0)),
         .pad = static_cast<std::size_t>(params.Get("pad", 0)),
     };
@@ -869,7 +869,7 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateBatteryDevice(
 std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateMotionDevice(
     Common::ParamPackage params) {
     const PadIdentifier identifier = {
-        .guid = Common::UUID{params.Get("guid", "")},
+        .guid = Common::NewUUID{params.Get("guid", "")},
         .port = static_cast<std::size_t>(params.Get("port", 0)),
         .pad = static_cast<std::size_t>(params.Get("pad", 0)),
     };
@@ -963,7 +963,7 @@ OutputFactory::OutputFactory(std::shared_ptr<InputEngine> input_engine_)
 std::unique_ptr<Common::Input::OutputDevice> OutputFactory::Create(
     const Common::ParamPackage& params) {
     const PadIdentifier identifier = {
-        .guid = Common::UUID{params.Get("guid", "")},
+        .guid = Common::NewUUID{params.Get("guid", "")},
         .port = static_cast<std::size_t>(params.Get("port", 0)),
         .pad = static_cast<std::size_t>(params.Get("pad", 0)),
     };
-- 
cgit v1.2.3


From ee0547e4c4d38d681d9cd3b9f7071c4dade9110d Mon Sep 17 00:00:00 2001
From: Morph <39850852+Morph1984@users.noreply.github.com>
Date: Sat, 5 Feb 2022 00:40:48 -0500
Subject: service: Migrate to the new UUID implementation

---
 src/core/hle/service/friend/friend.cpp          | 18 +++++++++---------
 src/core/hle/service/mii/mii_manager.cpp        | 21 ++++++---------------
 src/core/hle/service/mii/mii_manager.h          | 10 +++++-----
 src/core/hle/service/ns/pdm_qry.cpp             |  6 +++---
 src/core/hle/service/time/clock_types.h         |  8 ++++----
 src/core/hle/service/time/steady_clock_core.h   |  8 ++++----
 src/core/hle/service/time/time_manager.cpp      |  4 ++--
 src/core/hle/service/time/time_sharedmemory.cpp |  2 +-
 src/core/hle/service/time/time_sharedmemory.h   |  4 ++--
 9 files changed, 36 insertions(+), 45 deletions(-)

(limited to 'src')

diff --git a/src/core/hle/service/friend/friend.cpp b/src/core/hle/service/friend/friend.cpp
index 9f9cea1e0..3c621f7f0 100644
--- a/src/core/hle/service/friend/friend.cpp
+++ b/src/core/hle/service/friend/friend.cpp
@@ -4,7 +4,7 @@
 
 #include <queue>
 #include "common/logging/log.h"
-#include "common/uuid.h"
+#include "common/new_uuid.h"
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/k_event.h"
@@ -170,10 +170,10 @@ private:
     void GetPlayHistoryRegistrationKey(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
         const auto local_play = rp.Pop<bool>();
-        const auto uuid = rp.PopRaw<Common::UUID>();
+        const auto uuid = rp.PopRaw<Common::NewUUID>();
 
         LOG_WARNING(Service_Friend, "(STUBBED) called, local_play={}, uuid=0x{}", local_play,
-                    uuid.Format());
+                    uuid.RawString());
 
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(ResultSuccess);
@@ -182,11 +182,11 @@ private:
     void GetFriendList(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
         const auto friend_offset = rp.Pop<u32>();
-        const auto uuid = rp.PopRaw<Common::UUID>();
+        const auto uuid = rp.PopRaw<Common::NewUUID>();
         [[maybe_unused]] const auto filter = rp.PopRaw<SizedFriendFilter>();
         const auto pid = rp.Pop<u64>();
         LOG_WARNING(Service_Friend, "(STUBBED) called, offset={}, uuid=0x{}, pid={}", friend_offset,
-                    uuid.Format(), pid);
+                    uuid.RawString(), pid);
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(ResultSuccess);
@@ -202,7 +202,7 @@ private:
 
 class INotificationService final : public ServiceFramework<INotificationService> {
 public:
-    explicit INotificationService(Core::System& system_, Common::UUID uuid_)
+    explicit INotificationService(Core::System& system_, Common::NewUUID uuid_)
         : ServiceFramework{system_, "INotificationService"}, uuid{uuid_},
           service_context{system_, "INotificationService"} {
         // clang-format off
@@ -293,7 +293,7 @@ private:
         bool has_received_friend_request;
     };
 
-    Common::UUID uuid;
+    Common::NewUUID uuid;
     KernelHelpers::ServiceContext service_context;
 
     Kernel::KEvent* notification_event;
@@ -310,9 +310,9 @@ void Module::Interface::CreateFriendService(Kernel::HLERequestContext& ctx) {
 
 void Module::Interface::CreateNotificationService(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    auto uuid = rp.PopRaw<Common::UUID>();
+    auto uuid = rp.PopRaw<Common::NewUUID>();
 
-    LOG_DEBUG(Service_Friend, "called, uuid=0x{}", uuid.Format());
+    LOG_DEBUG(Service_Friend, "called, uuid=0x{}", uuid.RawString());
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
diff --git a/src/core/hle/service/mii/mii_manager.cpp b/src/core/hle/service/mii/mii_manager.cpp
index ca4ed35bb..aa1a9a6c7 100644
--- a/src/core/hle/service/mii/mii_manager.cpp
+++ b/src/core/hle/service/mii/mii_manager.cpp
@@ -118,16 +118,6 @@ u16 GenerateCrc16(const void* data, std::size_t size) {
     return Common::swap16(static_cast<u16>(crc));
 }
 
-Common::UUID GenerateValidUUID() {
-    auto uuid{Common::UUID::Generate()};
-
-    // Bit 7 must be set, and bit 6 unset for the UUID to be valid
-    uuid.uuid[1] &= 0xFFFFFFFFFFFFFF3FULL;
-    uuid.uuid[1] |= 0x0000000000000080ULL;
-
-    return uuid;
-}
-
 template <typename T>
 T GetRandomValue(T min, T max) {
     std::random_device device;
@@ -141,7 +131,8 @@ T GetRandomValue(T max) {
     return GetRandomValue<T>({}, max);
 }
 
-MiiStoreData BuildRandomStoreData(Age age, Gender gender, Race race, const Common::UUID& user_id) {
+MiiStoreData BuildRandomStoreData(Age age, Gender gender, Race race,
+                                  const Common::NewUUID& user_id) {
     MiiStoreBitFields bf{};
 
     if (gender == Gender::All) {
@@ -320,7 +311,7 @@ MiiStoreData BuildRandomStoreData(Age age, Gender gender, Race race, const Commo
     return {DefaultMiiName, bf, user_id};
 }
 
-MiiStoreData BuildDefaultStoreData(const DefaultMii& info, const Common::UUID& user_id) {
+MiiStoreData BuildDefaultStoreData(const DefaultMii& info, const Common::NewUUID& user_id) {
     MiiStoreBitFields bf{};
 
     bf.font_region.Assign(info.font_region);
@@ -381,13 +372,13 @@ MiiStoreData BuildDefaultStoreData(const DefaultMii& info, const Common::UUID& u
 MiiStoreData::MiiStoreData() = default;
 
 MiiStoreData::MiiStoreData(const MiiStoreData::Name& name, const MiiStoreBitFields& bit_fields,
-                           const Common::UUID& user_id) {
+                           const Common::NewUUID& user_id) {
     data.name = name;
-    data.uuid = GenerateValidUUID();
+    data.uuid = Common::NewUUID::MakeRandomRFC4122V4();
 
     std::memcpy(data.data.data(), &bit_fields, sizeof(MiiStoreBitFields));
     data_crc = GenerateCrc16(data.data.data(), sizeof(data));
-    device_crc = GenerateCrc16(&user_id, sizeof(Common::UUID));
+    device_crc = GenerateCrc16(&user_id, sizeof(Common::NewUUID));
 }
 
 MiiManager::MiiManager() : user_id{Service::Account::ProfileManager().GetLastOpenedUser()} {}
diff --git a/src/core/hle/service/mii/mii_manager.h b/src/core/hle/service/mii/mii_manager.h
index 8e048fc56..580a64fc9 100644
--- a/src/core/hle/service/mii/mii_manager.h
+++ b/src/core/hle/service/mii/mii_manager.h
@@ -8,7 +8,7 @@
 #include <vector>
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
-#include "common/uuid.h"
+#include "common/new_uuid.h"
 #include "core/hle/result.h"
 #include "core/hle/service/mii/types.h"
 
@@ -29,7 +29,7 @@ enum class SourceFlag : u32 {
 DECLARE_ENUM_FLAG_OPERATORS(SourceFlag);
 
 struct MiiInfo {
-    Common::UUID uuid;
+    Common::NewUUID uuid;
     std::array<char16_t, 11> name;
     u8 font_region;
     u8 favorite_color;
@@ -192,7 +192,7 @@ struct MiiStoreData {
 
     MiiStoreData();
     MiiStoreData(const Name& name, const MiiStoreBitFields& bit_fields,
-                 const Common::UUID& user_id);
+                 const Common::NewUUID& user_id);
 
     // This corresponds to the above structure MiiStoreBitFields. I did it like this because the
     // BitField<> type makes this (and any thing that contains it) not trivially copyable, which is
@@ -202,7 +202,7 @@ struct MiiStoreData {
         static_assert(sizeof(MiiStoreBitFields) == sizeof(data), "data field has incorrect size.");
 
         Name name{};
-        Common::UUID uuid{Common::INVALID_UUID};
+        Common::NewUUID uuid{};
     } data;
 
     u16 data_crc{};
@@ -326,7 +326,7 @@ public:
     ResultCode GetIndex(const MiiInfo& info, u32& index);
 
 private:
-    const Common::UUID user_id{Common::INVALID_UUID};
+    const Common::NewUUID user_id{};
     u64 update_counter{};
 };
 
diff --git a/src/core/hle/service/ns/pdm_qry.cpp b/src/core/hle/service/ns/pdm_qry.cpp
index e2fab5c3f..3eda444d2 100644
--- a/src/core/hle/service/ns/pdm_qry.cpp
+++ b/src/core/hle/service/ns/pdm_qry.cpp
@@ -5,7 +5,7 @@
 #include <memory>
 
 #include "common/logging/log.h"
-#include "common/uuid.h"
+#include "common/new_uuid.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/ns/pdm_qry.h"
 #include "core/hle/service/service.h"
@@ -49,7 +49,7 @@ void PDM_QRY::QueryPlayStatisticsByApplicationIdAndUserAccountId(Kernel::HLERequ
     const auto unknown = rp.Pop<bool>();
     rp.Pop<u8>(); // Padding
     const auto application_id = rp.Pop<u64>();
-    const auto user_account_uid = rp.PopRaw<Common::UUID>();
+    const auto user_account_uid = rp.PopRaw<Common::NewUUID>();
 
     // TODO(German77): Read statistics of the game
     PlayStatistics statistics{
@@ -59,7 +59,7 @@ void PDM_QRY::QueryPlayStatisticsByApplicationIdAndUserAccountId(Kernel::HLERequ
 
     LOG_WARNING(Service_NS,
                 "(STUBBED) called. unknown={}. application_id=0x{:016X}, user_account_uid=0x{}",
-                unknown, application_id, user_account_uid.Format());
+                unknown, application_id, user_account_uid.RawString());
 
     IPC::ResponseBuilder rb{ctx, 12};
     rb.Push(ResultSuccess);
diff --git a/src/core/hle/service/time/clock_types.h b/src/core/hle/service/time/clock_types.h
index 392e16863..23d6c859b 100644
--- a/src/core/hle/service/time/clock_types.h
+++ b/src/core/hle/service/time/clock_types.h
@@ -6,7 +6,7 @@
 
 #include "common/common_funcs.h"
 #include "common/common_types.h"
-#include "common/uuid.h"
+#include "common/new_uuid.h"
 #include "core/hle/service/time/errors.h"
 #include "core/hle/service/time/time_zone_types.h"
 
@@ -21,7 +21,7 @@ enum class TimeType : u8 {
 /// https://switchbrew.org/wiki/Glue_services#SteadyClockTimePoint
 struct SteadyClockTimePoint {
     s64 time_point;
-    Common::UUID clock_source_id;
+    Common::NewUUID clock_source_id;
 
     ResultCode GetSpanBetween(SteadyClockTimePoint other, s64& span) const {
         span = 0;
@@ -36,7 +36,7 @@ struct SteadyClockTimePoint {
     }
 
     static SteadyClockTimePoint GetRandom() {
-        return {0, Common::UUID::Generate()};
+        return {0, Common::NewUUID::MakeRandom()};
     }
 };
 static_assert(sizeof(SteadyClockTimePoint) == 0x18, "SteadyClockTimePoint is incorrect size");
@@ -45,7 +45,7 @@ static_assert(std::is_trivially_copyable_v<SteadyClockTimePoint>,
 
 struct SteadyClockContext {
     u64 internal_offset;
-    Common::UUID steady_time_point;
+    Common::NewUUID steady_time_point;
 };
 static_assert(sizeof(SteadyClockContext) == 0x18, "SteadyClockContext is incorrect size");
 static_assert(std::is_trivially_copyable_v<SteadyClockContext>,
diff --git a/src/core/hle/service/time/steady_clock_core.h b/src/core/hle/service/time/steady_clock_core.h
index d80a2385f..dfc9fade4 100644
--- a/src/core/hle/service/time/steady_clock_core.h
+++ b/src/core/hle/service/time/steady_clock_core.h
@@ -4,7 +4,7 @@
 
 #pragma once
 
-#include "common/uuid.h"
+#include "common/new_uuid.h"
 #include "core/hle/service/time/clock_types.h"
 
 namespace Core {
@@ -18,11 +18,11 @@ public:
     SteadyClockCore() = default;
     virtual ~SteadyClockCore() = default;
 
-    const Common::UUID& GetClockSourceId() const {
+    const Common::NewUUID& GetClockSourceId() const {
         return clock_source_id;
     }
 
-    void SetClockSourceId(const Common::UUID& value) {
+    void SetClockSourceId(const Common::NewUUID& value) {
         clock_source_id = value;
     }
 
@@ -49,7 +49,7 @@ public:
     }
 
 private:
-    Common::UUID clock_source_id{Common::UUID::Generate()};
+    Common::NewUUID clock_source_id{Common::NewUUID::MakeRandom()};
     bool is_initialized{};
 };
 
diff --git a/src/core/hle/service/time/time_manager.cpp b/src/core/hle/service/time/time_manager.cpp
index c1e4e6cce..15a2d99e8 100644
--- a/src/core/hle/service/time/time_manager.cpp
+++ b/src/core/hle/service/time/time_manager.cpp
@@ -45,7 +45,7 @@ struct TimeManager::Impl final {
           time_zone_content_manager{system} {
 
         const auto system_time{Clock::TimeSpanType::FromSeconds(GetExternalRtcValue())};
-        SetupStandardSteadyClock(system, Common::UUID::Generate(), system_time, {}, {});
+        SetupStandardSteadyClock(system, Common::NewUUID::MakeRandom(), system_time, {}, {});
         SetupStandardLocalSystemClock(system, {}, system_time.ToSeconds());
 
         Clock::SystemClockContext clock_context{};
@@ -132,7 +132,7 @@ struct TimeManager::Impl final {
         return 0;
     }
 
-    void SetupStandardSteadyClock(Core::System& system_, Common::UUID clock_source_id,
+    void SetupStandardSteadyClock(Core::System& system_, Common::NewUUID clock_source_id,
                                   Clock::TimeSpanType setup_value,
                                   Clock::TimeSpanType internal_offset, bool is_rtc_reset_detected) {
         standard_steady_clock_core.SetClockSourceId(clock_source_id);
diff --git a/src/core/hle/service/time/time_sharedmemory.cpp b/src/core/hle/service/time/time_sharedmemory.cpp
index ed9f75ed6..ac31cd9ca 100644
--- a/src/core/hle/service/time/time_sharedmemory.cpp
+++ b/src/core/hle/service/time/time_sharedmemory.cpp
@@ -20,7 +20,7 @@ SharedMemory::SharedMemory(Core::System& system_) : system(system_) {
 
 SharedMemory::~SharedMemory() = default;
 
-void SharedMemory::SetupStandardSteadyClock(const Common::UUID& clock_source_id,
+void SharedMemory::SetupStandardSteadyClock(const Common::NewUUID& clock_source_id,
                                             Clock::TimeSpanType current_time_point) {
     const Clock::TimeSpanType ticks_time_span{Clock::TimeSpanType::FromTicks(
         system.CoreTiming().GetClockTicks(), Core::Hardware::CNTFREQ)};
diff --git a/src/core/hle/service/time/time_sharedmemory.h b/src/core/hle/service/time/time_sharedmemory.h
index 9307ea795..4063ce4e0 100644
--- a/src/core/hle/service/time/time_sharedmemory.h
+++ b/src/core/hle/service/time/time_sharedmemory.h
@@ -5,7 +5,7 @@
 #pragma once
 
 #include "common/common_types.h"
-#include "common/uuid.h"
+#include "common/new_uuid.h"
 #include "core/hle/kernel/k_shared_memory.h"
 #include "core/hle/service/time/clock_types.h"
 
@@ -52,7 +52,7 @@ public:
     };
     static_assert(sizeof(Format) == 0xd8, "Format is an invalid size");
 
-    void SetupStandardSteadyClock(const Common::UUID& clock_source_id,
+    void SetupStandardSteadyClock(const Common::NewUUID& clock_source_id,
                                   Clock::TimeSpanType current_time_point);
     void UpdateLocalSystemClockContext(const Clock::SystemClockContext& context);
     void UpdateNetworkSystemClockContext(const Clock::SystemClockContext& context);
-- 
cgit v1.2.3


From f0340b8d22c8e2d9319726b8d90f9b3a3636882e Mon Sep 17 00:00:00 2001
From: Morph <39850852+Morph1984@users.noreply.github.com>
Date: Sat, 5 Feb 2022 11:29:44 -0500
Subject: hle: ipc_helpers: Ignore -Wclass-memaccess

This warning is triggered by GCC when copying into non-trivially default constructible types, as it uses the more restrictive std::is_trivial (which includes std::is_trivially_default_constructible) to determine whether memcpy is safe instead of std::is_trivially_copyable.
---
 src/core/hle/ipc_helpers.h | 8 ++++++++
 1 file changed, 8 insertions(+)

(limited to 'src')

diff --git a/src/core/hle/ipc_helpers.h b/src/core/hle/ipc_helpers.h
index cf204f570..026257115 100644
--- a/src/core/hle/ipc_helpers.h
+++ b/src/core/hle/ipc_helpers.h
@@ -404,6 +404,11 @@ inline s32 RequestParser::Pop() {
     return static_cast<s32>(Pop<u32>());
 }
 
+// Ignore the -Wclass-memaccess warning on memcpy for non-trivially default constructible objects.
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wclass-memaccess"
+#endif
 template <typename T>
 void RequestParser::PopRaw(T& value) {
     static_assert(std::is_trivially_copyable_v<T>,
@@ -411,6 +416,9 @@ void RequestParser::PopRaw(T& value) {
     std::memcpy(&value, cmdbuf + index, sizeof(T));
     index += (sizeof(T) + 3) / 4; // round up to word length
 }
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
 
 template <typename T>
 T RequestParser::PopRaw() {
-- 
cgit v1.2.3


From d94dcaefa020dcfc89d655dcf5aa8dad998e0bf2 Mon Sep 17 00:00:00 2001
From: Morph <39850852+Morph1984@users.noreply.github.com>
Date: Sat, 5 Feb 2022 11:41:39 -0500
Subject: common: uuid: Add AsU128()

This copies the internal bytes of the UUID into a u128 for backwards compatibility. This should not be used.
---
 src/common/new_uuid.cpp | 6 ++++++
 src/common/new_uuid.h   | 3 +++
 2 files changed, 9 insertions(+)

(limited to 'src')

diff --git a/src/common/new_uuid.cpp b/src/common/new_uuid.cpp
index 0442681c8..f2f0077ae 100644
--- a/src/common/new_uuid.cpp
+++ b/src/common/new_uuid.cpp
@@ -144,6 +144,12 @@ size_t NewUUID::Hash() const noexcept {
     return hash ^ std::rotl(temp, 1);
 }
 
+u128 NewUUID::AsU128() const {
+    u128 uuid_old;
+    std::memcpy(&uuid_old, uuid.data(), sizeof(NewUUID));
+    return uuid_old;
+}
+
 NewUUID NewUUID::MakeRandom() {
     std::random_device device;
 
diff --git a/src/common/new_uuid.h b/src/common/new_uuid.h
index bd4468ad2..44665ad5a 100644
--- a/src/common/new_uuid.h
+++ b/src/common/new_uuid.h
@@ -83,6 +83,9 @@ struct NewUUID {
      */
     size_t Hash() const noexcept;
 
+    /// DO NOT USE. Copies the contents of the UUID into a u128.
+    u128 AsU128() const;
+
     /**
      * Creates a default UUID "yuzu Default UID".
      *
-- 
cgit v1.2.3


From dfe11d72e3eb14dee718b7fa67a673514d199f20 Mon Sep 17 00:00:00 2001
From: Morph <39850852+Morph1984@users.noreply.github.com>
Date: Sat, 5 Feb 2022 12:29:09 -0500
Subject: profile: Migrate to the new UUID implementation

---
 src/core/frontend/applets/profile_select.cpp       |  5 +-
 src/core/frontend/applets/profile_select.h         |  7 +-
 src/core/hle/service/acc/acc.cpp                   | 93 +++++++++++-----------
 src/core/hle/service/acc/acc.h                     |  4 +-
 src/core/hle/service/acc/profile_manager.cpp       | 51 ++++++------
 src/core/hle/service/acc/profile_manager.h         | 38 ++++-----
 src/core/hle/service/am/am.cpp                     |  6 +-
 .../service/am/applets/applet_profile_select.cpp   |  9 ++-
 .../hle/service/am/applets/applet_profile_select.h |  6 +-
 src/yuzu/applets/qt_profile_select.cpp             | 14 ++--
 src/yuzu/applets/qt_profile_select.h               |  7 +-
 .../configuration/configure_profile_manager.cpp    | 14 ++--
 src/yuzu/main.cpp                                  |  2 +-
 src/yuzu/main.h                                    |  2 +-
 14 files changed, 131 insertions(+), 127 deletions(-)

(limited to 'src')

diff --git a/src/core/frontend/applets/profile_select.cpp b/src/core/frontend/applets/profile_select.cpp
index 3e4f90be2..a7ff2ccf9 100644
--- a/src/core/frontend/applets/profile_select.cpp
+++ b/src/core/frontend/applets/profile_select.cpp
@@ -11,10 +11,9 @@ namespace Core::Frontend {
 ProfileSelectApplet::~ProfileSelectApplet() = default;
 
 void DefaultProfileSelectApplet::SelectProfile(
-    std::function<void(std::optional<Common::UUID>)> callback) const {
+    std::function<void(std::optional<Common::NewUUID>)> callback) const {
     Service::Account::ProfileManager manager;
-    callback(manager.GetUser(Settings::values.current_user.GetValue())
-                 .value_or(Common::UUID{Common::INVALID_UUID}));
+    callback(manager.GetUser(Settings::values.current_user.GetValue()).value_or(Common::NewUUID{}));
     LOG_INFO(Service_ACC, "called, selecting current user instead of prompting...");
 }
 
diff --git a/src/core/frontend/applets/profile_select.h b/src/core/frontend/applets/profile_select.h
index 3506b9885..5b2346e72 100644
--- a/src/core/frontend/applets/profile_select.h
+++ b/src/core/frontend/applets/profile_select.h
@@ -6,7 +6,7 @@
 
 #include <functional>
 #include <optional>
-#include "common/uuid.h"
+#include "common/new_uuid.h"
 
 namespace Core::Frontend {
 
@@ -14,12 +14,13 @@ class ProfileSelectApplet {
 public:
     virtual ~ProfileSelectApplet();
 
-    virtual void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback) const = 0;
+    virtual void SelectProfile(
+        std::function<void(std::optional<Common::NewUUID>)> callback) const = 0;
 };
 
 class DefaultProfileSelectApplet final : public ProfileSelectApplet {
 public:
-    void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback) const override;
+    void SelectProfile(std::function<void(std::optional<Common::NewUUID>)> callback) const override;
 };
 
 } // namespace Core::Frontend
diff --git a/src/core/hle/service/acc/acc.cpp b/src/core/hle/service/acc/acc.cpp
index 6e63e057e..6abb7dbc4 100644
--- a/src/core/hle/service/acc/acc.cpp
+++ b/src/core/hle/service/acc/acc.cpp
@@ -39,9 +39,9 @@ constexpr ResultCode ERR_FAILED_SAVE_DATA{ErrorModule::Account, 100};
 // Thumbnails are hard coded to be at least this size
 constexpr std::size_t THUMBNAIL_SIZE = 0x24000;
 
-static std::filesystem::path GetImagePath(Common::UUID uuid) {
+static std::filesystem::path GetImagePath(const Common::NewUUID& uuid) {
     return Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir) /
-           fmt::format("system/save/8000000000000010/su/avators/{}.jpg", uuid.FormatSwitch());
+           fmt::format("system/save/8000000000000010/su/avators/{}.jpg", uuid.FormattedString());
 }
 
 static constexpr u32 SanitizeJPEGSize(std::size_t size) {
@@ -51,7 +51,7 @@ static constexpr u32 SanitizeJPEGSize(std::size_t size) {
 
 class IManagerForSystemService final : public ServiceFramework<IManagerForSystemService> {
 public:
-    explicit IManagerForSystemService(Core::System& system_, Common::UUID)
+    explicit IManagerForSystemService(Core::System& system_, Common::NewUUID)
         : ServiceFramework{system_, "IManagerForSystemService"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -87,7 +87,7 @@ public:
 // 3.0.0+
 class IFloatingRegistrationRequest final : public ServiceFramework<IFloatingRegistrationRequest> {
 public:
-    explicit IFloatingRegistrationRequest(Core::System& system_, Common::UUID)
+    explicit IFloatingRegistrationRequest(Core::System& system_, Common::NewUUID)
         : ServiceFramework{system_, "IFloatingRegistrationRequest"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -112,7 +112,7 @@ public:
 
 class IAdministrator final : public ServiceFramework<IAdministrator> {
 public:
-    explicit IAdministrator(Core::System& system_, Common::UUID)
+    explicit IAdministrator(Core::System& system_, Common::NewUUID)
         : ServiceFramework{system_, "IAdministrator"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -170,7 +170,7 @@ public:
 
 class IAuthorizationRequest final : public ServiceFramework<IAuthorizationRequest> {
 public:
-    explicit IAuthorizationRequest(Core::System& system_, Common::UUID)
+    explicit IAuthorizationRequest(Core::System& system_, Common::NewUUID)
         : ServiceFramework{system_, "IAuthorizationRequest"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -189,7 +189,7 @@ public:
 
 class IOAuthProcedure final : public ServiceFramework<IOAuthProcedure> {
 public:
-    explicit IOAuthProcedure(Core::System& system_, Common::UUID)
+    explicit IOAuthProcedure(Core::System& system_, Common::NewUUID)
         : ServiceFramework{system_, "IOAuthProcedure"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -208,7 +208,7 @@ public:
 // 3.0.0+
 class IOAuthProcedureForExternalNsa final : public ServiceFramework<IOAuthProcedureForExternalNsa> {
 public:
-    explicit IOAuthProcedureForExternalNsa(Core::System& system_, Common::UUID)
+    explicit IOAuthProcedureForExternalNsa(Core::System& system_, Common::NewUUID)
         : ServiceFramework{system_, "IOAuthProcedureForExternalNsa"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -231,7 +231,7 @@ public:
 class IOAuthProcedureForNintendoAccountLinkage final
     : public ServiceFramework<IOAuthProcedureForNintendoAccountLinkage> {
 public:
-    explicit IOAuthProcedureForNintendoAccountLinkage(Core::System& system_, Common::UUID)
+    explicit IOAuthProcedureForNintendoAccountLinkage(Core::System& system_, Common::NewUUID)
         : ServiceFramework{system_, "IOAuthProcedureForNintendoAccountLinkage"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -252,7 +252,7 @@ public:
 
 class INotifier final : public ServiceFramework<INotifier> {
 public:
-    explicit INotifier(Core::System& system_, Common::UUID)
+    explicit INotifier(Core::System& system_, Common::NewUUID)
         : ServiceFramework{system_, "INotifier"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -267,7 +267,7 @@ public:
 class IProfileCommon : public ServiceFramework<IProfileCommon> {
 public:
     explicit IProfileCommon(Core::System& system_, const char* name, bool editor_commands,
-                            Common::UUID user_id_, ProfileManager& profile_manager_)
+                            Common::NewUUID user_id_, ProfileManager& profile_manager_)
         : ServiceFramework{system_, name}, profile_manager{profile_manager_}, user_id{user_id_} {
         static const FunctionInfo functions[] = {
             {0, &IProfileCommon::Get, "Get"},
@@ -290,7 +290,7 @@ public:
 
 protected:
     void Get(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_ACC, "called user_id=0x{}", user_id.Format());
+        LOG_DEBUG(Service_ACC, "called user_id=0x{}", user_id.RawString());
         ProfileBase profile_base{};
         ProfileData data{};
         if (profile_manager.GetProfileBaseAndData(user_id, profile_base, data)) {
@@ -300,21 +300,21 @@ protected:
             rb.PushRaw(profile_base);
         } else {
             LOG_ERROR(Service_ACC, "Failed to get profile base and data for user=0x{}",
-                      user_id.Format());
+                      user_id.RawString());
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(ResultUnknown); // TODO(ogniK): Get actual error code
         }
     }
 
     void GetBase(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_ACC, "called user_id=0x{}", user_id.Format());
+        LOG_DEBUG(Service_ACC, "called user_id=0x{}", user_id.RawString());
         ProfileBase profile_base{};
         if (profile_manager.GetProfileBase(user_id, profile_base)) {
             IPC::ResponseBuilder rb{ctx, 16};
             rb.Push(ResultSuccess);
             rb.PushRaw(profile_base);
         } else {
-            LOG_ERROR(Service_ACC, "Failed to get profile base for user=0x{}", user_id.Format());
+            LOG_ERROR(Service_ACC, "Failed to get profile base for user=0x{}", user_id.RawString());
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(ResultUnknown); // TODO(ogniK): Get actual error code
         }
@@ -373,7 +373,7 @@ protected:
         LOG_DEBUG(Service_ACC, "called, username='{}', timestamp={:016X}, uuid=0x{}",
                   Common::StringFromFixedZeroTerminatedBuffer(
                       reinterpret_cast<const char*>(base.username.data()), base.username.size()),
-                  base.timestamp, base.user_uuid.Format());
+                  base.timestamp, base.user_uuid.RawString());
 
         if (user_data.size() < sizeof(ProfileData)) {
             LOG_ERROR(Service_ACC, "ProfileData buffer too small!");
@@ -406,7 +406,7 @@ protected:
         LOG_DEBUG(Service_ACC, "called, username='{}', timestamp={:016X}, uuid=0x{}",
                   Common::StringFromFixedZeroTerminatedBuffer(
                       reinterpret_cast<const char*>(base.username.data()), base.username.size()),
-                  base.timestamp, base.user_uuid.Format());
+                  base.timestamp, base.user_uuid.RawString());
 
         if (user_data.size() < sizeof(ProfileData)) {
             LOG_ERROR(Service_ACC, "ProfileData buffer too small!");
@@ -435,26 +435,26 @@ protected:
     }
 
     ProfileManager& profile_manager;
-    Common::UUID user_id{Common::INVALID_UUID}; ///< The user id this profile refers to.
+    Common::NewUUID user_id{}; ///< The user id this profile refers to.
 };
 
 class IProfile final : public IProfileCommon {
 public:
-    explicit IProfile(Core::System& system_, Common::UUID user_id_,
+    explicit IProfile(Core::System& system_, Common::NewUUID user_id_,
                       ProfileManager& profile_manager_)
         : IProfileCommon{system_, "IProfile", false, user_id_, profile_manager_} {}
 };
 
 class IProfileEditor final : public IProfileCommon {
 public:
-    explicit IProfileEditor(Core::System& system_, Common::UUID user_id_,
+    explicit IProfileEditor(Core::System& system_, Common::NewUUID user_id_,
                             ProfileManager& profile_manager_)
         : IProfileCommon{system_, "IProfileEditor", true, user_id_, profile_manager_} {}
 };
 
 class ISessionObject final : public ServiceFramework<ISessionObject> {
 public:
-    explicit ISessionObject(Core::System& system_, Common::UUID)
+    explicit ISessionObject(Core::System& system_, Common::NewUUID)
         : ServiceFramework{system_, "ISessionObject"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -468,7 +468,7 @@ public:
 
 class IGuestLoginRequest final : public ServiceFramework<IGuestLoginRequest> {
 public:
-    explicit IGuestLoginRequest(Core::System& system_, Common::UUID)
+    explicit IGuestLoginRequest(Core::System& system_, Common::NewUUID)
         : ServiceFramework{system_, "IGuestLoginRequest"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -514,7 +514,7 @@ protected:
 
 class IManagerForApplication final : public ServiceFramework<IManagerForApplication> {
 public:
-    explicit IManagerForApplication(Core::System& system_, Common::UUID user_id_)
+    explicit IManagerForApplication(Core::System& system_, Common::NewUUID user_id_)
         : ServiceFramework{system_, "IManagerForApplication"},
           ensure_token_id{std::make_shared<EnsureTokenIdCacheAsyncInterface>(system)},
           user_id{user_id_} {
@@ -547,7 +547,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 4};
         rb.Push(ResultSuccess);
-        rb.PushRaw<u64>(user_id.GetNintendoID());
+        rb.PushRaw<u64>(user_id.Hash());
     }
 
     void EnsureIdTokenCacheAsync(Kernel::HLERequestContext& ctx) {
@@ -577,7 +577,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 4};
         rb.Push(ResultSuccess);
-        rb.PushRaw<u64>(user_id.GetNintendoID());
+        rb.PushRaw<u64>(user_id.Hash());
     }
 
     void StoreOpenContext(Kernel::HLERequestContext& ctx) {
@@ -587,14 +587,14 @@ private:
     }
 
     std::shared_ptr<EnsureTokenIdCacheAsyncInterface> ensure_token_id{};
-    Common::UUID user_id{Common::INVALID_UUID};
+    Common::NewUUID user_id{};
 };
 
 // 6.0.0+
 class IAsyncNetworkServiceLicenseKindContext final
     : public ServiceFramework<IAsyncNetworkServiceLicenseKindContext> {
 public:
-    explicit IAsyncNetworkServiceLicenseKindContext(Core::System& system_, Common::UUID)
+    explicit IAsyncNetworkServiceLicenseKindContext(Core::System& system_, Common::NewUUID)
         : ServiceFramework{system_, "IAsyncNetworkServiceLicenseKindContext"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -614,7 +614,7 @@ public:
 class IOAuthProcedureForUserRegistration final
     : public ServiceFramework<IOAuthProcedureForUserRegistration> {
 public:
-    explicit IOAuthProcedureForUserRegistration(Core::System& system_, Common::UUID)
+    explicit IOAuthProcedureForUserRegistration(Core::System& system_, Common::NewUUID)
         : ServiceFramework{system_, "IOAuthProcedureForUserRegistration"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -638,7 +638,8 @@ public:
 
 class DAUTH_O final : public ServiceFramework<DAUTH_O> {
 public:
-    explicit DAUTH_O(Core::System& system_, Common::UUID) : ServiceFramework{system_, "dauth:o"} {
+    explicit DAUTH_O(Core::System& system_, Common::NewUUID)
+        : ServiceFramework{system_, "dauth:o"} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, nullptr, "EnsureAuthenticationTokenCacheAsync"},
@@ -662,7 +663,7 @@ public:
 // 6.0.0+
 class IAsyncResult final : public ServiceFramework<IAsyncResult> {
 public:
-    explicit IAsyncResult(Core::System& system_, Common::UUID)
+    explicit IAsyncResult(Core::System& system_, Common::NewUUID)
         : ServiceFramework{system_, "IAsyncResult"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -686,8 +687,8 @@ void Module::Interface::GetUserCount(Kernel::HLERequestContext& ctx) {
 
 void Module::Interface::GetUserExistence(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    Common::UUID user_id = rp.PopRaw<Common::UUID>();
-    LOG_DEBUG(Service_ACC, "called user_id=0x{}", user_id.Format());
+    Common::NewUUID user_id = rp.PopRaw<Common::NewUUID>();
+    LOG_DEBUG(Service_ACC, "called user_id=0x{}", user_id.RawString());
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(ResultSuccess);
@@ -712,13 +713,13 @@ void Module::Interface::GetLastOpenedUser(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_ACC, "called");
     IPC::ResponseBuilder rb{ctx, 6};
     rb.Push(ResultSuccess);
-    rb.PushRaw<Common::UUID>(profile_manager->GetLastOpenedUser());
+    rb.PushRaw<Common::NewUUID>(profile_manager->GetLastOpenedUser());
 }
 
 void Module::Interface::GetProfile(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    Common::UUID user_id = rp.PopRaw<Common::UUID>();
-    LOG_DEBUG(Service_ACC, "called user_id=0x{}", user_id.Format());
+    Common::NewUUID user_id = rp.PopRaw<Common::NewUUID>();
+    LOG_DEBUG(Service_ACC, "called user_id=0x{}", user_id.RawString());
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
@@ -831,9 +832,9 @@ void Module::Interface::InitializeApplicationInfoV2(Kernel::HLERequestContext& c
 
 void Module::Interface::GetProfileEditor(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    Common::UUID user_id = rp.PopRaw<Common::UUID>();
+    Common::NewUUID user_id = rp.PopRaw<Common::NewUUID>();
 
-    LOG_DEBUG(Service_ACC, "called, user_id=0x{}", user_id.Format());
+    LOG_DEBUG(Service_ACC, "called, user_id=0x{}", user_id.RawString());
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
@@ -873,9 +874,9 @@ void Module::Interface::ListOpenContextStoredUsers(Kernel::HLERequestContext& ct
 
 void Module::Interface::StoreSaveDataThumbnailApplication(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    const auto uuid = rp.PopRaw<Common::UUID>();
+    const auto uuid = rp.PopRaw<Common::NewUUID>();
 
-    LOG_WARNING(Service_ACC, "(STUBBED) called, uuid=0x{}", uuid.Format());
+    LOG_WARNING(Service_ACC, "(STUBBED) called, uuid=0x{}", uuid.RawString());
 
     // TODO(ogniK): Check if application ID is zero on acc initialize. As we don't have a reliable
     // way of confirming things like the TID, we're going to assume a non zero value for the time
@@ -886,15 +887,15 @@ void Module::Interface::StoreSaveDataThumbnailApplication(Kernel::HLERequestCont
 
 void Module::Interface::StoreSaveDataThumbnailSystem(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    const auto uuid = rp.PopRaw<Common::UUID>();
+    const auto uuid = rp.PopRaw<Common::NewUUID>();
     const auto tid = rp.Pop<u64_le>();
 
-    LOG_WARNING(Service_ACC, "(STUBBED) called, uuid=0x{}, tid={:016X}", uuid.Format(), tid);
+    LOG_WARNING(Service_ACC, "(STUBBED) called, uuid=0x{}, tid={:016X}", uuid.RawString(), tid);
     StoreSaveDataThumbnail(ctx, uuid, tid);
 }
 
 void Module::Interface::StoreSaveDataThumbnail(Kernel::HLERequestContext& ctx,
-                                               const Common::UUID& uuid, const u64 tid) {
+                                               const Common::NewUUID& uuid, const u64 tid) {
     IPC::ResponseBuilder rb{ctx, 2};
 
     if (tid == 0) {
@@ -903,7 +904,7 @@ void Module::Interface::StoreSaveDataThumbnail(Kernel::HLERequestContext& ctx,
         return;
     }
 
-    if (!uuid) {
+    if (uuid.IsInvalid()) {
         LOG_ERROR(Service_ACC, "User ID is not valid!");
         rb.Push(ERR_INVALID_USER_ID);
         return;
@@ -927,20 +928,20 @@ void Module::Interface::TrySelectUserWithoutInteraction(Kernel::HLERequestContex
     IPC::ResponseBuilder rb{ctx, 6};
     if (profile_manager->GetUserCount() != 1) {
         rb.Push(ResultSuccess);
-        rb.PushRaw<u128>(Common::INVALID_UUID);
+        rb.PushRaw(Common::InvalidUUID);
         return;
     }
 
     const auto user_list = profile_manager->GetAllUsers();
     if (std::ranges::all_of(user_list, [](const auto& user) { return user.IsInvalid(); })) {
         rb.Push(ResultUnknown); // TODO(ogniK): Find the correct error code
-        rb.PushRaw<u128>(Common::INVALID_UUID);
+        rb.PushRaw(Common::InvalidUUID);
         return;
     }
 
     // Select the first user we have
     rb.Push(ResultSuccess);
-    rb.PushRaw<u128>(profile_manager->GetUser(0)->uuid);
+    rb.PushRaw(profile_manager->GetUser(0)->uuid);
 }
 
 Module::Interface::Interface(std::shared_ptr<Module> module_,
diff --git a/src/core/hle/service/acc/acc.h b/src/core/hle/service/acc/acc.h
index f7e9bc4f8..b57342701 100644
--- a/src/core/hle/service/acc/acc.h
+++ b/src/core/hle/service/acc/acc.h
@@ -4,7 +4,7 @@
 
 #pragma once
 
-#include "common/uuid.h"
+#include "common/new_uuid.h"
 #include "core/hle/service/glue/glue_manager.h"
 #include "core/hle/service/service.h"
 
@@ -43,7 +43,7 @@ public:
 
     private:
         ResultCode InitializeApplicationInfoBase();
-        void StoreSaveDataThumbnail(Kernel::HLERequestContext& ctx, const Common::UUID& uuid,
+        void StoreSaveDataThumbnail(Kernel::HLERequestContext& ctx, const Common::NewUUID& uuid,
                                     const u64 tid);
 
         enum class ApplicationType : u32_le {
diff --git a/src/core/hle/service/acc/profile_manager.cpp b/src/core/hle/service/acc/profile_manager.cpp
index 568303ced..366f3fe14 100644
--- a/src/core/hle/service/acc/profile_manager.cpp
+++ b/src/core/hle/service/acc/profile_manager.cpp
@@ -16,11 +16,11 @@
 namespace Service::Account {
 
 namespace FS = Common::FS;
-using Common::UUID;
+using Common::NewUUID;
 
 struct UserRaw {
-    UUID uuid{Common::INVALID_UUID};
-    UUID uuid2{Common::INVALID_UUID};
+    NewUUID uuid{};
+    NewUUID uuid2{};
     u64 timestamp{};
     ProfileUsername username{};
     ProfileData extra_data{};
@@ -45,7 +45,7 @@ ProfileManager::ProfileManager() {
 
     // Create an user if none are present
     if (user_count == 0) {
-        CreateNewUser(UUID::Generate(), "yuzu");
+        CreateNewUser(NewUUID::MakeRandom(), "yuzu");
     }
 
     auto current =
@@ -97,11 +97,11 @@ ResultCode ProfileManager::AddUser(const ProfileInfo& user) {
 
 /// Create a new user on the system. If the uuid of the user already exists, the user is not
 /// created.
-ResultCode ProfileManager::CreateNewUser(UUID uuid, const ProfileUsername& username) {
+ResultCode ProfileManager::CreateNewUser(NewUUID uuid, const ProfileUsername& username) {
     if (user_count == MAX_USERS) {
         return ERROR_TOO_MANY_USERS;
     }
-    if (!uuid) {
+    if (uuid.IsInvalid()) {
         return ERROR_ARGUMENT_IS_NULL;
     }
     if (username[0] == 0x0) {
@@ -124,7 +124,7 @@ ResultCode ProfileManager::CreateNewUser(UUID uuid, const ProfileUsername& usern
 /// Creates a new user on the system. This function allows a much simpler method of registration
 /// specifically by allowing an std::string for the username. This is required specifically since
 /// we're loading a string straight from the config
-ResultCode ProfileManager::CreateNewUser(UUID uuid, const std::string& username) {
+ResultCode ProfileManager::CreateNewUser(NewUUID uuid, const std::string& username) {
     ProfileUsername username_output{};
 
     if (username.size() > username_output.size()) {
@@ -135,7 +135,7 @@ ResultCode ProfileManager::CreateNewUser(UUID uuid, const std::string& username)
     return CreateNewUser(uuid, username_output);
 }
 
-std::optional<UUID> ProfileManager::GetUser(std::size_t index) const {
+std::optional<NewUUID> ProfileManager::GetUser(std::size_t index) const {
     if (index >= MAX_USERS) {
         return std::nullopt;
     }
@@ -144,8 +144,8 @@ std::optional<UUID> ProfileManager::GetUser(std::size_t index) const {
 }
 
 /// Returns a users profile index based on their user id.
-std::optional<std::size_t> ProfileManager::GetUserIndex(const UUID& uuid) const {
-    if (!uuid) {
+std::optional<std::size_t> ProfileManager::GetUserIndex(const NewUUID& uuid) const {
+    if (uuid.IsInvalid()) {
         return std::nullopt;
     }
 
@@ -176,7 +176,7 @@ bool ProfileManager::GetProfileBase(std::optional<std::size_t> index, ProfileBas
 }
 
 /// Returns the data structure used by the switch when GetProfileBase is called on acc:*
-bool ProfileManager::GetProfileBase(UUID uuid, ProfileBase& profile) const {
+bool ProfileManager::GetProfileBase(NewUUID uuid, ProfileBase& profile) const {
     const auto idx = GetUserIndex(uuid);
     return GetProfileBase(idx, profile);
 }
@@ -203,7 +203,7 @@ std::size_t ProfileManager::GetOpenUserCount() const {
 }
 
 /// Checks if a user id exists in our profile manager
-bool ProfileManager::UserExists(UUID uuid) const {
+bool ProfileManager::UserExists(NewUUID uuid) const {
     return GetUserIndex(uuid).has_value();
 }
 
@@ -215,7 +215,7 @@ bool ProfileManager::UserExistsIndex(std::size_t index) const {
 }
 
 /// Opens a specific user
-void ProfileManager::OpenUser(UUID uuid) {
+void ProfileManager::OpenUser(NewUUID uuid) {
     const auto idx = GetUserIndex(uuid);
     if (!idx) {
         return;
@@ -226,7 +226,7 @@ void ProfileManager::OpenUser(UUID uuid) {
 }
 
 /// Closes a specific user
-void ProfileManager::CloseUser(UUID uuid) {
+void ProfileManager::CloseUser(NewUUID uuid) {
     const auto idx = GetUserIndex(uuid);
     if (!idx) {
         return;
@@ -250,14 +250,15 @@ UserIDArray ProfileManager::GetOpenUsers() const {
     std::ranges::transform(profiles, output.begin(), [](const ProfileInfo& p) {
         if (p.is_open)
             return p.user_uuid;
-        return UUID{Common::INVALID_UUID};
+        return Common::InvalidUUID;
     });
-    std::stable_partition(output.begin(), output.end(), [](const UUID& uuid) { return uuid; });
+    std::stable_partition(output.begin(), output.end(),
+                          [](const NewUUID& uuid) { return uuid.IsValid(); });
     return output;
 }
 
 /// Returns the last user which was opened
-UUID ProfileManager::GetLastOpenedUser() const {
+NewUUID ProfileManager::GetLastOpenedUser() const {
     return last_opened_user;
 }
 
@@ -272,7 +273,7 @@ bool ProfileManager::GetProfileBaseAndData(std::optional<std::size_t> index, Pro
 }
 
 /// Return the users profile base and the unknown arbitary data.
-bool ProfileManager::GetProfileBaseAndData(UUID uuid, ProfileBase& profile,
+bool ProfileManager::GetProfileBaseAndData(NewUUID uuid, ProfileBase& profile,
                                            ProfileData& data) const {
     const auto idx = GetUserIndex(uuid);
     return GetProfileBaseAndData(idx, profile, data);
@@ -291,7 +292,7 @@ bool ProfileManager::CanSystemRegisterUser() const {
     // emulate qlaunch. Update this to dynamically change.
 }
 
-bool ProfileManager::RemoveUser(UUID uuid) {
+bool ProfileManager::RemoveUser(NewUUID uuid) {
     const auto index = GetUserIndex(uuid);
     if (!index) {
         return false;
@@ -299,11 +300,11 @@ bool ProfileManager::RemoveUser(UUID uuid) {
 
     profiles[*index] = ProfileInfo{};
     std::stable_partition(profiles.begin(), profiles.end(),
-                          [](const ProfileInfo& profile) { return profile.user_uuid; });
+                          [](const ProfileInfo& profile) { return profile.user_uuid.IsValid(); });
     return true;
 }
 
-bool ProfileManager::SetProfileBase(UUID uuid, const ProfileBase& profile_new) {
+bool ProfileManager::SetProfileBase(NewUUID uuid, const ProfileBase& profile_new) {
     const auto index = GetUserIndex(uuid);
     if (!index || profile_new.user_uuid.IsInvalid()) {
         return false;
@@ -317,7 +318,7 @@ bool ProfileManager::SetProfileBase(UUID uuid, const ProfileBase& profile_new) {
     return true;
 }
 
-bool ProfileManager::SetProfileBaseAndData(Common::UUID uuid, const ProfileBase& profile_new,
+bool ProfileManager::SetProfileBaseAndData(Common::NewUUID uuid, const ProfileBase& profile_new,
                                            const ProfileData& data_new) {
     const auto index = GetUserIndex(uuid);
     if (index.has_value() && SetProfileBase(uuid, profile_new)) {
@@ -335,14 +336,14 @@ void ProfileManager::ParseUserSaveFile() {
 
     if (!save.IsOpen()) {
         LOG_WARNING(Service_ACC, "Failed to load profile data from save data... Generating new "
-                                 "user 'yuzu' with random UUID.");
+                                 "user 'yuzu' with random NewUUID.");
         return;
     }
 
     ProfileDataRaw data;
     if (!save.ReadObject(data)) {
         LOG_WARNING(Service_ACC, "profiles.dat is smaller than expected... Generating new user "
-                                 "'yuzu' with random UUID.");
+                                 "'yuzu' with random NewUUID.");
         return;
     }
 
@@ -361,7 +362,7 @@ void ProfileManager::ParseUserSaveFile() {
     }
 
     std::stable_partition(profiles.begin(), profiles.end(),
-                          [](const ProfileInfo& profile) { return profile.user_uuid; });
+                          [](const ProfileInfo& profile) { return profile.user_uuid.IsValid(); });
 }
 
 void ProfileManager::WriteUserSaveFile() {
diff --git a/src/core/hle/service/acc/profile_manager.h b/src/core/hle/service/acc/profile_manager.h
index 71b9d5518..e9c58a826 100644
--- a/src/core/hle/service/acc/profile_manager.h
+++ b/src/core/hle/service/acc/profile_manager.h
@@ -8,8 +8,8 @@
 #include <optional>
 
 #include "common/common_types.h"
+#include "common/new_uuid.h"
 #include "common/swap.h"
-#include "common/uuid.h"
 #include "core/hle/result.h"
 
 namespace Service::Account {
@@ -18,7 +18,7 @@ constexpr std::size_t MAX_USERS{8};
 constexpr std::size_t profile_username_size{32};
 
 using ProfileUsername = std::array<u8, profile_username_size>;
-using UserIDArray = std::array<Common::UUID, MAX_USERS>;
+using UserIDArray = std::array<Common::NewUUID, MAX_USERS>;
 
 /// Contains extra data related to a user.
 /// TODO: RE this structure
@@ -35,7 +35,7 @@ static_assert(sizeof(ProfileData) == 0x80, "ProfileData structure has incorrect
 /// This holds general information about a users profile. This is where we store all the information
 /// based on a specific user
 struct ProfileInfo {
-    Common::UUID user_uuid{Common::INVALID_UUID};
+    Common::NewUUID user_uuid{};
     ProfileUsername username{};
     u64 creation_time{};
     ProfileData data{}; // TODO(ognik): Work out what this is
@@ -43,13 +43,13 @@ struct ProfileInfo {
 };
 
 struct ProfileBase {
-    Common::UUID user_uuid;
+    Common::NewUUID user_uuid;
     u64_le timestamp;
     ProfileUsername username;
 
     // Zero out all the fields to make the profile slot considered "Empty"
     void Invalidate() {
-        user_uuid.Invalidate();
+        user_uuid = {};
         timestamp = 0;
         username.fill(0);
     }
@@ -65,34 +65,34 @@ public:
     ~ProfileManager();
 
     ResultCode AddUser(const ProfileInfo& user);
-    ResultCode CreateNewUser(Common::UUID uuid, const ProfileUsername& username);
-    ResultCode CreateNewUser(Common::UUID uuid, const std::string& username);
-    std::optional<Common::UUID> GetUser(std::size_t index) const;
-    std::optional<std::size_t> GetUserIndex(const Common::UUID& uuid) const;
+    ResultCode CreateNewUser(Common::NewUUID uuid, const ProfileUsername& username);
+    ResultCode CreateNewUser(Common::NewUUID uuid, const std::string& username);
+    std::optional<Common::NewUUID> GetUser(std::size_t index) const;
+    std::optional<std::size_t> GetUserIndex(const Common::NewUUID& uuid) const;
     std::optional<std::size_t> GetUserIndex(const ProfileInfo& user) const;
     bool GetProfileBase(std::optional<std::size_t> index, ProfileBase& profile) const;
-    bool GetProfileBase(Common::UUID uuid, ProfileBase& profile) const;
+    bool GetProfileBase(Common::NewUUID uuid, ProfileBase& profile) const;
     bool GetProfileBase(const ProfileInfo& user, ProfileBase& profile) const;
     bool GetProfileBaseAndData(std::optional<std::size_t> index, ProfileBase& profile,
                                ProfileData& data) const;
-    bool GetProfileBaseAndData(Common::UUID uuid, ProfileBase& profile, ProfileData& data) const;
+    bool GetProfileBaseAndData(Common::NewUUID uuid, ProfileBase& profile, ProfileData& data) const;
     bool GetProfileBaseAndData(const ProfileInfo& user, ProfileBase& profile,
                                ProfileData& data) const;
     std::size_t GetUserCount() const;
     std::size_t GetOpenUserCount() const;
-    bool UserExists(Common::UUID uuid) const;
+    bool UserExists(Common::NewUUID uuid) const;
     bool UserExistsIndex(std::size_t index) const;
-    void OpenUser(Common::UUID uuid);
-    void CloseUser(Common::UUID uuid);
+    void OpenUser(Common::NewUUID uuid);
+    void CloseUser(Common::NewUUID uuid);
     UserIDArray GetOpenUsers() const;
     UserIDArray GetAllUsers() const;
-    Common::UUID GetLastOpenedUser() const;
+    Common::NewUUID GetLastOpenedUser() const;
 
     bool CanSystemRegisterUser() const;
 
-    bool RemoveUser(Common::UUID uuid);
-    bool SetProfileBase(Common::UUID uuid, const ProfileBase& profile_new);
-    bool SetProfileBaseAndData(Common::UUID uuid, const ProfileBase& profile_new,
+    bool RemoveUser(Common::NewUUID uuid);
+    bool SetProfileBase(Common::NewUUID uuid, const ProfileBase& profile_new);
+    bool SetProfileBaseAndData(Common::NewUUID uuid, const ProfileBase& profile_new,
                                const ProfileData& data_new);
 
 private:
@@ -103,7 +103,7 @@ private:
 
     std::array<ProfileInfo, MAX_USERS> profiles{};
     std::size_t user_count{};
-    Common::UUID last_opened_user{Common::INVALID_UUID};
+    Common::NewUUID last_opened_user{};
 };
 
 }; // namespace Service::Account
diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp
index e60661fe1..4cdc029b7 100644
--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@@ -55,7 +55,7 @@ constexpr u32 LAUNCH_PARAMETER_ACCOUNT_PRESELECTED_USER_MAGIC = 0xC79497CA;
 struct LaunchParameterAccountPreselectedUser {
     u32_le magic;
     u32_le is_account_selected;
-    u128 current_user;
+    Common::NewUUID current_user;
     INSERT_PADDING_BYTES(0x70);
 };
 static_assert(sizeof(LaunchParameterAccountPreselectedUser) == 0x88);
@@ -1453,8 +1453,8 @@ void IApplicationFunctions::PopLaunchParameter(Kernel::HLERequestContext& ctx) {
 
         Account::ProfileManager profile_manager{};
         const auto uuid = profile_manager.GetUser(static_cast<s32>(Settings::values.current_user));
-        ASSERT(uuid);
-        params.current_user = uuid->uuid;
+        ASSERT(uuid.has_value() && uuid->IsValid());
+        params.current_user = *uuid;
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
 
diff --git a/src/core/hle/service/am/applets/applet_profile_select.cpp b/src/core/hle/service/am/applets/applet_profile_select.cpp
index a6e891944..3ac32fa58 100644
--- a/src/core/hle/service/am/applets/applet_profile_select.cpp
+++ b/src/core/hle/service/am/applets/applet_profile_select.cpp
@@ -54,19 +54,20 @@ void ProfileSelect::Execute() {
         return;
     }
 
-    frontend.SelectProfile([this](std::optional<Common::UUID> uuid) { SelectionComplete(uuid); });
+    frontend.SelectProfile(
+        [this](std::optional<Common::NewUUID> uuid) { SelectionComplete(uuid); });
 }
 
-void ProfileSelect::SelectionComplete(std::optional<Common::UUID> uuid) {
+void ProfileSelect::SelectionComplete(std::optional<Common::NewUUID> uuid) {
     UserSelectionOutput output{};
 
     if (uuid.has_value() && uuid->IsValid()) {
         output.result = 0;
-        output.uuid_selected = uuid->uuid;
+        output.uuid_selected = *uuid;
     } else {
         status = ERR_USER_CANCELLED_SELECTION;
         output.result = ERR_USER_CANCELLED_SELECTION.raw;
-        output.uuid_selected = Common::INVALID_UUID;
+        output.uuid_selected = Common::InvalidUUID;
     }
 
     final_data = std::vector<u8>(sizeof(UserSelectionOutput));
diff --git a/src/core/hle/service/am/applets/applet_profile_select.h b/src/core/hle/service/am/applets/applet_profile_select.h
index 8fb76e6c4..c5c506c41 100644
--- a/src/core/hle/service/am/applets/applet_profile_select.h
+++ b/src/core/hle/service/am/applets/applet_profile_select.h
@@ -7,7 +7,7 @@
 #include <vector>
 
 #include "common/common_funcs.h"
-#include "common/uuid.h"
+#include "common/new_uuid.h"
 #include "core/hle/result.h"
 #include "core/hle/service/am/applets/applets.h"
 
@@ -27,7 +27,7 @@ static_assert(sizeof(UserSelectionConfig) == 0xA0, "UserSelectionConfig has inco
 
 struct UserSelectionOutput {
     u64 result;
-    u128 uuid_selected;
+    Common::NewUUID uuid_selected;
 };
 static_assert(sizeof(UserSelectionOutput) == 0x18, "UserSelectionOutput has incorrect size.");
 
@@ -44,7 +44,7 @@ public:
     void ExecuteInteractive() override;
     void Execute() override;
 
-    void SelectionComplete(std::optional<Common::UUID> uuid);
+    void SelectionComplete(std::optional<Common::NewUUID> uuid);
 
 private:
     const Core::Frontend::ProfileSelectApplet& frontend;
diff --git a/src/yuzu/applets/qt_profile_select.cpp b/src/yuzu/applets/qt_profile_select.cpp
index 5b32da923..c10185e50 100644
--- a/src/yuzu/applets/qt_profile_select.cpp
+++ b/src/yuzu/applets/qt_profile_select.cpp
@@ -19,21 +19,21 @@
 #include "yuzu/util/controller_navigation.h"
 
 namespace {
-QString FormatUserEntryText(const QString& username, Common::UUID uuid) {
+QString FormatUserEntryText(const QString& username, Common::NewUUID uuid) {
     return QtProfileSelectionDialog::tr(
                "%1\n%2", "%1 is the profile username, %2 is the formatted UUID (e.g. "
                          "00112233-4455-6677-8899-AABBCCDDEEFF))")
-        .arg(username, QString::fromStdString(uuid.FormatSwitch()));
+        .arg(username, QString::fromStdString(uuid.FormattedString()));
 }
 
-QString GetImagePath(Common::UUID uuid) {
+QString GetImagePath(Common::NewUUID uuid) {
     const auto path =
         Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir) /
-        fmt::format("system/save/8000000000000010/su/avators/{}.jpg", uuid.FormatSwitch());
+        fmt::format("system/save/8000000000000010/su/avators/{}.jpg", uuid.FormattedString());
     return QString::fromStdString(Common::FS::PathToUTF8String(path));
 }
 
-QPixmap GetIcon(Common::UUID uuid) {
+QPixmap GetIcon(Common::NewUUID uuid) {
     QPixmap icon{GetImagePath(uuid)};
 
     if (!icon) {
@@ -163,11 +163,11 @@ QtProfileSelector::QtProfileSelector(GMainWindow& parent) {
 QtProfileSelector::~QtProfileSelector() = default;
 
 void QtProfileSelector::SelectProfile(
-    std::function<void(std::optional<Common::UUID>)> callback_) const {
+    std::function<void(std::optional<Common::NewUUID>)> callback_) const {
     callback = std::move(callback_);
     emit MainWindowSelectProfile();
 }
 
-void QtProfileSelector::MainWindowFinishedSelection(std::optional<Common::UUID> uuid) {
+void QtProfileSelector::MainWindowFinishedSelection(std::optional<Common::NewUUID> uuid) {
     callback(uuid);
 }
diff --git a/src/yuzu/applets/qt_profile_select.h b/src/yuzu/applets/qt_profile_select.h
index 56496ed31..2522b6450 100644
--- a/src/yuzu/applets/qt_profile_select.h
+++ b/src/yuzu/applets/qt_profile_select.h
@@ -66,13 +66,14 @@ public:
     explicit QtProfileSelector(GMainWindow& parent);
     ~QtProfileSelector() override;
 
-    void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback_) const override;
+    void SelectProfile(
+        std::function<void(std::optional<Common::NewUUID>)> callback_) const override;
 
 signals:
     void MainWindowSelectProfile() const;
 
 private:
-    void MainWindowFinishedSelection(std::optional<Common::UUID> uuid);
+    void MainWindowFinishedSelection(std::optional<Common::NewUUID> uuid);
 
-    mutable std::function<void(std::optional<Common::UUID>)> callback;
+    mutable std::function<void(std::optional<Common::NewUUID>)> callback;
 };
diff --git a/src/yuzu/configuration/configure_profile_manager.cpp b/src/yuzu/configuration/configure_profile_manager.cpp
index 78b6374c0..9e2832543 100644
--- a/src/yuzu/configuration/configure_profile_manager.cpp
+++ b/src/yuzu/configuration/configure_profile_manager.cpp
@@ -33,14 +33,14 @@ constexpr std::array<u8, 107> backup_jpeg{
     0x01, 0x01, 0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
 };
 
-QString GetImagePath(Common::UUID uuid) {
+QString GetImagePath(const Common::NewUUID& uuid) {
     const auto path =
         Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir) /
-        fmt::format("system/save/8000000000000010/su/avators/{}.jpg", uuid.FormatSwitch());
+        fmt::format("system/save/8000000000000010/su/avators/{}.jpg", uuid.FormattedString());
     return QString::fromStdString(Common::FS::PathToUTF8String(path));
 }
 
-QString GetAccountUsername(const Service::Account::ProfileManager& manager, Common::UUID uuid) {
+QString GetAccountUsername(const Service::Account::ProfileManager& manager, Common::NewUUID uuid) {
     Service::Account::ProfileBase profile{};
     if (!manager.GetProfileBase(uuid, profile)) {
         return {};
@@ -51,14 +51,14 @@ QString GetAccountUsername(const Service::Account::ProfileManager& manager, Comm
     return QString::fromStdString(text);
 }
 
-QString FormatUserEntryText(const QString& username, Common::UUID uuid) {
+QString FormatUserEntryText(const QString& username, Common::NewUUID uuid) {
     return ConfigureProfileManager::tr("%1\n%2",
                                        "%1 is the profile username, %2 is the formatted UUID (e.g. "
                                        "00112233-4455-6677-8899-AABBCCDDEEFF))")
-        .arg(username, QString::fromStdString(uuid.FormatSwitch()));
+        .arg(username, QString::fromStdString(uuid.FormattedString()));
 }
 
-QPixmap GetIcon(Common::UUID uuid) {
+QPixmap GetIcon(const Common::NewUUID& uuid) {
     QPixmap icon{GetImagePath(uuid)};
 
     if (!icon) {
@@ -200,7 +200,7 @@ void ConfigureProfileManager::AddUser() {
         return;
     }
 
-    const auto uuid = Common::UUID::Generate();
+    const auto uuid = Common::NewUUID::MakeRandom();
     profile_manager->CreateNewUser(uuid, username.toStdString());
 
     item_model->appendRow(new QStandardItem{GetIcon(uuid), FormatUserEntryText(username, uuid)});
diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp
index 556d2cdb3..c89909737 100644
--- a/src/yuzu/main.cpp
+++ b/src/yuzu/main.cpp
@@ -1688,7 +1688,7 @@ void GMainWindow::OnGameListOpenFolder(u64 program_id, GameListOpenTarget target
 
             const auto user_save_data_path = FileSys::SaveDataFactory::GetFullPath(
                 *system, FileSys::SaveDataSpaceId::NandUser, FileSys::SaveDataType::SaveData,
-                program_id, user_id->uuid, 0);
+                program_id, user_id->AsU128(), 0);
 
             path = Common::FS::ConcatPathSafe(nand_dir, user_save_data_path);
         } else {
diff --git a/src/yuzu/main.h b/src/yuzu/main.h
index ca4ab9af5..529d101ae 100644
--- a/src/yuzu/main.h
+++ b/src/yuzu/main.h
@@ -153,7 +153,7 @@ signals:
 
     void ErrorDisplayFinished();
 
-    void ProfileSelectorFinishedSelection(std::optional<Common::UUID> uuid);
+    void ProfileSelectorFinishedSelection(std::optional<Common::NewUUID> uuid);
 
     void SoftwareKeyboardSubmitNormalText(Service::AM::Applets::SwkbdResult result,
                                           std::u16string submitted_text, bool confirmed);
-- 
cgit v1.2.3


From 25db62ce1534cbd8b93b4284869229e4bd7de54d Mon Sep 17 00:00:00 2001
From: Morph <39850852+Morph1984@users.noreply.github.com>
Date: Sat, 5 Feb 2022 12:35:39 -0500
Subject: general: Rename NewUUID to UUID, and remove the previous UUID impl

This completes the removal of the old UUID implementation.
---
 src/common/CMakeLists.txt                          |   2 -
 src/common/input.h                                 |   8 +-
 src/common/new_uuid.cpp                            | 188 ---------------------
 src/common/new_uuid.h                              | 141 ----------------
 src/common/uuid.cpp                                | 185 +++++++++++++++-----
 src/common/uuid.h                                  | 166 +++++++++++-------
 src/core/frontend/applets/profile_select.cpp       |   4 +-
 src/core/frontend/applets/profile_select.h         |   7 +-
 src/core/hid/emulated_controller.cpp               |  14 +-
 src/core/hid/emulated_controller.h                 |   6 +-
 src/core/hid/hid_types.h                           |   2 +-
 src/core/hle/service/acc/acc.cpp                   |  57 +++----
 src/core/hle/service/acc/acc.h                     |   4 +-
 src/core/hle/service/acc/profile_manager.cpp       |  40 ++---
 src/core/hle/service/acc/profile_manager.h         |  36 ++--
 src/core/hle/service/am/am.cpp                     |   2 +-
 .../service/am/applets/applet_profile_select.cpp   |   5 +-
 .../hle/service/am/applets/applet_profile_select.h |   6 +-
 src/core/hle/service/friend/friend.cpp             |  12 +-
 src/core/hle/service/mii/mii_manager.cpp           |  11 +-
 src/core/hle/service/mii/mii_manager.h             |  10 +-
 src/core/hle/service/ns/pdm_qry.cpp                |   4 +-
 src/core/hle/service/time/clock_types.h            |   8 +-
 src/core/hle/service/time/steady_clock_core.h      |   8 +-
 src/core/hle/service/time/time_manager.cpp         |   4 +-
 src/core/hle/service/time/time_sharedmemory.cpp    |   2 +-
 src/core/hle/service/time/time_sharedmemory.h      |   4 +-
 src/input_common/drivers/gc_adapter.cpp            |   2 +-
 src/input_common/drivers/keyboard.cpp              |   6 +-
 src/input_common/drivers/mouse.cpp                 |   2 +-
 src/input_common/drivers/sdl_driver.cpp            |   2 +-
 src/input_common/drivers/tas_input.cpp             |   4 +-
 src/input_common/drivers/touch_screen.cpp          |   2 +-
 src/input_common/drivers/udp_client.cpp            |   4 +-
 src/input_common/drivers/udp_client.h              |   4 +-
 src/input_common/input_engine.h                    |   4 +-
 src/input_common/input_poller.cpp                  |  18 +-
 src/yuzu/applets/qt_profile_select.cpp             |  10 +-
 src/yuzu/applets/qt_profile_select.h               |   7 +-
 .../configuration/configure_profile_manager.cpp    |  10 +-
 src/yuzu/main.h                                    |   2 +-
 41 files changed, 415 insertions(+), 598 deletions(-)
 delete mode 100644 src/common/new_uuid.cpp
 delete mode 100644 src/common/new_uuid.h

(limited to 'src')

diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
index 3dd460191..adf70eb8b 100644
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -99,8 +99,6 @@ add_library(common STATIC
     microprofile.cpp
     microprofile.h
     microprofileui.h
-    new_uuid.cpp
-    new_uuid.h
     nvidia_flags.cpp
     nvidia_flags.h
     page_table.cpp
diff --git a/src/common/input.h b/src/common/input.h
index 95d30497d..54fcb24b0 100644
--- a/src/common/input.h
+++ b/src/common/input.h
@@ -10,8 +10,8 @@
 #include <unordered_map>
 #include <utility>
 #include "common/logging/log.h"
-#include "common/new_uuid.h"
 #include "common/param_package.h"
+#include "common/uuid.h"
 
 namespace Common::Input {
 
@@ -97,7 +97,7 @@ struct AnalogStatus {
 
 // Button data
 struct ButtonStatus {
-    Common::NewUUID uuid{};
+    Common::UUID uuid{};
     bool value{};
     bool inverted{};
     bool toggle{};
@@ -109,7 +109,7 @@ using BatteryStatus = BatteryLevel;
 
 // Analog and digital joystick data
 struct StickStatus {
-    Common::NewUUID uuid{};
+    Common::UUID uuid{};
     AnalogStatus x{};
     AnalogStatus y{};
     bool left{};
@@ -120,7 +120,7 @@ struct StickStatus {
 
 // Analog and digital trigger data
 struct TriggerStatus {
-    Common::NewUUID uuid{};
+    Common::UUID uuid{};
     AnalogStatus analog{};
     ButtonStatus pressed{};
 };
diff --git a/src/common/new_uuid.cpp b/src/common/new_uuid.cpp
deleted file mode 100644
index f2f0077ae..000000000
--- a/src/common/new_uuid.cpp
+++ /dev/null
@@ -1,188 +0,0 @@
-// Copyright 2022 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <bit>
-#include <random>
-
-#include <fmt/format.h>
-
-#include "common/assert.h"
-#include "common/new_uuid.h"
-#include "common/tiny_mt.h"
-
-namespace Common {
-
-namespace {
-
-constexpr size_t RawStringSize = sizeof(NewUUID) * 2;
-constexpr size_t FormattedStringSize = RawStringSize + 4;
-
-u8 HexCharToByte(char c) {
-    if (c >= '0' && c <= '9') {
-        return static_cast<u8>(c - '0');
-    }
-    if (c >= 'a' && c <= 'f') {
-        return static_cast<u8>(c - 'a' + 10);
-    }
-    if (c >= 'A' && c <= 'F') {
-        return static_cast<u8>(c - 'A' + 10);
-    }
-    ASSERT_MSG(false, "{} is not a hexadecimal digit!", c);
-    return u8{0};
-}
-
-std::array<u8, 0x10> ConstructFromRawString(std::string_view raw_string) {
-    std::array<u8, 0x10> uuid;
-
-    for (size_t i = 0; i < RawStringSize; i += 2) {
-        uuid[i / 2] =
-            static_cast<u8>((HexCharToByte(raw_string[i]) << 4) | HexCharToByte(raw_string[i + 1]));
-    }
-
-    return uuid;
-}
-
-std::array<u8, 0x10> ConstructFromFormattedString(std::string_view formatted_string) {
-    std::array<u8, 0x10> uuid;
-
-    size_t i = 0;
-
-    // Process the first 8 characters.
-    const auto* str = formatted_string.data();
-
-    for (; i < 4; ++i) {
-        uuid[i] = static_cast<u8>((HexCharToByte(*(str++)) << 4));
-        uuid[i] |= HexCharToByte(*(str++));
-    }
-
-    // Process the next 4 characters.
-    ++str;
-
-    for (; i < 6; ++i) {
-        uuid[i] = static_cast<u8>((HexCharToByte(*(str++)) << 4));
-        uuid[i] |= HexCharToByte(*(str++));
-    }
-
-    // Process the next 4 characters.
-    ++str;
-
-    for (; i < 8; ++i) {
-        uuid[i] = static_cast<u8>((HexCharToByte(*(str++)) << 4));
-        uuid[i] |= HexCharToByte(*(str++));
-    }
-
-    // Process the next 4 characters.
-    ++str;
-
-    for (; i < 10; ++i) {
-        uuid[i] = static_cast<u8>((HexCharToByte(*(str++)) << 4));
-        uuid[i] |= HexCharToByte(*(str++));
-    }
-
-    // Process the last 12 characters.
-    ++str;
-
-    for (; i < 16; ++i) {
-        uuid[i] = static_cast<u8>((HexCharToByte(*(str++)) << 4));
-        uuid[i] |= HexCharToByte(*(str++));
-    }
-
-    return uuid;
-}
-
-std::array<u8, 0x10> ConstructUUID(std::string_view uuid_string) {
-    const auto length = uuid_string.length();
-
-    if (length == 0) {
-        return {};
-    }
-
-    // Check if the input string contains 32 hexadecimal characters.
-    if (length == RawStringSize) {
-        return ConstructFromRawString(uuid_string);
-    }
-
-    // Check if the input string has the length of a RFC 4122 formatted UUID string.
-    if (length == FormattedStringSize) {
-        return ConstructFromFormattedString(uuid_string);
-    }
-
-    ASSERT_MSG(false, "UUID string has an invalid length of {} characters!", length);
-
-    return {};
-}
-
-} // Anonymous namespace
-
-NewUUID::NewUUID(std::string_view uuid_string) : uuid{ConstructUUID(uuid_string)} {}
-
-std::string NewUUID::RawString() const {
-    return fmt::format("{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}"
-                       "{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}",
-                       uuid[0], uuid[1], uuid[2], uuid[3], uuid[4], uuid[5], uuid[6], uuid[7],
-                       uuid[8], uuid[9], uuid[10], uuid[11], uuid[12], uuid[13], uuid[14],
-                       uuid[15]);
-}
-
-std::string NewUUID::FormattedString() const {
-    return fmt::format("{:02x}{:02x}{:02x}{:02x}"
-                       "-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-"
-                       "{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}",
-                       uuid[0], uuid[1], uuid[2], uuid[3], uuid[4], uuid[5], uuid[6], uuid[7],
-                       uuid[8], uuid[9], uuid[10], uuid[11], uuid[12], uuid[13], uuid[14],
-                       uuid[15]);
-}
-
-size_t NewUUID::Hash() const noexcept {
-    u64 hash;
-    u64 temp;
-
-    std::memcpy(&hash, uuid.data(), sizeof(u64));
-    std::memcpy(&temp, uuid.data() + 8, sizeof(u64));
-
-    return hash ^ std::rotl(temp, 1);
-}
-
-u128 NewUUID::AsU128() const {
-    u128 uuid_old;
-    std::memcpy(&uuid_old, uuid.data(), sizeof(NewUUID));
-    return uuid_old;
-}
-
-NewUUID NewUUID::MakeRandom() {
-    std::random_device device;
-
-    return MakeRandomWithSeed(device());
-}
-
-NewUUID NewUUID::MakeRandomWithSeed(u32 seed) {
-    // Create and initialize our RNG.
-    TinyMT rng;
-    rng.Initialize(seed);
-
-    NewUUID uuid;
-
-    // Populate the UUID with random bytes.
-    rng.GenerateRandomBytes(uuid.uuid.data(), sizeof(NewUUID));
-
-    return uuid;
-}
-
-NewUUID NewUUID::MakeRandomRFC4122V4() {
-    auto uuid = MakeRandom();
-
-    // According to Proposed Standard RFC 4122 Section 4.4, we must:
-
-    // 1. Set the two most significant bits (bits 6 and 7) of the
-    //    clock_seq_hi_and_reserved to zero and one, respectively.
-    uuid.uuid[8] = 0x80 | (uuid.uuid[8] & 0x3F);
-
-    // 2. Set the four most significant bits (bits 12 through 15) of the
-    //    time_hi_and_version field to the 4-bit version number from Section 4.1.3.
-    uuid.uuid[6] = 0x40 | (uuid.uuid[6] & 0xF);
-
-    return uuid;
-}
-
-} // namespace Common
diff --git a/src/common/new_uuid.h b/src/common/new_uuid.h
deleted file mode 100644
index 44665ad5a..000000000
--- a/src/common/new_uuid.h
+++ /dev/null
@@ -1,141 +0,0 @@
-// Copyright 2022 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <functional>
-#include <string>
-#include <string_view>
-
-#include "common/common_types.h"
-
-namespace Common {
-
-struct NewUUID {
-    std::array<u8, 0x10> uuid{};
-
-    /// Constructs an invalid UUID.
-    constexpr NewUUID() = default;
-
-    /// Constructs a UUID from a reference to a 128 bit array.
-    constexpr explicit NewUUID(const std::array<u8, 16>& uuid_) : uuid{uuid_} {}
-
-    /**
-     * Constructs a UUID from either:
-     * 1. A 32 hexadecimal character string representing the bytes of the UUID
-     * 2. A RFC 4122 formatted UUID string, in the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
-     *
-     * The input string may contain uppercase or lowercase characters, but they must:
-     * 1. Contain valid hexadecimal characters (0-9, a-f, A-F)
-     * 2. Not contain the "0x" hexadecimal prefix
-     *
-     * Should the input string not meet the above requirements,
-     * an assert will be triggered and an invalid UUID is set instead.
-     */
-    explicit NewUUID(std::string_view uuid_string);
-
-    ~NewUUID() = default;
-
-    constexpr NewUUID(const NewUUID&) noexcept = default;
-    constexpr NewUUID(NewUUID&&) noexcept = default;
-
-    constexpr NewUUID& operator=(const NewUUID&) noexcept = default;
-    constexpr NewUUID& operator=(NewUUID&&) noexcept = default;
-
-    /**
-     * Returns whether the stored UUID is valid or not.
-     *
-     * @returns True if the stored UUID is valid, false otherwise.
-     */
-    constexpr bool IsValid() const {
-        return uuid != std::array<u8, 0x10>{};
-    }
-
-    /**
-     * Returns whether the stored UUID is invalid or not.
-     *
-     * @returns True if the stored UUID is invalid, false otherwise.
-     */
-    constexpr bool IsInvalid() const {
-        return !IsValid();
-    }
-
-    /**
-     * Returns a 32 hexadecimal character string representing the bytes of the UUID.
-     *
-     * @returns A 32 hexadecimal character string of the UUID.
-     */
-    std::string RawString() const;
-
-    /**
-     * Returns a RFC 4122 formatted UUID string in the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
-     *
-     * @returns A RFC 4122 formatted UUID string.
-     */
-    std::string FormattedString() const;
-
-    /**
-     * Returns a 64-bit hash of the UUID for use in hash table data structures.
-     *
-     * @returns A 64-bit hash of the UUID.
-     */
-    size_t Hash() const noexcept;
-
-    /// DO NOT USE. Copies the contents of the UUID into a u128.
-    u128 AsU128() const;
-
-    /**
-     * Creates a default UUID "yuzu Default UID".
-     *
-     * @returns A UUID with its bytes set to the ASCII values of "yuzu Default UID".
-     */
-    static constexpr NewUUID MakeDefault() {
-        return NewUUID{
-            {'y', 'u', 'z', 'u', ' ', 'D', 'e', 'f', 'a', 'u', 'l', 't', ' ', 'U', 'I', 'D'},
-        };
-    }
-
-    /**
-     * Creates a random UUID.
-     *
-     * @returns A random UUID.
-     */
-    static NewUUID MakeRandom();
-
-    /**
-     * Creates a random UUID with a seed.
-     *
-     * @param seed A seed to initialize the Mersenne-Twister RNG
-     *
-     * @returns A random UUID.
-     */
-    static NewUUID MakeRandomWithSeed(u32 seed);
-
-    /**
-     * Creates a random UUID. The generated UUID is RFC 4122 Version 4 compliant.
-     *
-     * @returns A random UUID that is RFC 4122 Version 4 compliant.
-     */
-    static NewUUID MakeRandomRFC4122V4();
-
-    friend constexpr bool operator==(const NewUUID& lhs, const NewUUID& rhs) = default;
-};
-static_assert(sizeof(NewUUID) == 0x10, "UUID has incorrect size.");
-
-/// An invalid UUID. This UUID has all its bytes set to 0.
-constexpr NewUUID InvalidUUID = {};
-
-} // namespace Common
-
-namespace std {
-
-template <>
-struct hash<Common::NewUUID> {
-    size_t operator()(const Common::NewUUID& uuid) const noexcept {
-        return uuid.Hash();
-    }
-};
-
-} // namespace std
diff --git a/src/common/uuid.cpp b/src/common/uuid.cpp
index d7435a6e9..10a1b86e0 100644
--- a/src/common/uuid.cpp
+++ b/src/common/uuid.cpp
@@ -1,21 +1,22 @@
-// Copyright 2018 yuzu Emulator Project
+// Copyright 2022 yuzu Emulator Project
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <bit>
 #include <random>
 
 #include <fmt/format.h>
 
 #include "common/assert.h"
+#include "common/tiny_mt.h"
 #include "common/uuid.h"
 
 namespace Common {
 
 namespace {
 
-bool IsHexDigit(char c) {
-    return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
-}
+constexpr size_t RawStringSize = sizeof(UUID) * 2;
+constexpr size_t FormattedStringSize = RawStringSize + 4;
 
 u8 HexCharToByte(char c) {
     if (c >= '0' && c <= '9') {
@@ -31,57 +32,157 @@ u8 HexCharToByte(char c) {
     return u8{0};
 }
 
-} // Anonymous namespace
+std::array<u8, 0x10> ConstructFromRawString(std::string_view raw_string) {
+    std::array<u8, 0x10> uuid;
+
+    for (size_t i = 0; i < RawStringSize; i += 2) {
+        uuid[i / 2] =
+            static_cast<u8>((HexCharToByte(raw_string[i]) << 4) | HexCharToByte(raw_string[i + 1]));
+    }
+
+    return uuid;
+}
+
+std::array<u8, 0x10> ConstructFromFormattedString(std::string_view formatted_string) {
+    std::array<u8, 0x10> uuid;
 
-u128 HexStringToU128(std::string_view hex_string) {
-    const size_t length = hex_string.length();
+    size_t i = 0;
 
-    // Detect "0x" prefix.
-    const bool has_0x_prefix = length > 2 && hex_string[0] == '0' && hex_string[1] == 'x';
-    const size_t offset = has_0x_prefix ? 2 : 0;
+    // Process the first 8 characters.
+    const auto* str = formatted_string.data();
 
-    // Check length.
-    if (length > 32 + offset) {
-        ASSERT_MSG(false, "hex_string has more than 32 hexadecimal characters!");
-        return INVALID_UUID;
+    for (; i < 4; ++i) {
+        uuid[i] = static_cast<u8>((HexCharToByte(*(str++)) << 4));
+        uuid[i] |= HexCharToByte(*(str++));
     }
 
-    u64 lo = 0;
-    u64 hi = 0;
-    for (size_t i = 0; i < length - offset; ++i) {
-        const char c = hex_string[length - 1 - i];
-        if (!IsHexDigit(c)) {
-            ASSERT_MSG(false, "{} is not a hexadecimal digit!", c);
-            return INVALID_UUID;
-        }
-        if (i < 16) {
-            lo |= u64{HexCharToByte(c)} << (i * 4);
-        }
-        if (i >= 16) {
-            hi |= u64{HexCharToByte(c)} << ((i - 16) * 4);
-        }
+    // Process the next 4 characters.
+    ++str;
+
+    for (; i < 6; ++i) {
+        uuid[i] = static_cast<u8>((HexCharToByte(*(str++)) << 4));
+        uuid[i] |= HexCharToByte(*(str++));
+    }
+
+    // Process the next 4 characters.
+    ++str;
+
+    for (; i < 8; ++i) {
+        uuid[i] = static_cast<u8>((HexCharToByte(*(str++)) << 4));
+        uuid[i] |= HexCharToByte(*(str++));
     }
-    return u128{lo, hi};
+
+    // Process the next 4 characters.
+    ++str;
+
+    for (; i < 10; ++i) {
+        uuid[i] = static_cast<u8>((HexCharToByte(*(str++)) << 4));
+        uuid[i] |= HexCharToByte(*(str++));
+    }
+
+    // Process the last 12 characters.
+    ++str;
+
+    for (; i < 16; ++i) {
+        uuid[i] = static_cast<u8>((HexCharToByte(*(str++)) << 4));
+        uuid[i] |= HexCharToByte(*(str++));
+    }
+
+    return uuid;
 }
 
-UUID UUID::Generate() {
+std::array<u8, 0x10> ConstructUUID(std::string_view uuid_string) {
+    const auto length = uuid_string.length();
+
+    if (length == 0) {
+        return {};
+    }
+
+    // Check if the input string contains 32 hexadecimal characters.
+    if (length == RawStringSize) {
+        return ConstructFromRawString(uuid_string);
+    }
+
+    // Check if the input string has the length of a RFC 4122 formatted UUID string.
+    if (length == FormattedStringSize) {
+        return ConstructFromFormattedString(uuid_string);
+    }
+
+    ASSERT_MSG(false, "UUID string has an invalid length of {} characters!", length);
+
+    return {};
+}
+
+} // Anonymous namespace
+
+UUID::UUID(std::string_view uuid_string) : uuid{ConstructUUID(uuid_string)} {}
+
+std::string UUID::RawString() const {
+    return fmt::format("{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}"
+                       "{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}",
+                       uuid[0], uuid[1], uuid[2], uuid[3], uuid[4], uuid[5], uuid[6], uuid[7],
+                       uuid[8], uuid[9], uuid[10], uuid[11], uuid[12], uuid[13], uuid[14],
+                       uuid[15]);
+}
+
+std::string UUID::FormattedString() const {
+    return fmt::format("{:02x}{:02x}{:02x}{:02x}"
+                       "-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-"
+                       "{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}",
+                       uuid[0], uuid[1], uuid[2], uuid[3], uuid[4], uuid[5], uuid[6], uuid[7],
+                       uuid[8], uuid[9], uuid[10], uuid[11], uuid[12], uuid[13], uuid[14],
+                       uuid[15]);
+}
+
+size_t UUID::Hash() const noexcept {
+    u64 hash;
+    u64 temp;
+
+    std::memcpy(&hash, uuid.data(), sizeof(u64));
+    std::memcpy(&temp, uuid.data() + 8, sizeof(u64));
+
+    return hash ^ std::rotl(temp, 1);
+}
+
+u128 UUID::AsU128() const {
+    u128 uuid_old;
+    std::memcpy(&uuid_old, uuid.data(), sizeof(UUID));
+    return uuid_old;
+}
+
+UUID UUID::MakeRandom() {
     std::random_device device;
-    std::mt19937 gen(device());
-    std::uniform_int_distribution<u64> distribution(1, std::numeric_limits<u64>::max());
-    return UUID{distribution(gen), distribution(gen)};
+
+    return MakeRandomWithSeed(device());
 }
 
-std::string UUID::Format() const {
-    return fmt::format("{:016x}{:016x}", uuid[1], uuid[0]);
+UUID UUID::MakeRandomWithSeed(u32 seed) {
+    // Create and initialize our RNG.
+    TinyMT rng;
+    rng.Initialize(seed);
+
+    UUID uuid;
+
+    // Populate the UUID with random bytes.
+    rng.GenerateRandomBytes(uuid.uuid.data(), sizeof(UUID));
+
+    return uuid;
 }
 
-std::string UUID::FormatSwitch() const {
-    std::array<u8, 16> s{};
-    std::memcpy(s.data(), uuid.data(), sizeof(u128));
-    return fmt::format("{:02x}{:02x}{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{"
-                       ":02x}{:02x}{:02x}{:02x}{:02x}",
-                       s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9], s[10], s[11],
-                       s[12], s[13], s[14], s[15]);
+UUID UUID::MakeRandomRFC4122V4() {
+    auto uuid = MakeRandom();
+
+    // According to Proposed Standard RFC 4122 Section 4.4, we must:
+
+    // 1. Set the two most significant bits (bits 6 and 7) of the
+    //    clock_seq_hi_and_reserved to zero and one, respectively.
+    uuid.uuid[8] = 0x80 | (uuid.uuid[8] & 0x3F);
+
+    // 2. Set the four most significant bits (bits 12 through 15) of the
+    //    time_hi_and_version field to the 4-bit version number from Section 4.1.3.
+    uuid.uuid[6] = 0x40 | (uuid.uuid[6] & 0xF);
+
+    return uuid;
 }
 
 } // namespace Common
diff --git a/src/common/uuid.h b/src/common/uuid.h
index 8ea01f8da..fe31e64e6 100644
--- a/src/common/uuid.h
+++ b/src/common/uuid.h
@@ -1,9 +1,11 @@
-// Copyright 2018 yuzu Emulator Project
+// Copyright 2022 yuzu Emulator Project
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
 #pragma once
 
+#include <array>
+#include <functional>
 #include <string>
 #include <string_view>
 
@@ -11,69 +13,119 @@
 
 namespace Common {
 
-constexpr u128 INVALID_UUID{{0, 0}};
-
-/**
- * Converts a hex string to a 128-bit unsigned integer.
- *
- * The hex string can be formatted in lowercase or uppercase, with or without the "0x" prefix.
- *
- * This function will assert and return INVALID_UUID under the following conditions:
- * - If the hex string is more than 32 characters long
- * - If the hex string contains non-hexadecimal characters
- *
- * @param hex_string Hexadecimal string
- *
- * @returns A 128-bit unsigned integer if successfully converted, INVALID_UUID otherwise.
- */
-[[nodiscard]] u128 HexStringToU128(std::string_view hex_string);
-
 struct UUID {
-    // UUIDs which are 0 are considered invalid!
-    u128 uuid;
-    UUID() = default;
-    constexpr explicit UUID(const u128& id) : uuid{id} {}
-    constexpr explicit UUID(const u64 lo, const u64 hi) : uuid{{lo, hi}} {}
-    explicit UUID(std::string_view hex_string) {
-        uuid = HexStringToU128(hex_string);
-    }
-
-    [[nodiscard]] constexpr explicit operator bool() const {
-        return uuid != INVALID_UUID;
-    }
-
-    [[nodiscard]] constexpr bool operator==(const UUID& rhs) const {
-        return uuid == rhs.uuid;
-    }
-
-    [[nodiscard]] constexpr bool operator!=(const UUID& rhs) const {
-        return !operator==(rhs);
-    }
-
-    // TODO(ogniK): Properly generate uuids based on RFC-4122
-    [[nodiscard]] static UUID Generate();
-
-    // Set the UUID to {0,0} to be considered an invalid user
-    constexpr void Invalidate() {
-        uuid = INVALID_UUID;
+    std::array<u8, 0x10> uuid{};
+
+    /// Constructs an invalid UUID.
+    constexpr UUID() = default;
+
+    /// Constructs a UUID from a reference to a 128 bit array.
+    constexpr explicit UUID(const std::array<u8, 16>& uuid_) : uuid{uuid_} {}
+
+    /**
+     * Constructs a UUID from either:
+     * 1. A 32 hexadecimal character string representing the bytes of the UUID
+     * 2. A RFC 4122 formatted UUID string, in the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+     *
+     * The input string may contain uppercase or lowercase characters, but they must:
+     * 1. Contain valid hexadecimal characters (0-9, a-f, A-F)
+     * 2. Not contain the "0x" hexadecimal prefix
+     *
+     * Should the input string not meet the above requirements,
+     * an assert will be triggered and an invalid UUID is set instead.
+     */
+    explicit UUID(std::string_view uuid_string);
+
+    ~UUID() = default;
+
+    constexpr UUID(const UUID&) noexcept = default;
+    constexpr UUID(UUID&&) noexcept = default;
+
+    constexpr UUID& operator=(const UUID&) noexcept = default;
+    constexpr UUID& operator=(UUID&&) noexcept = default;
+
+    /**
+     * Returns whether the stored UUID is valid or not.
+     *
+     * @returns True if the stored UUID is valid, false otherwise.
+     */
+    constexpr bool IsValid() const {
+        return uuid != std::array<u8, 0x10>{};
     }
 
-    [[nodiscard]] constexpr bool IsInvalid() const {
-        return uuid == INVALID_UUID;
-    }
-    [[nodiscard]] constexpr bool IsValid() const {
-        return !IsInvalid();
+    /**
+     * Returns whether the stored UUID is invalid or not.
+     *
+     * @returns True if the stored UUID is invalid, false otherwise.
+     */
+    constexpr bool IsInvalid() const {
+        return !IsValid();
     }
 
-    // TODO(ogniK): Properly generate a Nintendo ID
-    [[nodiscard]] constexpr u64 GetNintendoID() const {
-        return uuid[0];
+    /**
+     * Returns a 32 hexadecimal character string representing the bytes of the UUID.
+     *
+     * @returns A 32 hexadecimal character string of the UUID.
+     */
+    std::string RawString() const;
+
+    /**
+     * Returns a RFC 4122 formatted UUID string in the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
+     *
+     * @returns A RFC 4122 formatted UUID string.
+     */
+    std::string FormattedString() const;
+
+    /**
+     * Returns a 64-bit hash of the UUID for use in hash table data structures.
+     *
+     * @returns A 64-bit hash of the UUID.
+     */
+    size_t Hash() const noexcept;
+
+    /// DO NOT USE. Copies the contents of the UUID into a u128.
+    u128 AsU128() const;
+
+    /**
+     * Creates a default UUID "yuzu Default UID".
+     *
+     * @returns A UUID with its bytes set to the ASCII values of "yuzu Default UID".
+     */
+    static constexpr UUID MakeDefault() {
+        return UUID{
+            {'y', 'u', 'z', 'u', ' ', 'D', 'e', 'f', 'a', 'u', 'l', 't', ' ', 'U', 'I', 'D'},
+        };
     }
 
-    [[nodiscard]] std::string Format() const;
-    [[nodiscard]] std::string FormatSwitch() const;
+    /**
+     * Creates a random UUID.
+     *
+     * @returns A random UUID.
+     */
+    static UUID MakeRandom();
+
+    /**
+     * Creates a random UUID with a seed.
+     *
+     * @param seed A seed to initialize the Mersenne-Twister RNG
+     *
+     * @returns A random UUID.
+     */
+    static UUID MakeRandomWithSeed(u32 seed);
+
+    /**
+     * Creates a random UUID. The generated UUID is RFC 4122 Version 4 compliant.
+     *
+     * @returns A random UUID that is RFC 4122 Version 4 compliant.
+     */
+    static UUID MakeRandomRFC4122V4();
+
+    friend constexpr bool operator==(const UUID& lhs, const UUID& rhs) = default;
 };
-static_assert(sizeof(UUID) == 16, "UUID is an invalid size!");
+static_assert(sizeof(UUID) == 0x10, "UUID has incorrect size.");
+
+/// An invalid UUID. This UUID has all its bytes set to 0.
+constexpr UUID InvalidUUID = {};
 
 } // namespace Common
 
@@ -82,7 +134,7 @@ namespace std {
 template <>
 struct hash<Common::UUID> {
     size_t operator()(const Common::UUID& uuid) const noexcept {
-        return uuid.uuid[1] ^ uuid.uuid[0];
+        return uuid.Hash();
     }
 };
 
diff --git a/src/core/frontend/applets/profile_select.cpp b/src/core/frontend/applets/profile_select.cpp
index a7ff2ccf9..4c58c310f 100644
--- a/src/core/frontend/applets/profile_select.cpp
+++ b/src/core/frontend/applets/profile_select.cpp
@@ -11,9 +11,9 @@ namespace Core::Frontend {
 ProfileSelectApplet::~ProfileSelectApplet() = default;
 
 void DefaultProfileSelectApplet::SelectProfile(
-    std::function<void(std::optional<Common::NewUUID>)> callback) const {
+    std::function<void(std::optional<Common::UUID>)> callback) const {
     Service::Account::ProfileManager manager;
-    callback(manager.GetUser(Settings::values.current_user.GetValue()).value_or(Common::NewUUID{}));
+    callback(manager.GetUser(Settings::values.current_user.GetValue()).value_or(Common::UUID{}));
     LOG_INFO(Service_ACC, "called, selecting current user instead of prompting...");
 }
 
diff --git a/src/core/frontend/applets/profile_select.h b/src/core/frontend/applets/profile_select.h
index 5b2346e72..3506b9885 100644
--- a/src/core/frontend/applets/profile_select.h
+++ b/src/core/frontend/applets/profile_select.h
@@ -6,7 +6,7 @@
 
 #include <functional>
 #include <optional>
-#include "common/new_uuid.h"
+#include "common/uuid.h"
 
 namespace Core::Frontend {
 
@@ -14,13 +14,12 @@ class ProfileSelectApplet {
 public:
     virtual ~ProfileSelectApplet();
 
-    virtual void SelectProfile(
-        std::function<void(std::optional<Common::NewUUID>)> callback) const = 0;
+    virtual void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback) const = 0;
 };
 
 class DefaultProfileSelectApplet final : public ProfileSelectApplet {
 public:
-    void SelectProfile(std::function<void(std::optional<Common::NewUUID>)> callback) const override;
+    void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback) const override;
 };
 
 } // namespace Core::Frontend
diff --git a/src/core/hid/emulated_controller.cpp b/src/core/hid/emulated_controller.cpp
index 44e9f22b9..2bee173b3 100644
--- a/src/core/hid/emulated_controller.cpp
+++ b/src/core/hid/emulated_controller.cpp
@@ -204,7 +204,7 @@ void EmulatedController::ReloadInput() {
         if (!button_devices[index]) {
             continue;
         }
-        const auto uuid = Common::NewUUID{button_params[index].Get("guid", "")};
+        const auto uuid = Common::UUID{button_params[index].Get("guid", "")};
         button_devices[index]->SetCallback({
             .on_change =
                 [this, index, uuid](const Common::Input::CallbackStatus& callback) {
@@ -218,7 +218,7 @@ void EmulatedController::ReloadInput() {
         if (!stick_devices[index]) {
             continue;
         }
-        const auto uuid = Common::NewUUID{stick_params[index].Get("guid", "")};
+        const auto uuid = Common::UUID{stick_params[index].Get("guid", "")};
         stick_devices[index]->SetCallback({
             .on_change =
                 [this, index, uuid](const Common::Input::CallbackStatus& callback) {
@@ -232,7 +232,7 @@ void EmulatedController::ReloadInput() {
         if (!trigger_devices[index]) {
             continue;
         }
-        const auto uuid = Common::NewUUID{trigger_params[index].Get("guid", "")};
+        const auto uuid = Common::UUID{trigger_params[index].Get("guid", "")};
         trigger_devices[index]->SetCallback({
             .on_change =
                 [this, index, uuid](const Common::Input::CallbackStatus& callback) {
@@ -269,7 +269,7 @@ void EmulatedController::ReloadInput() {
     }
 
     // Use a common UUID for TAS
-    static constexpr Common::NewUUID TAS_UUID = Common::NewUUID{
+    static constexpr Common::UUID TAS_UUID = Common::UUID{
         {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xA5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}};
 
     // Register TAS devices. No need to force update
@@ -490,7 +490,7 @@ void EmulatedController::SetMotionParam(std::size_t index, Common::ParamPackage
 }
 
 void EmulatedController::SetButton(const Common::Input::CallbackStatus& callback, std::size_t index,
-                                   Common::NewUUID uuid) {
+                                   Common::UUID uuid) {
     if (index >= controller.button_values.size()) {
         return;
     }
@@ -639,7 +639,7 @@ void EmulatedController::SetButton(const Common::Input::CallbackStatus& callback
 }
 
 void EmulatedController::SetStick(const Common::Input::CallbackStatus& callback, std::size_t index,
-                                  Common::NewUUID uuid) {
+                                  Common::UUID uuid) {
     if (index >= controller.stick_values.size()) {
         return;
     }
@@ -689,7 +689,7 @@ void EmulatedController::SetStick(const Common::Input::CallbackStatus& callback,
 }
 
 void EmulatedController::SetTrigger(const Common::Input::CallbackStatus& callback,
-                                    std::size_t index, Common::NewUUID uuid) {
+                                    std::size_t index, Common::UUID uuid) {
     if (index >= controller.trigger_values.size()) {
         return;
     }
diff --git a/src/core/hid/emulated_controller.h b/src/core/hid/emulated_controller.h
index ed61e9522..d8642c5b3 100644
--- a/src/core/hid/emulated_controller.h
+++ b/src/core/hid/emulated_controller.h
@@ -354,7 +354,7 @@ private:
      * @param index Button ID of the to be updated
      */
     void SetButton(const Common::Input::CallbackStatus& callback, std::size_t index,
-                   Common::NewUUID uuid);
+                   Common::UUID uuid);
 
     /**
      * Updates the analog stick status of the controller
@@ -362,7 +362,7 @@ private:
      * @param index stick ID of the to be updated
      */
     void SetStick(const Common::Input::CallbackStatus& callback, std::size_t index,
-                  Common::NewUUID uuid);
+                  Common::UUID uuid);
 
     /**
      * Updates the trigger status of the controller
@@ -370,7 +370,7 @@ private:
      * @param index trigger ID of the to be updated
      */
     void SetTrigger(const Common::Input::CallbackStatus& callback, std::size_t index,
-                    Common::NewUUID uuid);
+                    Common::UUID uuid);
 
     /**
      * Updates the motion status of the controller
diff --git a/src/core/hid/hid_types.h b/src/core/hid/hid_types.h
index a4ccdf11c..778b328b9 100644
--- a/src/core/hid/hid_types.h
+++ b/src/core/hid/hid_types.h
@@ -7,8 +7,8 @@
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
-#include "common/new_uuid.h"
 #include "common/point.h"
+#include "common/uuid.h"
 
 namespace Core::HID {
 
diff --git a/src/core/hle/service/acc/acc.cpp b/src/core/hle/service/acc/acc.cpp
index 6abb7dbc4..e34ef5a78 100644
--- a/src/core/hle/service/acc/acc.cpp
+++ b/src/core/hle/service/acc/acc.cpp
@@ -39,7 +39,7 @@ constexpr ResultCode ERR_FAILED_SAVE_DATA{ErrorModule::Account, 100};
 // Thumbnails are hard coded to be at least this size
 constexpr std::size_t THUMBNAIL_SIZE = 0x24000;
 
-static std::filesystem::path GetImagePath(const Common::NewUUID& uuid) {
+static std::filesystem::path GetImagePath(const Common::UUID& uuid) {
     return Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir) /
            fmt::format("system/save/8000000000000010/su/avators/{}.jpg", uuid.FormattedString());
 }
@@ -51,7 +51,7 @@ static constexpr u32 SanitizeJPEGSize(std::size_t size) {
 
 class IManagerForSystemService final : public ServiceFramework<IManagerForSystemService> {
 public:
-    explicit IManagerForSystemService(Core::System& system_, Common::NewUUID)
+    explicit IManagerForSystemService(Core::System& system_, Common::UUID)
         : ServiceFramework{system_, "IManagerForSystemService"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -87,7 +87,7 @@ public:
 // 3.0.0+
 class IFloatingRegistrationRequest final : public ServiceFramework<IFloatingRegistrationRequest> {
 public:
-    explicit IFloatingRegistrationRequest(Core::System& system_, Common::NewUUID)
+    explicit IFloatingRegistrationRequest(Core::System& system_, Common::UUID)
         : ServiceFramework{system_, "IFloatingRegistrationRequest"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -112,7 +112,7 @@ public:
 
 class IAdministrator final : public ServiceFramework<IAdministrator> {
 public:
-    explicit IAdministrator(Core::System& system_, Common::NewUUID)
+    explicit IAdministrator(Core::System& system_, Common::UUID)
         : ServiceFramework{system_, "IAdministrator"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -170,7 +170,7 @@ public:
 
 class IAuthorizationRequest final : public ServiceFramework<IAuthorizationRequest> {
 public:
-    explicit IAuthorizationRequest(Core::System& system_, Common::NewUUID)
+    explicit IAuthorizationRequest(Core::System& system_, Common::UUID)
         : ServiceFramework{system_, "IAuthorizationRequest"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -189,7 +189,7 @@ public:
 
 class IOAuthProcedure final : public ServiceFramework<IOAuthProcedure> {
 public:
-    explicit IOAuthProcedure(Core::System& system_, Common::NewUUID)
+    explicit IOAuthProcedure(Core::System& system_, Common::UUID)
         : ServiceFramework{system_, "IOAuthProcedure"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -208,7 +208,7 @@ public:
 // 3.0.0+
 class IOAuthProcedureForExternalNsa final : public ServiceFramework<IOAuthProcedureForExternalNsa> {
 public:
-    explicit IOAuthProcedureForExternalNsa(Core::System& system_, Common::NewUUID)
+    explicit IOAuthProcedureForExternalNsa(Core::System& system_, Common::UUID)
         : ServiceFramework{system_, "IOAuthProcedureForExternalNsa"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -231,7 +231,7 @@ public:
 class IOAuthProcedureForNintendoAccountLinkage final
     : public ServiceFramework<IOAuthProcedureForNintendoAccountLinkage> {
 public:
-    explicit IOAuthProcedureForNintendoAccountLinkage(Core::System& system_, Common::NewUUID)
+    explicit IOAuthProcedureForNintendoAccountLinkage(Core::System& system_, Common::UUID)
         : ServiceFramework{system_, "IOAuthProcedureForNintendoAccountLinkage"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -252,7 +252,7 @@ public:
 
 class INotifier final : public ServiceFramework<INotifier> {
 public:
-    explicit INotifier(Core::System& system_, Common::NewUUID)
+    explicit INotifier(Core::System& system_, Common::UUID)
         : ServiceFramework{system_, "INotifier"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -267,7 +267,7 @@ public:
 class IProfileCommon : public ServiceFramework<IProfileCommon> {
 public:
     explicit IProfileCommon(Core::System& system_, const char* name, bool editor_commands,
-                            Common::NewUUID user_id_, ProfileManager& profile_manager_)
+                            Common::UUID user_id_, ProfileManager& profile_manager_)
         : ServiceFramework{system_, name}, profile_manager{profile_manager_}, user_id{user_id_} {
         static const FunctionInfo functions[] = {
             {0, &IProfileCommon::Get, "Get"},
@@ -435,26 +435,26 @@ protected:
     }
 
     ProfileManager& profile_manager;
-    Common::NewUUID user_id{}; ///< The user id this profile refers to.
+    Common::UUID user_id{}; ///< The user id this profile refers to.
 };
 
 class IProfile final : public IProfileCommon {
 public:
-    explicit IProfile(Core::System& system_, Common::NewUUID user_id_,
+    explicit IProfile(Core::System& system_, Common::UUID user_id_,
                       ProfileManager& profile_manager_)
         : IProfileCommon{system_, "IProfile", false, user_id_, profile_manager_} {}
 };
 
 class IProfileEditor final : public IProfileCommon {
 public:
-    explicit IProfileEditor(Core::System& system_, Common::NewUUID user_id_,
+    explicit IProfileEditor(Core::System& system_, Common::UUID user_id_,
                             ProfileManager& profile_manager_)
         : IProfileCommon{system_, "IProfileEditor", true, user_id_, profile_manager_} {}
 };
 
 class ISessionObject final : public ServiceFramework<ISessionObject> {
 public:
-    explicit ISessionObject(Core::System& system_, Common::NewUUID)
+    explicit ISessionObject(Core::System& system_, Common::UUID)
         : ServiceFramework{system_, "ISessionObject"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -468,7 +468,7 @@ public:
 
 class IGuestLoginRequest final : public ServiceFramework<IGuestLoginRequest> {
 public:
-    explicit IGuestLoginRequest(Core::System& system_, Common::NewUUID)
+    explicit IGuestLoginRequest(Core::System& system_, Common::UUID)
         : ServiceFramework{system_, "IGuestLoginRequest"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -514,7 +514,7 @@ protected:
 
 class IManagerForApplication final : public ServiceFramework<IManagerForApplication> {
 public:
-    explicit IManagerForApplication(Core::System& system_, Common::NewUUID user_id_)
+    explicit IManagerForApplication(Core::System& system_, Common::UUID user_id_)
         : ServiceFramework{system_, "IManagerForApplication"},
           ensure_token_id{std::make_shared<EnsureTokenIdCacheAsyncInterface>(system)},
           user_id{user_id_} {
@@ -587,14 +587,14 @@ private:
     }
 
     std::shared_ptr<EnsureTokenIdCacheAsyncInterface> ensure_token_id{};
-    Common::NewUUID user_id{};
+    Common::UUID user_id{};
 };
 
 // 6.0.0+
 class IAsyncNetworkServiceLicenseKindContext final
     : public ServiceFramework<IAsyncNetworkServiceLicenseKindContext> {
 public:
-    explicit IAsyncNetworkServiceLicenseKindContext(Core::System& system_, Common::NewUUID)
+    explicit IAsyncNetworkServiceLicenseKindContext(Core::System& system_, Common::UUID)
         : ServiceFramework{system_, "IAsyncNetworkServiceLicenseKindContext"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -614,7 +614,7 @@ public:
 class IOAuthProcedureForUserRegistration final
     : public ServiceFramework<IOAuthProcedureForUserRegistration> {
 public:
-    explicit IOAuthProcedureForUserRegistration(Core::System& system_, Common::NewUUID)
+    explicit IOAuthProcedureForUserRegistration(Core::System& system_, Common::UUID)
         : ServiceFramework{system_, "IOAuthProcedureForUserRegistration"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -638,8 +638,7 @@ public:
 
 class DAUTH_O final : public ServiceFramework<DAUTH_O> {
 public:
-    explicit DAUTH_O(Core::System& system_, Common::NewUUID)
-        : ServiceFramework{system_, "dauth:o"} {
+    explicit DAUTH_O(Core::System& system_, Common::UUID) : ServiceFramework{system_, "dauth:o"} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, nullptr, "EnsureAuthenticationTokenCacheAsync"},
@@ -663,7 +662,7 @@ public:
 // 6.0.0+
 class IAsyncResult final : public ServiceFramework<IAsyncResult> {
 public:
-    explicit IAsyncResult(Core::System& system_, Common::NewUUID)
+    explicit IAsyncResult(Core::System& system_, Common::UUID)
         : ServiceFramework{system_, "IAsyncResult"} {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -687,7 +686,7 @@ void Module::Interface::GetUserCount(Kernel::HLERequestContext& ctx) {
 
 void Module::Interface::GetUserExistence(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    Common::NewUUID user_id = rp.PopRaw<Common::NewUUID>();
+    Common::UUID user_id = rp.PopRaw<Common::UUID>();
     LOG_DEBUG(Service_ACC, "called user_id=0x{}", user_id.RawString());
 
     IPC::ResponseBuilder rb{ctx, 3};
@@ -713,12 +712,12 @@ void Module::Interface::GetLastOpenedUser(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_ACC, "called");
     IPC::ResponseBuilder rb{ctx, 6};
     rb.Push(ResultSuccess);
-    rb.PushRaw<Common::NewUUID>(profile_manager->GetLastOpenedUser());
+    rb.PushRaw<Common::UUID>(profile_manager->GetLastOpenedUser());
 }
 
 void Module::Interface::GetProfile(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    Common::NewUUID user_id = rp.PopRaw<Common::NewUUID>();
+    Common::UUID user_id = rp.PopRaw<Common::UUID>();
     LOG_DEBUG(Service_ACC, "called user_id=0x{}", user_id.RawString());
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
@@ -832,7 +831,7 @@ void Module::Interface::InitializeApplicationInfoV2(Kernel::HLERequestContext& c
 
 void Module::Interface::GetProfileEditor(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    Common::NewUUID user_id = rp.PopRaw<Common::NewUUID>();
+    Common::UUID user_id = rp.PopRaw<Common::UUID>();
 
     LOG_DEBUG(Service_ACC, "called, user_id=0x{}", user_id.RawString());
 
@@ -874,7 +873,7 @@ void Module::Interface::ListOpenContextStoredUsers(Kernel::HLERequestContext& ct
 
 void Module::Interface::StoreSaveDataThumbnailApplication(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    const auto uuid = rp.PopRaw<Common::NewUUID>();
+    const auto uuid = rp.PopRaw<Common::UUID>();
 
     LOG_WARNING(Service_ACC, "(STUBBED) called, uuid=0x{}", uuid.RawString());
 
@@ -887,7 +886,7 @@ void Module::Interface::StoreSaveDataThumbnailApplication(Kernel::HLERequestCont
 
 void Module::Interface::StoreSaveDataThumbnailSystem(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    const auto uuid = rp.PopRaw<Common::NewUUID>();
+    const auto uuid = rp.PopRaw<Common::UUID>();
     const auto tid = rp.Pop<u64_le>();
 
     LOG_WARNING(Service_ACC, "(STUBBED) called, uuid=0x{}, tid={:016X}", uuid.RawString(), tid);
@@ -895,7 +894,7 @@ void Module::Interface::StoreSaveDataThumbnailSystem(Kernel::HLERequestContext&
 }
 
 void Module::Interface::StoreSaveDataThumbnail(Kernel::HLERequestContext& ctx,
-                                               const Common::NewUUID& uuid, const u64 tid) {
+                                               const Common::UUID& uuid, const u64 tid) {
     IPC::ResponseBuilder rb{ctx, 2};
 
     if (tid == 0) {
diff --git a/src/core/hle/service/acc/acc.h b/src/core/hle/service/acc/acc.h
index b57342701..f7e9bc4f8 100644
--- a/src/core/hle/service/acc/acc.h
+++ b/src/core/hle/service/acc/acc.h
@@ -4,7 +4,7 @@
 
 #pragma once
 
-#include "common/new_uuid.h"
+#include "common/uuid.h"
 #include "core/hle/service/glue/glue_manager.h"
 #include "core/hle/service/service.h"
 
@@ -43,7 +43,7 @@ public:
 
     private:
         ResultCode InitializeApplicationInfoBase();
-        void StoreSaveDataThumbnail(Kernel::HLERequestContext& ctx, const Common::NewUUID& uuid,
+        void StoreSaveDataThumbnail(Kernel::HLERequestContext& ctx, const Common::UUID& uuid,
                                     const u64 tid);
 
         enum class ApplicationType : u32_le {
diff --git a/src/core/hle/service/acc/profile_manager.cpp b/src/core/hle/service/acc/profile_manager.cpp
index 366f3fe14..fba847142 100644
--- a/src/core/hle/service/acc/profile_manager.cpp
+++ b/src/core/hle/service/acc/profile_manager.cpp
@@ -16,11 +16,11 @@
 namespace Service::Account {
 
 namespace FS = Common::FS;
-using Common::NewUUID;
+using Common::UUID;
 
 struct UserRaw {
-    NewUUID uuid{};
-    NewUUID uuid2{};
+    UUID uuid{};
+    UUID uuid2{};
     u64 timestamp{};
     ProfileUsername username{};
     ProfileData extra_data{};
@@ -45,7 +45,7 @@ ProfileManager::ProfileManager() {
 
     // Create an user if none are present
     if (user_count == 0) {
-        CreateNewUser(NewUUID::MakeRandom(), "yuzu");
+        CreateNewUser(UUID::MakeRandom(), "yuzu");
     }
 
     auto current =
@@ -97,7 +97,7 @@ ResultCode ProfileManager::AddUser(const ProfileInfo& user) {
 
 /// Create a new user on the system. If the uuid of the user already exists, the user is not
 /// created.
-ResultCode ProfileManager::CreateNewUser(NewUUID uuid, const ProfileUsername& username) {
+ResultCode ProfileManager::CreateNewUser(UUID uuid, const ProfileUsername& username) {
     if (user_count == MAX_USERS) {
         return ERROR_TOO_MANY_USERS;
     }
@@ -124,7 +124,7 @@ ResultCode ProfileManager::CreateNewUser(NewUUID uuid, const ProfileUsername& us
 /// Creates a new user on the system. This function allows a much simpler method of registration
 /// specifically by allowing an std::string for the username. This is required specifically since
 /// we're loading a string straight from the config
-ResultCode ProfileManager::CreateNewUser(NewUUID uuid, const std::string& username) {
+ResultCode ProfileManager::CreateNewUser(UUID uuid, const std::string& username) {
     ProfileUsername username_output{};
 
     if (username.size() > username_output.size()) {
@@ -135,7 +135,7 @@ ResultCode ProfileManager::CreateNewUser(NewUUID uuid, const std::string& userna
     return CreateNewUser(uuid, username_output);
 }
 
-std::optional<NewUUID> ProfileManager::GetUser(std::size_t index) const {
+std::optional<UUID> ProfileManager::GetUser(std::size_t index) const {
     if (index >= MAX_USERS) {
         return std::nullopt;
     }
@@ -144,7 +144,7 @@ std::optional<NewUUID> ProfileManager::GetUser(std::size_t index) const {
 }
 
 /// Returns a users profile index based on their user id.
-std::optional<std::size_t> ProfileManager::GetUserIndex(const NewUUID& uuid) const {
+std::optional<std::size_t> ProfileManager::GetUserIndex(const UUID& uuid) const {
     if (uuid.IsInvalid()) {
         return std::nullopt;
     }
@@ -176,7 +176,7 @@ bool ProfileManager::GetProfileBase(std::optional<std::size_t> index, ProfileBas
 }
 
 /// Returns the data structure used by the switch when GetProfileBase is called on acc:*
-bool ProfileManager::GetProfileBase(NewUUID uuid, ProfileBase& profile) const {
+bool ProfileManager::GetProfileBase(UUID uuid, ProfileBase& profile) const {
     const auto idx = GetUserIndex(uuid);
     return GetProfileBase(idx, profile);
 }
@@ -203,7 +203,7 @@ std::size_t ProfileManager::GetOpenUserCount() const {
 }
 
 /// Checks if a user id exists in our profile manager
-bool ProfileManager::UserExists(NewUUID uuid) const {
+bool ProfileManager::UserExists(UUID uuid) const {
     return GetUserIndex(uuid).has_value();
 }
 
@@ -215,7 +215,7 @@ bool ProfileManager::UserExistsIndex(std::size_t index) const {
 }
 
 /// Opens a specific user
-void ProfileManager::OpenUser(NewUUID uuid) {
+void ProfileManager::OpenUser(UUID uuid) {
     const auto idx = GetUserIndex(uuid);
     if (!idx) {
         return;
@@ -226,7 +226,7 @@ void ProfileManager::OpenUser(NewUUID uuid) {
 }
 
 /// Closes a specific user
-void ProfileManager::CloseUser(NewUUID uuid) {
+void ProfileManager::CloseUser(UUID uuid) {
     const auto idx = GetUserIndex(uuid);
     if (!idx) {
         return;
@@ -253,12 +253,12 @@ UserIDArray ProfileManager::GetOpenUsers() const {
         return Common::InvalidUUID;
     });
     std::stable_partition(output.begin(), output.end(),
-                          [](const NewUUID& uuid) { return uuid.IsValid(); });
+                          [](const UUID& uuid) { return uuid.IsValid(); });
     return output;
 }
 
 /// Returns the last user which was opened
-NewUUID ProfileManager::GetLastOpenedUser() const {
+UUID ProfileManager::GetLastOpenedUser() const {
     return last_opened_user;
 }
 
@@ -273,7 +273,7 @@ bool ProfileManager::GetProfileBaseAndData(std::optional<std::size_t> index, Pro
 }
 
 /// Return the users profile base and the unknown arbitary data.
-bool ProfileManager::GetProfileBaseAndData(NewUUID uuid, ProfileBase& profile,
+bool ProfileManager::GetProfileBaseAndData(UUID uuid, ProfileBase& profile,
                                            ProfileData& data) const {
     const auto idx = GetUserIndex(uuid);
     return GetProfileBaseAndData(idx, profile, data);
@@ -292,7 +292,7 @@ bool ProfileManager::CanSystemRegisterUser() const {
     // emulate qlaunch. Update this to dynamically change.
 }
 
-bool ProfileManager::RemoveUser(NewUUID uuid) {
+bool ProfileManager::RemoveUser(UUID uuid) {
     const auto index = GetUserIndex(uuid);
     if (!index) {
         return false;
@@ -304,7 +304,7 @@ bool ProfileManager::RemoveUser(NewUUID uuid) {
     return true;
 }
 
-bool ProfileManager::SetProfileBase(NewUUID uuid, const ProfileBase& profile_new) {
+bool ProfileManager::SetProfileBase(UUID uuid, const ProfileBase& profile_new) {
     const auto index = GetUserIndex(uuid);
     if (!index || profile_new.user_uuid.IsInvalid()) {
         return false;
@@ -318,7 +318,7 @@ bool ProfileManager::SetProfileBase(NewUUID uuid, const ProfileBase& profile_new
     return true;
 }
 
-bool ProfileManager::SetProfileBaseAndData(Common::NewUUID uuid, const ProfileBase& profile_new,
+bool ProfileManager::SetProfileBaseAndData(Common::UUID uuid, const ProfileBase& profile_new,
                                            const ProfileData& data_new) {
     const auto index = GetUserIndex(uuid);
     if (index.has_value() && SetProfileBase(uuid, profile_new)) {
@@ -336,14 +336,14 @@ void ProfileManager::ParseUserSaveFile() {
 
     if (!save.IsOpen()) {
         LOG_WARNING(Service_ACC, "Failed to load profile data from save data... Generating new "
-                                 "user 'yuzu' with random NewUUID.");
+                                 "user 'yuzu' with random UUID.");
         return;
     }
 
     ProfileDataRaw data;
     if (!save.ReadObject(data)) {
         LOG_WARNING(Service_ACC, "profiles.dat is smaller than expected... Generating new user "
-                                 "'yuzu' with random NewUUID.");
+                                 "'yuzu' with random UUID.");
         return;
     }
 
diff --git a/src/core/hle/service/acc/profile_manager.h b/src/core/hle/service/acc/profile_manager.h
index e9c58a826..17347f7ef 100644
--- a/src/core/hle/service/acc/profile_manager.h
+++ b/src/core/hle/service/acc/profile_manager.h
@@ -8,8 +8,8 @@
 #include <optional>
 
 #include "common/common_types.h"
-#include "common/new_uuid.h"
 #include "common/swap.h"
+#include "common/uuid.h"
 #include "core/hle/result.h"
 
 namespace Service::Account {
@@ -18,7 +18,7 @@ constexpr std::size_t MAX_USERS{8};
 constexpr std::size_t profile_username_size{32};
 
 using ProfileUsername = std::array<u8, profile_username_size>;
-using UserIDArray = std::array<Common::NewUUID, MAX_USERS>;
+using UserIDArray = std::array<Common::UUID, MAX_USERS>;
 
 /// Contains extra data related to a user.
 /// TODO: RE this structure
@@ -35,7 +35,7 @@ static_assert(sizeof(ProfileData) == 0x80, "ProfileData structure has incorrect
 /// This holds general information about a users profile. This is where we store all the information
 /// based on a specific user
 struct ProfileInfo {
-    Common::NewUUID user_uuid{};
+    Common::UUID user_uuid{};
     ProfileUsername username{};
     u64 creation_time{};
     ProfileData data{}; // TODO(ognik): Work out what this is
@@ -43,7 +43,7 @@ struct ProfileInfo {
 };
 
 struct ProfileBase {
-    Common::NewUUID user_uuid;
+    Common::UUID user_uuid;
     u64_le timestamp;
     ProfileUsername username;
 
@@ -65,34 +65,34 @@ public:
     ~ProfileManager();
 
     ResultCode AddUser(const ProfileInfo& user);
-    ResultCode CreateNewUser(Common::NewUUID uuid, const ProfileUsername& username);
-    ResultCode CreateNewUser(Common::NewUUID uuid, const std::string& username);
-    std::optional<Common::NewUUID> GetUser(std::size_t index) const;
-    std::optional<std::size_t> GetUserIndex(const Common::NewUUID& uuid) const;
+    ResultCode CreateNewUser(Common::UUID uuid, const ProfileUsername& username);
+    ResultCode CreateNewUser(Common::UUID uuid, const std::string& username);
+    std::optional<Common::UUID> GetUser(std::size_t index) const;
+    std::optional<std::size_t> GetUserIndex(const Common::UUID& uuid) const;
     std::optional<std::size_t> GetUserIndex(const ProfileInfo& user) const;
     bool GetProfileBase(std::optional<std::size_t> index, ProfileBase& profile) const;
-    bool GetProfileBase(Common::NewUUID uuid, ProfileBase& profile) const;
+    bool GetProfileBase(Common::UUID uuid, ProfileBase& profile) const;
     bool GetProfileBase(const ProfileInfo& user, ProfileBase& profile) const;
     bool GetProfileBaseAndData(std::optional<std::size_t> index, ProfileBase& profile,
                                ProfileData& data) const;
-    bool GetProfileBaseAndData(Common::NewUUID uuid, ProfileBase& profile, ProfileData& data) const;
+    bool GetProfileBaseAndData(Common::UUID uuid, ProfileBase& profile, ProfileData& data) const;
     bool GetProfileBaseAndData(const ProfileInfo& user, ProfileBase& profile,
                                ProfileData& data) const;
     std::size_t GetUserCount() const;
     std::size_t GetOpenUserCount() const;
-    bool UserExists(Common::NewUUID uuid) const;
+    bool UserExists(Common::UUID uuid) const;
     bool UserExistsIndex(std::size_t index) const;
-    void OpenUser(Common::NewUUID uuid);
-    void CloseUser(Common::NewUUID uuid);
+    void OpenUser(Common::UUID uuid);
+    void CloseUser(Common::UUID uuid);
     UserIDArray GetOpenUsers() const;
     UserIDArray GetAllUsers() const;
-    Common::NewUUID GetLastOpenedUser() const;
+    Common::UUID GetLastOpenedUser() const;
 
     bool CanSystemRegisterUser() const;
 
-    bool RemoveUser(Common::NewUUID uuid);
-    bool SetProfileBase(Common::NewUUID uuid, const ProfileBase& profile_new);
-    bool SetProfileBaseAndData(Common::NewUUID uuid, const ProfileBase& profile_new,
+    bool RemoveUser(Common::UUID uuid);
+    bool SetProfileBase(Common::UUID uuid, const ProfileBase& profile_new);
+    bool SetProfileBaseAndData(Common::UUID uuid, const ProfileBase& profile_new,
                                const ProfileData& data_new);
 
 private:
@@ -103,7 +103,7 @@ private:
 
     std::array<ProfileInfo, MAX_USERS> profiles{};
     std::size_t user_count{};
-    Common::NewUUID last_opened_user{};
+    Common::UUID last_opened_user{};
 };
 
 }; // namespace Service::Account
diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp
index 4cdc029b7..773dc9f29 100644
--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@@ -55,7 +55,7 @@ constexpr u32 LAUNCH_PARAMETER_ACCOUNT_PRESELECTED_USER_MAGIC = 0xC79497CA;
 struct LaunchParameterAccountPreselectedUser {
     u32_le magic;
     u32_le is_account_selected;
-    Common::NewUUID current_user;
+    Common::UUID current_user;
     INSERT_PADDING_BYTES(0x70);
 };
 static_assert(sizeof(LaunchParameterAccountPreselectedUser) == 0x88);
diff --git a/src/core/hle/service/am/applets/applet_profile_select.cpp b/src/core/hle/service/am/applets/applet_profile_select.cpp
index 3ac32fa58..82500e121 100644
--- a/src/core/hle/service/am/applets/applet_profile_select.cpp
+++ b/src/core/hle/service/am/applets/applet_profile_select.cpp
@@ -54,11 +54,10 @@ void ProfileSelect::Execute() {
         return;
     }
 
-    frontend.SelectProfile(
-        [this](std::optional<Common::NewUUID> uuid) { SelectionComplete(uuid); });
+    frontend.SelectProfile([this](std::optional<Common::UUID> uuid) { SelectionComplete(uuid); });
 }
 
-void ProfileSelect::SelectionComplete(std::optional<Common::NewUUID> uuid) {
+void ProfileSelect::SelectionComplete(std::optional<Common::UUID> uuid) {
     UserSelectionOutput output{};
 
     if (uuid.has_value() && uuid->IsValid()) {
diff --git a/src/core/hle/service/am/applets/applet_profile_select.h b/src/core/hle/service/am/applets/applet_profile_select.h
index c5c506c41..852e1e0c0 100644
--- a/src/core/hle/service/am/applets/applet_profile_select.h
+++ b/src/core/hle/service/am/applets/applet_profile_select.h
@@ -7,7 +7,7 @@
 #include <vector>
 
 #include "common/common_funcs.h"
-#include "common/new_uuid.h"
+#include "common/uuid.h"
 #include "core/hle/result.h"
 #include "core/hle/service/am/applets/applets.h"
 
@@ -27,7 +27,7 @@ static_assert(sizeof(UserSelectionConfig) == 0xA0, "UserSelectionConfig has inco
 
 struct UserSelectionOutput {
     u64 result;
-    Common::NewUUID uuid_selected;
+    Common::UUID uuid_selected;
 };
 static_assert(sizeof(UserSelectionOutput) == 0x18, "UserSelectionOutput has incorrect size.");
 
@@ -44,7 +44,7 @@ public:
     void ExecuteInteractive() override;
     void Execute() override;
 
-    void SelectionComplete(std::optional<Common::NewUUID> uuid);
+    void SelectionComplete(std::optional<Common::UUID> uuid);
 
 private:
     const Core::Frontend::ProfileSelectApplet& frontend;
diff --git a/src/core/hle/service/friend/friend.cpp b/src/core/hle/service/friend/friend.cpp
index 3c621f7f0..79cd3acbb 100644
--- a/src/core/hle/service/friend/friend.cpp
+++ b/src/core/hle/service/friend/friend.cpp
@@ -4,7 +4,7 @@
 
 #include <queue>
 #include "common/logging/log.h"
-#include "common/new_uuid.h"
+#include "common/uuid.h"
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/k_event.h"
@@ -170,7 +170,7 @@ private:
     void GetPlayHistoryRegistrationKey(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
         const auto local_play = rp.Pop<bool>();
-        const auto uuid = rp.PopRaw<Common::NewUUID>();
+        const auto uuid = rp.PopRaw<Common::UUID>();
 
         LOG_WARNING(Service_Friend, "(STUBBED) called, local_play={}, uuid=0x{}", local_play,
                     uuid.RawString());
@@ -182,7 +182,7 @@ private:
     void GetFriendList(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
         const auto friend_offset = rp.Pop<u32>();
-        const auto uuid = rp.PopRaw<Common::NewUUID>();
+        const auto uuid = rp.PopRaw<Common::UUID>();
         [[maybe_unused]] const auto filter = rp.PopRaw<SizedFriendFilter>();
         const auto pid = rp.Pop<u64>();
         LOG_WARNING(Service_Friend, "(STUBBED) called, offset={}, uuid=0x{}, pid={}", friend_offset,
@@ -202,7 +202,7 @@ private:
 
 class INotificationService final : public ServiceFramework<INotificationService> {
 public:
-    explicit INotificationService(Core::System& system_, Common::NewUUID uuid_)
+    explicit INotificationService(Core::System& system_, Common::UUID uuid_)
         : ServiceFramework{system_, "INotificationService"}, uuid{uuid_},
           service_context{system_, "INotificationService"} {
         // clang-format off
@@ -293,7 +293,7 @@ private:
         bool has_received_friend_request;
     };
 
-    Common::NewUUID uuid;
+    Common::UUID uuid;
     KernelHelpers::ServiceContext service_context;
 
     Kernel::KEvent* notification_event;
@@ -310,7 +310,7 @@ void Module::Interface::CreateFriendService(Kernel::HLERequestContext& ctx) {
 
 void Module::Interface::CreateNotificationService(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    auto uuid = rp.PopRaw<Common::NewUUID>();
+    auto uuid = rp.PopRaw<Common::UUID>();
 
     LOG_DEBUG(Service_Friend, "called, uuid=0x{}", uuid.RawString());
 
diff --git a/src/core/hle/service/mii/mii_manager.cpp b/src/core/hle/service/mii/mii_manager.cpp
index aa1a9a6c7..0a57c3cde 100644
--- a/src/core/hle/service/mii/mii_manager.cpp
+++ b/src/core/hle/service/mii/mii_manager.cpp
@@ -131,8 +131,7 @@ T GetRandomValue(T max) {
     return GetRandomValue<T>({}, max);
 }
 
-MiiStoreData BuildRandomStoreData(Age age, Gender gender, Race race,
-                                  const Common::NewUUID& user_id) {
+MiiStoreData BuildRandomStoreData(Age age, Gender gender, Race race, const Common::UUID& user_id) {
     MiiStoreBitFields bf{};
 
     if (gender == Gender::All) {
@@ -311,7 +310,7 @@ MiiStoreData BuildRandomStoreData(Age age, Gender gender, Race race,
     return {DefaultMiiName, bf, user_id};
 }
 
-MiiStoreData BuildDefaultStoreData(const DefaultMii& info, const Common::NewUUID& user_id) {
+MiiStoreData BuildDefaultStoreData(const DefaultMii& info, const Common::UUID& user_id) {
     MiiStoreBitFields bf{};
 
     bf.font_region.Assign(info.font_region);
@@ -372,13 +371,13 @@ MiiStoreData BuildDefaultStoreData(const DefaultMii& info, const Common::NewUUID
 MiiStoreData::MiiStoreData() = default;
 
 MiiStoreData::MiiStoreData(const MiiStoreData::Name& name, const MiiStoreBitFields& bit_fields,
-                           const Common::NewUUID& user_id) {
+                           const Common::UUID& user_id) {
     data.name = name;
-    data.uuid = Common::NewUUID::MakeRandomRFC4122V4();
+    data.uuid = Common::UUID::MakeRandomRFC4122V4();
 
     std::memcpy(data.data.data(), &bit_fields, sizeof(MiiStoreBitFields));
     data_crc = GenerateCrc16(data.data.data(), sizeof(data));
-    device_crc = GenerateCrc16(&user_id, sizeof(Common::NewUUID));
+    device_crc = GenerateCrc16(&user_id, sizeof(Common::UUID));
 }
 
 MiiManager::MiiManager() : user_id{Service::Account::ProfileManager().GetLastOpenedUser()} {}
diff --git a/src/core/hle/service/mii/mii_manager.h b/src/core/hle/service/mii/mii_manager.h
index 580a64fc9..6999d15b1 100644
--- a/src/core/hle/service/mii/mii_manager.h
+++ b/src/core/hle/service/mii/mii_manager.h
@@ -8,7 +8,7 @@
 #include <vector>
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
-#include "common/new_uuid.h"
+#include "common/uuid.h"
 #include "core/hle/result.h"
 #include "core/hle/service/mii/types.h"
 
@@ -29,7 +29,7 @@ enum class SourceFlag : u32 {
 DECLARE_ENUM_FLAG_OPERATORS(SourceFlag);
 
 struct MiiInfo {
-    Common::NewUUID uuid;
+    Common::UUID uuid;
     std::array<char16_t, 11> name;
     u8 font_region;
     u8 favorite_color;
@@ -192,7 +192,7 @@ struct MiiStoreData {
 
     MiiStoreData();
     MiiStoreData(const Name& name, const MiiStoreBitFields& bit_fields,
-                 const Common::NewUUID& user_id);
+                 const Common::UUID& user_id);
 
     // This corresponds to the above structure MiiStoreBitFields. I did it like this because the
     // BitField<> type makes this (and any thing that contains it) not trivially copyable, which is
@@ -202,7 +202,7 @@ struct MiiStoreData {
         static_assert(sizeof(MiiStoreBitFields) == sizeof(data), "data field has incorrect size.");
 
         Name name{};
-        Common::NewUUID uuid{};
+        Common::UUID uuid{};
     } data;
 
     u16 data_crc{};
@@ -326,7 +326,7 @@ public:
     ResultCode GetIndex(const MiiInfo& info, u32& index);
 
 private:
-    const Common::NewUUID user_id{};
+    const Common::UUID user_id{};
     u64 update_counter{};
 };
 
diff --git a/src/core/hle/service/ns/pdm_qry.cpp b/src/core/hle/service/ns/pdm_qry.cpp
index 3eda444d2..36ce46353 100644
--- a/src/core/hle/service/ns/pdm_qry.cpp
+++ b/src/core/hle/service/ns/pdm_qry.cpp
@@ -5,7 +5,7 @@
 #include <memory>
 
 #include "common/logging/log.h"
-#include "common/new_uuid.h"
+#include "common/uuid.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/ns/pdm_qry.h"
 #include "core/hle/service/service.h"
@@ -49,7 +49,7 @@ void PDM_QRY::QueryPlayStatisticsByApplicationIdAndUserAccountId(Kernel::HLERequ
     const auto unknown = rp.Pop<bool>();
     rp.Pop<u8>(); // Padding
     const auto application_id = rp.Pop<u64>();
-    const auto user_account_uid = rp.PopRaw<Common::NewUUID>();
+    const auto user_account_uid = rp.PopRaw<Common::UUID>();
 
     // TODO(German77): Read statistics of the game
     PlayStatistics statistics{
diff --git a/src/core/hle/service/time/clock_types.h b/src/core/hle/service/time/clock_types.h
index 23d6c859b..d0cacb80c 100644
--- a/src/core/hle/service/time/clock_types.h
+++ b/src/core/hle/service/time/clock_types.h
@@ -6,7 +6,7 @@
 
 #include "common/common_funcs.h"
 #include "common/common_types.h"
-#include "common/new_uuid.h"
+#include "common/uuid.h"
 #include "core/hle/service/time/errors.h"
 #include "core/hle/service/time/time_zone_types.h"
 
@@ -21,7 +21,7 @@ enum class TimeType : u8 {
 /// https://switchbrew.org/wiki/Glue_services#SteadyClockTimePoint
 struct SteadyClockTimePoint {
     s64 time_point;
-    Common::NewUUID clock_source_id;
+    Common::UUID clock_source_id;
 
     ResultCode GetSpanBetween(SteadyClockTimePoint other, s64& span) const {
         span = 0;
@@ -36,7 +36,7 @@ struct SteadyClockTimePoint {
     }
 
     static SteadyClockTimePoint GetRandom() {
-        return {0, Common::NewUUID::MakeRandom()};
+        return {0, Common::UUID::MakeRandom()};
     }
 };
 static_assert(sizeof(SteadyClockTimePoint) == 0x18, "SteadyClockTimePoint is incorrect size");
@@ -45,7 +45,7 @@ static_assert(std::is_trivially_copyable_v<SteadyClockTimePoint>,
 
 struct SteadyClockContext {
     u64 internal_offset;
-    Common::NewUUID steady_time_point;
+    Common::UUID steady_time_point;
 };
 static_assert(sizeof(SteadyClockContext) == 0x18, "SteadyClockContext is incorrect size");
 static_assert(std::is_trivially_copyable_v<SteadyClockContext>,
diff --git a/src/core/hle/service/time/steady_clock_core.h b/src/core/hle/service/time/steady_clock_core.h
index dfc9fade4..5ee2c0e0a 100644
--- a/src/core/hle/service/time/steady_clock_core.h
+++ b/src/core/hle/service/time/steady_clock_core.h
@@ -4,7 +4,7 @@
 
 #pragma once
 
-#include "common/new_uuid.h"
+#include "common/uuid.h"
 #include "core/hle/service/time/clock_types.h"
 
 namespace Core {
@@ -18,11 +18,11 @@ public:
     SteadyClockCore() = default;
     virtual ~SteadyClockCore() = default;
 
-    const Common::NewUUID& GetClockSourceId() const {
+    const Common::UUID& GetClockSourceId() const {
         return clock_source_id;
     }
 
-    void SetClockSourceId(const Common::NewUUID& value) {
+    void SetClockSourceId(const Common::UUID& value) {
         clock_source_id = value;
     }
 
@@ -49,7 +49,7 @@ public:
     }
 
 private:
-    Common::NewUUID clock_source_id{Common::NewUUID::MakeRandom()};
+    Common::UUID clock_source_id{Common::UUID::MakeRandom()};
     bool is_initialized{};
 };
 
diff --git a/src/core/hle/service/time/time_manager.cpp b/src/core/hle/service/time/time_manager.cpp
index 15a2d99e8..00f1ae8cf 100644
--- a/src/core/hle/service/time/time_manager.cpp
+++ b/src/core/hle/service/time/time_manager.cpp
@@ -45,7 +45,7 @@ struct TimeManager::Impl final {
           time_zone_content_manager{system} {
 
         const auto system_time{Clock::TimeSpanType::FromSeconds(GetExternalRtcValue())};
-        SetupStandardSteadyClock(system, Common::NewUUID::MakeRandom(), system_time, {}, {});
+        SetupStandardSteadyClock(system, Common::UUID::MakeRandom(), system_time, {}, {});
         SetupStandardLocalSystemClock(system, {}, system_time.ToSeconds());
 
         Clock::SystemClockContext clock_context{};
@@ -132,7 +132,7 @@ struct TimeManager::Impl final {
         return 0;
     }
 
-    void SetupStandardSteadyClock(Core::System& system_, Common::NewUUID clock_source_id,
+    void SetupStandardSteadyClock(Core::System& system_, Common::UUID clock_source_id,
                                   Clock::TimeSpanType setup_value,
                                   Clock::TimeSpanType internal_offset, bool is_rtc_reset_detected) {
         standard_steady_clock_core.SetClockSourceId(clock_source_id);
diff --git a/src/core/hle/service/time/time_sharedmemory.cpp b/src/core/hle/service/time/time_sharedmemory.cpp
index ac31cd9ca..ed9f75ed6 100644
--- a/src/core/hle/service/time/time_sharedmemory.cpp
+++ b/src/core/hle/service/time/time_sharedmemory.cpp
@@ -20,7 +20,7 @@ SharedMemory::SharedMemory(Core::System& system_) : system(system_) {
 
 SharedMemory::~SharedMemory() = default;
 
-void SharedMemory::SetupStandardSteadyClock(const Common::NewUUID& clock_source_id,
+void SharedMemory::SetupStandardSteadyClock(const Common::UUID& clock_source_id,
                                             Clock::TimeSpanType current_time_point) {
     const Clock::TimeSpanType ticks_time_span{Clock::TimeSpanType::FromTicks(
         system.CoreTiming().GetClockTicks(), Core::Hardware::CNTFREQ)};
diff --git a/src/core/hle/service/time/time_sharedmemory.h b/src/core/hle/service/time/time_sharedmemory.h
index 4063ce4e0..9307ea795 100644
--- a/src/core/hle/service/time/time_sharedmemory.h
+++ b/src/core/hle/service/time/time_sharedmemory.h
@@ -5,7 +5,7 @@
 #pragma once
 
 #include "common/common_types.h"
-#include "common/new_uuid.h"
+#include "common/uuid.h"
 #include "core/hle/kernel/k_shared_memory.h"
 #include "core/hle/service/time/clock_types.h"
 
@@ -52,7 +52,7 @@ public:
     };
     static_assert(sizeof(Format) == 0xd8, "Format is an invalid size");
 
-    void SetupStandardSteadyClock(const Common::NewUUID& clock_source_id,
+    void SetupStandardSteadyClock(const Common::UUID& clock_source_id,
                                   Clock::TimeSpanType current_time_point);
     void UpdateLocalSystemClockContext(const Clock::SystemClockContext& context);
     void UpdateNetworkSystemClockContext(const Clock::SystemClockContext& context);
diff --git a/src/input_common/drivers/gc_adapter.cpp b/src/input_common/drivers/gc_adapter.cpp
index 7a269b526..155caae42 100644
--- a/src/input_common/drivers/gc_adapter.cpp
+++ b/src/input_common/drivers/gc_adapter.cpp
@@ -248,7 +248,7 @@ bool GCAdapter::Setup() {
         std::size_t port = 0;
         for (GCController& pad : pads) {
             pad.identifier = {
-                .guid = Common::NewUUID{},
+                .guid = Common::UUID{},
                 .port = port++,
                 .pad = 0,
             };
diff --git a/src/input_common/drivers/keyboard.cpp b/src/input_common/drivers/keyboard.cpp
index 449509270..59e3d9cc0 100644
--- a/src/input_common/drivers/keyboard.cpp
+++ b/src/input_common/drivers/keyboard.cpp
@@ -9,17 +9,17 @@
 namespace InputCommon {
 
 constexpr PadIdentifier key_identifier = {
-    .guid = Common::NewUUID{},
+    .guid = Common::UUID{},
     .port = 0,
     .pad = 0,
 };
 constexpr PadIdentifier keyboard_key_identifier = {
-    .guid = Common::NewUUID{},
+    .guid = Common::UUID{},
     .port = 1,
     .pad = 0,
 };
 constexpr PadIdentifier keyboard_modifier_identifier = {
-    .guid = Common::NewUUID{},
+    .guid = Common::UUID{},
     .port = 1,
     .pad = 1,
 };
diff --git a/src/input_common/drivers/mouse.cpp b/src/input_common/drivers/mouse.cpp
index ae63088ba..3c9a4e747 100644
--- a/src/input_common/drivers/mouse.cpp
+++ b/src/input_common/drivers/mouse.cpp
@@ -20,7 +20,7 @@ constexpr int motion_wheel_y = 4;
 constexpr int touch_axis_x = 10;
 constexpr int touch_axis_y = 11;
 constexpr PadIdentifier identifier = {
-    .guid = Common::NewUUID{},
+    .guid = Common::UUID{},
     .port = 0,
     .pad = 0,
 };
diff --git a/src/input_common/drivers/sdl_driver.cpp b/src/input_common/drivers/sdl_driver.cpp
index b9a8317d4..655eb5275 100644
--- a/src/input_common/drivers/sdl_driver.cpp
+++ b/src/input_common/drivers/sdl_driver.cpp
@@ -120,7 +120,7 @@ public:
      */
     const PadIdentifier GetPadIdentifier() const {
         return {
-            .guid = Common::NewUUID{guid},
+            .guid = Common::UUID{guid},
             .port = static_cast<std::size_t>(port),
             .pad = 0,
         };
diff --git a/src/input_common/drivers/tas_input.cpp b/src/input_common/drivers/tas_input.cpp
index 6d36cf5da..944e141bf 100644
--- a/src/input_common/drivers/tas_input.cpp
+++ b/src/input_common/drivers/tas_input.cpp
@@ -50,7 +50,7 @@ constexpr std::array<std::pair<std::string_view, TasButton>, 18> text_to_tas_but
 Tas::Tas(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
     for (size_t player_index = 0; player_index < PLAYER_NUMBER; player_index++) {
         PadIdentifier identifier{
-            .guid = Common::NewUUID{},
+            .guid = Common::UUID{},
             .port = player_index,
             .pad = 0,
         };
@@ -203,7 +203,7 @@ void Tas::UpdateThread() {
             }
 
             PadIdentifier identifier{
-                .guid = Common::NewUUID{},
+                .guid = Common::UUID{},
                 .port = player_index,
                 .pad = 0,
             };
diff --git a/src/input_common/drivers/touch_screen.cpp b/src/input_common/drivers/touch_screen.cpp
index 1030e74d9..30c727df4 100644
--- a/src/input_common/drivers/touch_screen.cpp
+++ b/src/input_common/drivers/touch_screen.cpp
@@ -8,7 +8,7 @@
 namespace InputCommon {
 
 constexpr PadIdentifier identifier = {
-    .guid = Common::NewUUID{},
+    .guid = Common::UUID{},
     .port = 0,
     .pad = 0,
 };
diff --git a/src/input_common/drivers/udp_client.cpp b/src/input_common/drivers/udp_client.cpp
index cbcfa7a4b..64162f431 100644
--- a/src/input_common/drivers/udp_client.cpp
+++ b/src/input_common/drivers/udp_client.cpp
@@ -351,10 +351,10 @@ PadIdentifier UDPClient::GetPadIdentifier(std::size_t pad_index) const {
     };
 }
 
-Common::NewUUID UDPClient::GetHostUUID(const std::string& host) const {
+Common::UUID UDPClient::GetHostUUID(const std::string& host) const {
     const auto ip = boost::asio::ip::make_address_v4(host);
     const auto hex_host = fmt::format("00000000-0000-0000-0000-0000{:06x}", ip.to_uint());
-    return Common::NewUUID{hex_host};
+    return Common::UUID{hex_host};
 }
 
 void UDPClient::Reset() {
diff --git a/src/input_common/drivers/udp_client.h b/src/input_common/drivers/udp_client.h
index 98abeedd1..76e32bd04 100644
--- a/src/input_common/drivers/udp_client.h
+++ b/src/input_common/drivers/udp_client.h
@@ -126,7 +126,7 @@ private:
     struct ClientConnection {
         ClientConnection();
         ~ClientConnection();
-        Common::NewUUID uuid{"00000000-0000-0000-0000-00007F000001"};
+        Common::UUID uuid{"00000000-0000-0000-0000-00007F000001"};
         std::string host{"127.0.0.1"};
         u16 port{26760};
         s8 active{-1};
@@ -148,7 +148,7 @@ private:
     void OnPadData(Response::PadData, std::size_t client);
     void StartCommunication(std::size_t client, const std::string& host, u16 port);
     PadIdentifier GetPadIdentifier(std::size_t pad_index) const;
-    Common::NewUUID GetHostUUID(const std::string& host) const;
+    Common::UUID GetHostUUID(const std::string& host) const;
 
     Common::Input::ButtonNames GetUIButtonName(const Common::ParamPackage& params) const;
 
diff --git a/src/input_common/input_engine.h b/src/input_common/input_engine.h
index 05e45b877..c6c027aef 100644
--- a/src/input_common/input_engine.h
+++ b/src/input_common/input_engine.h
@@ -10,13 +10,13 @@
 
 #include "common/common_types.h"
 #include "common/input.h"
-#include "common/new_uuid.h"
 #include "common/param_package.h"
+#include "common/uuid.h"
 #include "input_common/main.h"
 
 // Pad Identifier of data source
 struct PadIdentifier {
-    Common::NewUUID guid{};
+    Common::UUID guid{};
     std::size_t port{};
     std::size_t pad{};
 
diff --git a/src/input_common/input_poller.cpp b/src/input_common/input_poller.cpp
index 313703f5f..2f3c0735a 100644
--- a/src/input_common/input_poller.cpp
+++ b/src/input_common/input_poller.cpp
@@ -691,7 +691,7 @@ private:
 std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateButtonDevice(
     const Common::ParamPackage& params) {
     const PadIdentifier identifier = {
-        .guid = Common::NewUUID{params.Get("guid", "")},
+        .guid = Common::UUID{params.Get("guid", "")},
         .port = static_cast<std::size_t>(params.Get("port", 0)),
         .pad = static_cast<std::size_t>(params.Get("pad", 0)),
     };
@@ -714,7 +714,7 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateButtonDevice(
 std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateHatButtonDevice(
     const Common::ParamPackage& params) {
     const PadIdentifier identifier = {
-        .guid = Common::NewUUID{params.Get("guid", "")},
+        .guid = Common::UUID{params.Get("guid", "")},
         .port = static_cast<std::size_t>(params.Get("port", 0)),
         .pad = static_cast<std::size_t>(params.Get("pad", 0)),
     };
@@ -736,7 +736,7 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateStickDevice(
     const auto range = std::clamp(params.Get("range", 1.0f), 0.25f, 1.50f);
     const auto threshold = std::clamp(params.Get("threshold", 0.5f), 0.0f, 1.0f);
     const PadIdentifier identifier = {
-        .guid = Common::NewUUID{params.Get("guid", "")},
+        .guid = Common::UUID{params.Get("guid", "")},
         .port = static_cast<std::size_t>(params.Get("port", 0)),
         .pad = static_cast<std::size_t>(params.Get("pad", 0)),
     };
@@ -768,7 +768,7 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateStickDevice(
 std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateAnalogDevice(
     const Common::ParamPackage& params) {
     const PadIdentifier identifier = {
-        .guid = Common::NewUUID{params.Get("guid", "")},
+        .guid = Common::UUID{params.Get("guid", "")},
         .port = static_cast<std::size_t>(params.Get("port", 0)),
         .pad = static_cast<std::size_t>(params.Get("pad", 0)),
     };
@@ -789,7 +789,7 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateAnalogDevice(
 std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateTriggerDevice(
     const Common::ParamPackage& params) {
     const PadIdentifier identifier = {
-        .guid = Common::NewUUID{params.Get("guid", "")},
+        .guid = Common::UUID{params.Get("guid", "")},
         .port = static_cast<std::size_t>(params.Get("port", 0)),
         .pad = static_cast<std::size_t>(params.Get("pad", 0)),
     };
@@ -820,7 +820,7 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateTouchDevice(
     const auto range = std::clamp(params.Get("range", 1.0f), 0.25f, 1.50f);
     const auto threshold = std::clamp(params.Get("threshold", 0.5f), 0.0f, 1.0f);
     const PadIdentifier identifier = {
-        .guid = Common::NewUUID{params.Get("guid", "")},
+        .guid = Common::UUID{params.Get("guid", "")},
         .port = static_cast<std::size_t>(params.Get("port", 0)),
         .pad = static_cast<std::size_t>(params.Get("pad", 0)),
     };
@@ -857,7 +857,7 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateTouchDevice(
 std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateBatteryDevice(
     const Common::ParamPackage& params) {
     const PadIdentifier identifier = {
-        .guid = Common::NewUUID{params.Get("guid", "")},
+        .guid = Common::UUID{params.Get("guid", "")},
         .port = static_cast<std::size_t>(params.Get("port", 0)),
         .pad = static_cast<std::size_t>(params.Get("pad", 0)),
     };
@@ -869,7 +869,7 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateBatteryDevice(
 std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateMotionDevice(
     Common::ParamPackage params) {
     const PadIdentifier identifier = {
-        .guid = Common::NewUUID{params.Get("guid", "")},
+        .guid = Common::UUID{params.Get("guid", "")},
         .port = static_cast<std::size_t>(params.Get("port", 0)),
         .pad = static_cast<std::size_t>(params.Get("pad", 0)),
     };
@@ -963,7 +963,7 @@ OutputFactory::OutputFactory(std::shared_ptr<InputEngine> input_engine_)
 std::unique_ptr<Common::Input::OutputDevice> OutputFactory::Create(
     const Common::ParamPackage& params) {
     const PadIdentifier identifier = {
-        .guid = Common::NewUUID{params.Get("guid", "")},
+        .guid = Common::UUID{params.Get("guid", "")},
         .port = static_cast<std::size_t>(params.Get("port", 0)),
         .pad = static_cast<std::size_t>(params.Get("pad", 0)),
     };
diff --git a/src/yuzu/applets/qt_profile_select.cpp b/src/yuzu/applets/qt_profile_select.cpp
index c10185e50..4cd8f7784 100644
--- a/src/yuzu/applets/qt_profile_select.cpp
+++ b/src/yuzu/applets/qt_profile_select.cpp
@@ -19,21 +19,21 @@
 #include "yuzu/util/controller_navigation.h"
 
 namespace {
-QString FormatUserEntryText(const QString& username, Common::NewUUID uuid) {
+QString FormatUserEntryText(const QString& username, Common::UUID uuid) {
     return QtProfileSelectionDialog::tr(
                "%1\n%2", "%1 is the profile username, %2 is the formatted UUID (e.g. "
                          "00112233-4455-6677-8899-AABBCCDDEEFF))")
         .arg(username, QString::fromStdString(uuid.FormattedString()));
 }
 
-QString GetImagePath(Common::NewUUID uuid) {
+QString GetImagePath(Common::UUID uuid) {
     const auto path =
         Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir) /
         fmt::format("system/save/8000000000000010/su/avators/{}.jpg", uuid.FormattedString());
     return QString::fromStdString(Common::FS::PathToUTF8String(path));
 }
 
-QPixmap GetIcon(Common::NewUUID uuid) {
+QPixmap GetIcon(Common::UUID uuid) {
     QPixmap icon{GetImagePath(uuid)};
 
     if (!icon) {
@@ -163,11 +163,11 @@ QtProfileSelector::QtProfileSelector(GMainWindow& parent) {
 QtProfileSelector::~QtProfileSelector() = default;
 
 void QtProfileSelector::SelectProfile(
-    std::function<void(std::optional<Common::NewUUID>)> callback_) const {
+    std::function<void(std::optional<Common::UUID>)> callback_) const {
     callback = std::move(callback_);
     emit MainWindowSelectProfile();
 }
 
-void QtProfileSelector::MainWindowFinishedSelection(std::optional<Common::NewUUID> uuid) {
+void QtProfileSelector::MainWindowFinishedSelection(std::optional<Common::UUID> uuid) {
     callback(uuid);
 }
diff --git a/src/yuzu/applets/qt_profile_select.h b/src/yuzu/applets/qt_profile_select.h
index 2522b6450..56496ed31 100644
--- a/src/yuzu/applets/qt_profile_select.h
+++ b/src/yuzu/applets/qt_profile_select.h
@@ -66,14 +66,13 @@ public:
     explicit QtProfileSelector(GMainWindow& parent);
     ~QtProfileSelector() override;
 
-    void SelectProfile(
-        std::function<void(std::optional<Common::NewUUID>)> callback_) const override;
+    void SelectProfile(std::function<void(std::optional<Common::UUID>)> callback_) const override;
 
 signals:
     void MainWindowSelectProfile() const;
 
 private:
-    void MainWindowFinishedSelection(std::optional<Common::NewUUID> uuid);
+    void MainWindowFinishedSelection(std::optional<Common::UUID> uuid);
 
-    mutable std::function<void(std::optional<Common::NewUUID>)> callback;
+    mutable std::function<void(std::optional<Common::UUID>)> callback;
 };
diff --git a/src/yuzu/configuration/configure_profile_manager.cpp b/src/yuzu/configuration/configure_profile_manager.cpp
index 9e2832543..d9f6dee4e 100644
--- a/src/yuzu/configuration/configure_profile_manager.cpp
+++ b/src/yuzu/configuration/configure_profile_manager.cpp
@@ -33,14 +33,14 @@ constexpr std::array<u8, 107> backup_jpeg{
     0x01, 0x01, 0x00, 0x00, 0x3f, 0x00, 0xd2, 0xcf, 0x20, 0xff, 0xd9,
 };
 
-QString GetImagePath(const Common::NewUUID& uuid) {
+QString GetImagePath(const Common::UUID& uuid) {
     const auto path =
         Common::FS::GetYuzuPath(Common::FS::YuzuPath::NANDDir) /
         fmt::format("system/save/8000000000000010/su/avators/{}.jpg", uuid.FormattedString());
     return QString::fromStdString(Common::FS::PathToUTF8String(path));
 }
 
-QString GetAccountUsername(const Service::Account::ProfileManager& manager, Common::NewUUID uuid) {
+QString GetAccountUsername(const Service::Account::ProfileManager& manager, Common::UUID uuid) {
     Service::Account::ProfileBase profile{};
     if (!manager.GetProfileBase(uuid, profile)) {
         return {};
@@ -51,14 +51,14 @@ QString GetAccountUsername(const Service::Account::ProfileManager& manager, Comm
     return QString::fromStdString(text);
 }
 
-QString FormatUserEntryText(const QString& username, Common::NewUUID uuid) {
+QString FormatUserEntryText(const QString& username, Common::UUID uuid) {
     return ConfigureProfileManager::tr("%1\n%2",
                                        "%1 is the profile username, %2 is the formatted UUID (e.g. "
                                        "00112233-4455-6677-8899-AABBCCDDEEFF))")
         .arg(username, QString::fromStdString(uuid.FormattedString()));
 }
 
-QPixmap GetIcon(const Common::NewUUID& uuid) {
+QPixmap GetIcon(const Common::UUID& uuid) {
     QPixmap icon{GetImagePath(uuid)};
 
     if (!icon) {
@@ -200,7 +200,7 @@ void ConfigureProfileManager::AddUser() {
         return;
     }
 
-    const auto uuid = Common::NewUUID::MakeRandom();
+    const auto uuid = Common::UUID::MakeRandom();
     profile_manager->CreateNewUser(uuid, username.toStdString());
 
     item_model->appendRow(new QStandardItem{GetIcon(uuid), FormatUserEntryText(username, uuid)});
diff --git a/src/yuzu/main.h b/src/yuzu/main.h
index 529d101ae..ca4ab9af5 100644
--- a/src/yuzu/main.h
+++ b/src/yuzu/main.h
@@ -153,7 +153,7 @@ signals:
 
     void ErrorDisplayFinished();
 
-    void ProfileSelectorFinishedSelection(std::optional<Common::NewUUID> uuid);
+    void ProfileSelectorFinishedSelection(std::optional<Common::UUID> uuid);
 
     void SoftwareKeyboardSubmitNormalText(Service::AM::Applets::SwkbdResult result,
                                           std::u16string submitted_text, bool confirmed);
-- 
cgit v1.2.3


From ec4d7f71fedb1cc117b0fb6c33cbffb699b98555 Mon Sep 17 00:00:00 2001
From: Morph <39850852+Morph1984@users.noreply.github.com>
Date: Sat, 5 Feb 2022 13:07:51 -0500
Subject: common: uuid: Return an invalid UUID if conversion from string fails

The string constructor of UUID states:
Should the input string not meet the above requirements, an assert will be triggered and an invalid UUID is set instead.
---
 src/common/uuid.cpp | 53 +++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 39 insertions(+), 14 deletions(-)

(limited to 'src')

diff --git a/src/common/uuid.cpp b/src/common/uuid.cpp
index 10a1b86e0..4aab10e08 100644
--- a/src/common/uuid.cpp
+++ b/src/common/uuid.cpp
@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <bit>
+#include <optional>
 #include <random>
 
 #include <fmt/format.h>
@@ -18,7 +19,7 @@ namespace {
 constexpr size_t RawStringSize = sizeof(UUID) * 2;
 constexpr size_t FormattedStringSize = RawStringSize + 4;
 
-u8 HexCharToByte(char c) {
+std::optional<u8> HexCharToByte(char c) {
     if (c >= '0' && c <= '9') {
         return static_cast<u8>(c - '0');
     }
@@ -29,15 +30,19 @@ u8 HexCharToByte(char c) {
         return static_cast<u8>(c - 'A' + 10);
     }
     ASSERT_MSG(false, "{} is not a hexadecimal digit!", c);
-    return u8{0};
+    return std::nullopt;
 }
 
 std::array<u8, 0x10> ConstructFromRawString(std::string_view raw_string) {
     std::array<u8, 0x10> uuid;
 
     for (size_t i = 0; i < RawStringSize; i += 2) {
-        uuid[i / 2] =
-            static_cast<u8>((HexCharToByte(raw_string[i]) << 4) | HexCharToByte(raw_string[i + 1]));
+        const auto upper = HexCharToByte(raw_string[i]);
+        const auto lower = HexCharToByte(raw_string[i + 1]);
+        if (!upper || !lower) {
+            return {};
+        }
+        uuid[i / 2] = static_cast<u8>((*upper << 4) | *lower);
     }
 
     return uuid;
@@ -52,40 +57,60 @@ std::array<u8, 0x10> ConstructFromFormattedString(std::string_view formatted_str
     const auto* str = formatted_string.data();
 
     for (; i < 4; ++i) {
-        uuid[i] = static_cast<u8>((HexCharToByte(*(str++)) << 4));
-        uuid[i] |= HexCharToByte(*(str++));
+        const auto upper = HexCharToByte(*(str++));
+        const auto lower = HexCharToByte(*(str++));
+        if (!upper || !lower) {
+            return {};
+        }
+        uuid[i] = static_cast<u8>((*upper << 4) | *lower);
     }
 
     // Process the next 4 characters.
     ++str;
 
     for (; i < 6; ++i) {
-        uuid[i] = static_cast<u8>((HexCharToByte(*(str++)) << 4));
-        uuid[i] |= HexCharToByte(*(str++));
+        const auto upper = HexCharToByte(*(str++));
+        const auto lower = HexCharToByte(*(str++));
+        if (!upper || !lower) {
+            return {};
+        }
+        uuid[i] = static_cast<u8>((*upper << 4) | *lower);
     }
 
     // Process the next 4 characters.
     ++str;
 
     for (; i < 8; ++i) {
-        uuid[i] = static_cast<u8>((HexCharToByte(*(str++)) << 4));
-        uuid[i] |= HexCharToByte(*(str++));
+        const auto upper = HexCharToByte(*(str++));
+        const auto lower = HexCharToByte(*(str++));
+        if (!upper || !lower) {
+            return {};
+        }
+        uuid[i] = static_cast<u8>((*upper << 4) | *lower);
     }
 
     // Process the next 4 characters.
     ++str;
 
     for (; i < 10; ++i) {
-        uuid[i] = static_cast<u8>((HexCharToByte(*(str++)) << 4));
-        uuid[i] |= HexCharToByte(*(str++));
+        const auto upper = HexCharToByte(*(str++));
+        const auto lower = HexCharToByte(*(str++));
+        if (!upper || !lower) {
+            return {};
+        }
+        uuid[i] = static_cast<u8>((*upper << 4) | *lower);
     }
 
     // Process the last 12 characters.
     ++str;
 
     for (; i < 16; ++i) {
-        uuid[i] = static_cast<u8>((HexCharToByte(*(str++)) << 4));
-        uuid[i] |= HexCharToByte(*(str++));
+        const auto upper = HexCharToByte(*(str++));
+        const auto lower = HexCharToByte(*(str++));
+        if (!upper || !lower) {
+            return {};
+        }
+        uuid[i] = static_cast<u8>((*upper << 4) | *lower);
     }
 
     return uuid;
-- 
cgit v1.2.3


From 3799c820ca7c5b978d47be9c5ac1318333e5d9cb Mon Sep 17 00:00:00 2001
From: Morph <39850852+Morph1984@users.noreply.github.com>
Date: Thu, 10 Feb 2022 15:03:49 -0500
Subject: common: uuid: Use sizeof(u64) instead of 8 in Hash()

---
 src/common/uuid.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'src')

diff --git a/src/common/uuid.cpp b/src/common/uuid.cpp
index 4aab10e08..2b6a530e3 100644
--- a/src/common/uuid.cpp
+++ b/src/common/uuid.cpp
@@ -160,13 +160,13 @@ std::string UUID::FormattedString() const {
 }
 
 size_t UUID::Hash() const noexcept {
-    u64 hash;
-    u64 temp;
+    u64 upper_hash;
+    u64 lower_hash;
 
-    std::memcpy(&hash, uuid.data(), sizeof(u64));
-    std::memcpy(&temp, uuid.data() + 8, sizeof(u64));
+    std::memcpy(&upper_hash, uuid.data(), sizeof(u64));
+    std::memcpy(&lower_hash, uuid.data() + sizeof(u64), sizeof(u64));
 
-    return hash ^ std::rotl(temp, 1);
+    return upper_hash ^ std::rotl(lower_hash, 1);
 }
 
 u128 UUID::AsU128() const {
-- 
cgit v1.2.3