6 files changed, 256 insertions, 434 deletions

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();
     }
 };