From 76d83ffbece12d9509c5cc753dd6c69d8abeb458 Mon Sep 17 00:00:00 2001 From: Lioncash Date: Wed, 2 Feb 2022 12:12:22 -0500 Subject: general: Move deleted copy/move constructor/assignment operators to public interface This allows for better compiler errors, where the compiler will state a copy or move couldn't occur due to the relevant function being deleted. Previously a compiler would warn about the relevant function not being accessible (which, while true, isn't as informative as it could be). --- src/core/hid/emulated_console.h | 1 + src/core/hid/emulated_controller.h | 2 -- src/core/hid/hid_core.h | 1 + src/core/hle/kernel/k_auto_object.h | 7 ++++--- src/core/hle/kernel/k_auto_object_container.h | 4 +--- src/core/hle/kernel/k_handle_table.h | 3 +-- src/core/hle/service/vi/display/vi_display.h | 2 +- 7 files changed, 9 insertions(+), 11 deletions(-) diff --git a/src/core/hid/emulated_console.h b/src/core/hid/emulated_console.h index 707419102..5eb170823 100644 --- a/src/core/hid/emulated_console.h +++ b/src/core/hid/emulated_console.h @@ -10,6 +10,7 @@ #include #include +#include "common/common_funcs.h" #include "common/common_types.h" #include "common/input.h" #include "common/param_package.h" diff --git a/src/core/hid/emulated_controller.h b/src/core/hid/emulated_controller.h index a63a83cce..d8642c5b3 100644 --- a/src/core/hid/emulated_controller.h +++ b/src/core/hid/emulated_controller.h @@ -13,8 +13,6 @@ #include "common/common_types.h" #include "common/input.h" #include "common/param_package.h" -#include "common/point.h" -#include "common/quaternion.h" #include "common/settings.h" #include "common/vector_math.h" #include "core/hid/hid_types.h" diff --git a/src/core/hid/hid_core.h b/src/core/hid/hid_core.h index 837f7de49..717f605e7 100644 --- a/src/core/hid/hid_core.h +++ b/src/core/hid/hid_core.h @@ -6,6 +6,7 @@ #include +#include "common/common_funcs.h" #include "core/hid/hid_types.h" namespace Core::HID { diff --git a/src/core/hle/kernel/k_auto_object.h b/src/core/hle/kernel/k_auto_object.h index 165b76747..05779f2d5 100644 --- a/src/core/hle/kernel/k_auto_object.h +++ b/src/core/hle/kernel/k_auto_object.h @@ -20,8 +20,6 @@ class KernelCore; class KProcess; #define KERNEL_AUTOOBJECT_TRAITS(CLASS, BASE_CLASS) \ - YUZU_NON_COPYABLE(CLASS); \ - YUZU_NON_MOVEABLE(CLASS); \ \ private: \ friend class ::Kernel::KClassTokenGenerator; \ @@ -32,6 +30,9 @@ private: } \ \ public: \ + YUZU_NON_COPYABLE(CLASS); \ + YUZU_NON_MOVEABLE(CLASS); \ + \ using BaseClass = BASE_CLASS; \ static constexpr TypeObj GetStaticTypeObj() { \ constexpr ClassTokenType Token = ClassToken(); \ @@ -224,9 +225,9 @@ private: template class KScopedAutoObject { +public: YUZU_NON_COPYABLE(KScopedAutoObject); -public: constexpr KScopedAutoObject() = default; constexpr KScopedAutoObject(T* o) : m_obj(o) { diff --git a/src/core/hle/kernel/k_auto_object_container.h b/src/core/hle/kernel/k_auto_object_container.h index 4eadfe99d..697cc4289 100644 --- a/src/core/hle/kernel/k_auto_object_container.h +++ b/src/core/hle/kernel/k_auto_object_container.h @@ -16,13 +16,12 @@ class KernelCore; class KProcess; class KAutoObjectWithListContainer { +public: YUZU_NON_COPYABLE(KAutoObjectWithListContainer); YUZU_NON_MOVEABLE(KAutoObjectWithListContainer); -public: using ListType = boost::intrusive::rbtree; -public: class ListAccessor : public KScopedLightLock { public: explicit ListAccessor(KAutoObjectWithListContainer* container) @@ -48,7 +47,6 @@ public: friend class ListAccessor; -public: KAutoObjectWithListContainer(KernelCore& kernel) : m_lock(kernel), m_object_list() {} void Initialize() {} diff --git a/src/core/hle/kernel/k_handle_table.h b/src/core/hle/kernel/k_handle_table.h index 4b114ec2f..87004a0f9 100644 --- a/src/core/hle/kernel/k_handle_table.h +++ b/src/core/hle/kernel/k_handle_table.h @@ -22,13 +22,12 @@ namespace Kernel { class KernelCore; class KHandleTable { +public: YUZU_NON_COPYABLE(KHandleTable); YUZU_NON_MOVEABLE(KHandleTable); -public: static constexpr size_t MaxTableSize = 1024; -public: explicit KHandleTable(KernelCore& kernel_); ~KHandleTable(); diff --git a/src/core/hle/service/vi/display/vi_display.h b/src/core/hle/service/vi/display/vi_display.h index 0979fc421..329f4ba86 100644 --- a/src/core/hle/service/vi/display/vi_display.h +++ b/src/core/hle/service/vi/display/vi_display.h @@ -28,10 +28,10 @@ class Layer; /// Represents a single display type class Display { +public: YUZU_NON_COPYABLE(Display); YUZU_NON_MOVEABLE(Display); -public: /// Constructs a display with a given unique ID and name. /// /// @param id The unique ID for this display. -- cgit v1.2.3 From f785f73e9279dcb9cfdee93da694d7a1f55142ea Mon Sep 17 00:00:00 2001 From: Lioncash Date: Wed, 2 Feb 2022 12:59:36 -0500 Subject: general: Replace NonCopyable struct with equivalents --- src/common/telemetry.h | 26 ++++--- src/core/arm/arm_interface.h | 6 +- src/core/file_sys/vfs.h | 18 ++++- src/core/hle/kernel/k_memory_manager.h | 42 +++++----- src/core/hle/kernel/k_memory_region.h | 80 ++++++++++--------- src/core/hle/kernel/k_page_heap.h | 90 ++++++++++++---------- src/core/hle/kernel/k_page_table.cpp | 2 + src/core/hle/kernel/k_page_table.h | 7 +- src/core/hle/kernel/k_slab_heap.h | 13 +++- src/core/loader/loader.h | 6 +- src/video_core/renderer_base.h | 8 +- .../renderer_opengl/gl_resource_manager.h | 50 ++++++++---- 12 files changed, 219 insertions(+), 129 deletions(-) diff --git a/src/common/telemetry.h b/src/common/telemetry.h index 49186e848..d38aeac99 100644 --- a/src/common/telemetry.h +++ b/src/common/telemetry.h @@ -8,6 +8,7 @@ #include #include #include +#include "common/common_funcs.h" #include "common/common_types.h" namespace Common::Telemetry { @@ -28,7 +29,7 @@ struct VisitorInterface; /** * Interface class for telemetry data fields. */ -class FieldInterface : NonCopyable { +class FieldInterface { public: virtual ~FieldInterface() = default; @@ -52,14 +53,15 @@ public: template class Field : public FieldInterface { public: + YUZU_NON_COPYABLE(Field); + Field(FieldType type_, std::string name_, T value_) : name(std::move(name_)), type(type_), value(std::move(value_)) {} - Field(const Field&) = default; - Field& operator=(const Field&) = default; + ~Field() override = default; - Field(Field&&) = default; - Field& operator=(Field&& other) = default; + Field(Field&&) noexcept = default; + Field& operator=(Field&& other) noexcept = default; void Accept(VisitorInterface& visitor) const override; @@ -98,9 +100,15 @@ private: /** * Collection of data fields that have been logged. */ -class FieldCollection final : NonCopyable { +class FieldCollection final { public: + YUZU_NON_COPYABLE(FieldCollection); + FieldCollection() = default; + ~FieldCollection() = default; + + FieldCollection(FieldCollection&&) noexcept = default; + FieldCollection& operator=(FieldCollection&&) noexcept = default; /** * Accept method for the visitor pattern, visits each field in the collection. @@ -133,7 +141,7 @@ private: * Telemetry fields visitor interface class. A backend to log to a web service should implement * this interface. */ -struct VisitorInterface : NonCopyable { +struct VisitorInterface { virtual ~VisitorInterface() = default; virtual void Visit(const Field& field) = 0; @@ -160,8 +168,8 @@ struct VisitorInterface : NonCopyable { * Empty implementation of VisitorInterface that drops all fields. Used when a functional * backend implementation is not available. */ -struct NullVisitor : public VisitorInterface { - ~NullVisitor() = default; +struct NullVisitor final : public VisitorInterface { + YUZU_NON_COPYABLE(NullVisitor); void Visit(const Field& /*field*/) override {} void Visit(const Field& /*field*/) override {} diff --git a/src/core/arm/arm_interface.h b/src/core/arm/arm_interface.h index 689e3ceb5..c60322442 100644 --- a/src/core/arm/arm_interface.h +++ b/src/core/arm/arm_interface.h @@ -6,6 +6,7 @@ #include #include +#include "common/common_funcs.h" #include "common/common_types.h" #include "core/hardware_properties.h" @@ -24,8 +25,11 @@ class CPUInterruptHandler; using CPUInterrupts = std::array; /// Generic ARMv8 CPU interface -class ARM_Interface : NonCopyable { +class ARM_Interface { public: + YUZU_NON_COPYABLE(ARM_Interface); + YUZU_NON_MOVEABLE(ARM_Interface); + explicit ARM_Interface(System& system_, CPUInterrupts& interrupt_handlers_, bool uses_wall_clock_) : system{system_}, interrupt_handlers{interrupt_handlers_}, uses_wall_clock{ diff --git a/src/core/file_sys/vfs.h b/src/core/file_sys/vfs.h index 3e625fad6..1b9365853 100644 --- a/src/core/file_sys/vfs.h +++ b/src/core/file_sys/vfs.h @@ -12,6 +12,7 @@ #include #include +#include "common/common_funcs.h" #include "common/common_types.h" #include "core/file_sys/vfs_types.h" @@ -29,8 +30,11 @@ enum class VfsEntryType { // A class representing an abstract filesystem. A default implementation given the root VirtualDir // is provided for convenience, but if the Vfs implementation has any additional state or // functionality, they will need to override. -class VfsFilesystem : NonCopyable { +class VfsFilesystem { public: + YUZU_NON_COPYABLE(VfsFilesystem); + YUZU_NON_MOVEABLE(VfsFilesystem); + explicit VfsFilesystem(VirtualDir root); virtual ~VfsFilesystem(); @@ -77,8 +81,12 @@ protected: }; // A class representing a file in an abstract filesystem. -class VfsFile : NonCopyable { +class VfsFile { public: + YUZU_NON_COPYABLE(VfsFile); + YUZU_NON_MOVEABLE(VfsFile); + + VfsFile() = default; virtual ~VfsFile(); // Retrieves the file name. @@ -176,8 +184,12 @@ public: }; // A class representing a directory in an abstract filesystem. -class VfsDirectory : NonCopyable { +class VfsDirectory { public: + YUZU_NON_COPYABLE(VfsDirectory); + YUZU_NON_MOVEABLE(VfsDirectory); + + VfsDirectory() = default; virtual ~VfsDirectory(); // Retrives the file located at path as if the current directory was root. Returns nullptr if diff --git a/src/core/hle/kernel/k_memory_manager.h b/src/core/hle/kernel/k_memory_manager.h index abd6c8ace..17c7690f1 100644 --- a/src/core/hle/kernel/k_memory_manager.h +++ b/src/core/hle/kernel/k_memory_manager.h @@ -8,6 +8,7 @@ #include #include +#include "common/common_funcs.h" #include "common/common_types.h" #include "core/hle/kernel/k_page_heap.h" #include "core/hle/result.h" @@ -20,8 +21,11 @@ namespace Kernel { class KPageLinkedList; -class KMemoryManager final : NonCopyable { +class KMemoryManager final { public: + YUZU_NON_COPYABLE(KMemoryManager); + YUZU_NON_MOVEABLE(KMemoryManager); + enum class Pool : u32 { Application = 0, Applet = 1, @@ -88,26 +92,13 @@ public: } private: - class Impl final : NonCopyable { - private: - using RefCount = u16; - - private: - KPageHeap heap; - Pool pool{}; - + class Impl final { public: - static std::size_t CalculateManagementOverheadSize(std::size_t region_size); - - static constexpr std::size_t CalculateOptimizedProcessOverheadSize( - std::size_t region_size) { - return (Common::AlignUp((region_size / PageSize), Common::BitSize()) / - Common::BitSize()) * - sizeof(u64); - } + YUZU_NON_COPYABLE(Impl); + YUZU_NON_MOVEABLE(Impl); - public: Impl() = default; + ~Impl() = default; std::size_t Initialize(Pool new_pool, u64 start_address, u64 end_address); @@ -130,6 +121,21 @@ private: constexpr VAddr GetEndAddress() const { return heap.GetEndAddress(); } + + static std::size_t CalculateManagementOverheadSize(std::size_t region_size); + + static constexpr std::size_t CalculateOptimizedProcessOverheadSize( + std::size_t region_size) { + return (Common::AlignUp((region_size / PageSize), Common::BitSize()) / + Common::BitSize()) * + sizeof(u64); + } + + private: + using RefCount = u16; + + KPageHeap heap; + Pool pool{}; }; private: diff --git a/src/core/hle/kernel/k_memory_region.h b/src/core/hle/kernel/k_memory_region.h index 90ab8fd62..e9bdf4e59 100644 --- a/src/core/hle/kernel/k_memory_region.h +++ b/src/core/hle/kernel/k_memory_region.h @@ -5,6 +5,7 @@ #pragma once #include "common/assert.h" +#include "common/common_funcs.h" #include "common/common_types.h" #include "common/intrusive_red_black_tree.h" #include "core/hle/kernel/k_memory_region_type.h" @@ -13,11 +14,13 @@ namespace Kernel { class KMemoryRegionAllocator; -class KMemoryRegion final : public Common::IntrusiveRedBlackTreeBaseNode, - NonCopyable { +class KMemoryRegion final : public Common::IntrusiveRedBlackTreeBaseNode { friend class KMemoryRegionTree; public: + YUZU_NON_COPYABLE(KMemoryRegion); + YUZU_NON_MOVEABLE(KMemoryRegion); + constexpr KMemoryRegion() = default; constexpr KMemoryRegion(u64 address_, u64 last_address_) : address{address_}, last_address{last_address_} {} @@ -29,6 +32,8 @@ public: : KMemoryRegion(address_, last_address_, std::numeric_limits::max(), attributes_, type_id_) {} + ~KMemoryRegion() = default; + static constexpr int Compare(const KMemoryRegion& lhs, const KMemoryRegion& rhs) { if (lhs.GetAddress() < rhs.GetAddress()) { return -1; @@ -39,16 +44,6 @@ public: } } -private: - constexpr void Reset(u64 a, u64 la, u64 p, u32 r, u32 t) { - address = a; - pair_address = p; - last_address = la; - attributes = r; - type_id = t; - } - -public: constexpr u64 GetAddress() const { return address; } @@ -108,6 +103,14 @@ public: } private: + constexpr void Reset(u64 a, u64 la, u64 p, u32 r, u32 t) { + address = a; + pair_address = p; + last_address = la; + attributes = r; + type_id = t; + } + u64 address{}; u64 last_address{}; u64 pair_address{}; @@ -115,8 +118,25 @@ private: u32 type_id{}; }; -class KMemoryRegionTree final : NonCopyable { +class KMemoryRegionTree final { +private: + using TreeType = + Common::IntrusiveRedBlackTreeBaseTraits::TreeType; + public: + YUZU_NON_COPYABLE(KMemoryRegionTree); + YUZU_NON_MOVEABLE(KMemoryRegionTree); + + using value_type = TreeType::value_type; + using size_type = TreeType::size_type; + using difference_type = TreeType::difference_type; + using pointer = TreeType::pointer; + using const_pointer = TreeType::const_pointer; + using reference = TreeType::reference; + using const_reference = TreeType::const_reference; + using iterator = TreeType::iterator; + using const_iterator = TreeType::const_iterator; + struct DerivedRegionExtents { const KMemoryRegion* first_region{}; const KMemoryRegion* last_region{}; @@ -140,29 +160,9 @@ public: } }; -private: - using TreeType = - Common::IntrusiveRedBlackTreeBaseTraits::TreeType; - -public: - using value_type = TreeType::value_type; - using size_type = TreeType::size_type; - using difference_type = TreeType::difference_type; - using pointer = TreeType::pointer; - using const_pointer = TreeType::const_pointer; - using reference = TreeType::reference; - using const_reference = TreeType::const_reference; - using iterator = TreeType::iterator; - using const_iterator = TreeType::const_iterator; - -private: - TreeType m_tree{}; - KMemoryRegionAllocator& memory_region_allocator; - -public: explicit KMemoryRegionTree(KMemoryRegionAllocator& memory_region_allocator_); + ~KMemoryRegionTree() = default; -public: KMemoryRegion* FindModifiable(u64 address) { if (auto it = this->find(KMemoryRegion(address, address, 0, 0)); it != this->end()) { return std::addressof(*it); @@ -241,7 +241,6 @@ public: return GetDerivedRegionExtents(static_cast(type_id)); } -public: void InsertDirectly(u64 address, u64 last_address, u32 attr = 0, u32 type_id = 0); bool Insert(u64 address, size_t size, u32 type_id, u32 new_attr = 0, u32 old_attr = 0); @@ -252,7 +251,6 @@ public: return this->GetRandomAlignedRegion(size + 2 * guard_size, alignment, type_id) + guard_size; } -public: // Iterator accessors. iterator begin() { return m_tree.begin(); @@ -322,13 +320,21 @@ public: iterator nfind(const_reference ref) const { return m_tree.nfind(ref); } + +private: + TreeType m_tree{}; + KMemoryRegionAllocator& memory_region_allocator; }; -class KMemoryRegionAllocator final : NonCopyable { +class KMemoryRegionAllocator final { public: + YUZU_NON_COPYABLE(KMemoryRegionAllocator); + YUZU_NON_MOVEABLE(KMemoryRegionAllocator); + static constexpr size_t MaxMemoryRegions = 200; constexpr KMemoryRegionAllocator() = default; + constexpr ~KMemoryRegionAllocator() = default; template KMemoryRegion* Allocate(Args&&... args) { diff --git a/src/core/hle/kernel/k_page_heap.h b/src/core/hle/kernel/k_page_heap.h index 8d9f30523..a65aa28a0 100644 --- a/src/core/hle/kernel/k_page_heap.h +++ b/src/core/hle/kernel/k_page_heap.h @@ -8,14 +8,44 @@ #include #include "common/alignment.h" +#include "common/common_funcs.h" #include "common/common_types.h" #include "core/hle/kernel/k_page_bitmap.h" #include "core/hle/kernel/memory_types.h" namespace Kernel { -class KPageHeap final : NonCopyable { +class KPageHeap final { public: + YUZU_NON_COPYABLE(KPageHeap); + YUZU_NON_MOVEABLE(KPageHeap); + + KPageHeap() = default; + ~KPageHeap() = default; + + constexpr VAddr GetAddress() const { + return heap_address; + } + constexpr std::size_t GetSize() const { + return heap_size; + } + constexpr VAddr GetEndAddress() const { + return GetAddress() + GetSize(); + } + constexpr std::size_t GetPageOffset(VAddr block) const { + return (block - GetAddress()) / PageSize; + } + + void Initialize(VAddr heap_address, std::size_t heap_size, std::size_t metadata_size); + VAddr AllocateBlock(s32 index, bool random); + void Free(VAddr addr, std::size_t num_pages); + + void UpdateUsedSize() { + used_size = heap_size - (GetNumFreePages() * PageSize); + } + + static std::size_t CalculateManagementOverheadSize(std::size_t region_size); + static constexpr s32 GetAlignedBlockIndex(std::size_t num_pages, std::size_t align_pages) { const auto target_pages{std::max(num_pages, align_pages)}; for (std::size_t i = 0; i < NumMemoryBlockPageShifts; i++) { @@ -45,21 +75,13 @@ public: } private: - static constexpr std::size_t NumMemoryBlockPageShifts{7}; - static constexpr std::array MemoryBlockPageShifts{ - 0xC, 0x10, 0x15, 0x16, 0x19, 0x1D, 0x1E, - }; - - class Block final : NonCopyable { - private: - KPageBitmap bitmap; - VAddr heap_address{}; - uintptr_t end_offset{}; - std::size_t block_shift{}; - std::size_t next_block_shift{}; - + class Block final { public: + YUZU_NON_COPYABLE(Block); + YUZU_NON_MOVEABLE(Block); + Block() = default; + ~Block() = default; constexpr std::size_t GetShift() const { return block_shift; @@ -129,7 +151,6 @@ private: return heap_address + (offset << GetShift()); } - public: static constexpr std::size_t CalculateManagementOverheadSize(std::size_t region_size, std::size_t cur_block_shift, std::size_t next_block_shift) { @@ -139,35 +160,15 @@ private: return KPageBitmap::CalculateManagementOverheadSize( (align * 2 + Common::AlignUp(region_size, align)) / cur_block_size); } - }; - -public: - KPageHeap() = default; - - constexpr VAddr GetAddress() const { - return heap_address; - } - constexpr std::size_t GetSize() const { - return heap_size; - } - constexpr VAddr GetEndAddress() const { - return GetAddress() + GetSize(); - } - constexpr std::size_t GetPageOffset(VAddr block) const { - return (block - GetAddress()) / PageSize; - } - void Initialize(VAddr heap_address, std::size_t heap_size, std::size_t metadata_size); - VAddr AllocateBlock(s32 index, bool random); - void Free(VAddr addr, std::size_t num_pages); - - void UpdateUsedSize() { - used_size = heap_size - (GetNumFreePages() * PageSize); - } - - static std::size_t CalculateManagementOverheadSize(std::size_t region_size); + private: + KPageBitmap bitmap; + VAddr heap_address{}; + uintptr_t end_offset{}; + std::size_t block_shift{}; + std::size_t next_block_shift{}; + }; -private: constexpr std::size_t GetNumFreePages() const { std::size_t num_free{}; @@ -180,6 +181,11 @@ private: void FreeBlock(VAddr block, s32 index); + static constexpr std::size_t NumMemoryBlockPageShifts{7}; + static constexpr std::array MemoryBlockPageShifts{ + 0xC, 0x10, 0x15, 0x16, 0x19, 0x1D, 0x1E, + }; + VAddr heap_address{}; std::size_t heap_size{}; std::size_t used_size{}; diff --git a/src/core/hle/kernel/k_page_table.cpp b/src/core/hle/kernel/k_page_table.cpp index 2ebbc0819..393214082 100644 --- a/src/core/hle/kernel/k_page_table.cpp +++ b/src/core/hle/kernel/k_page_table.cpp @@ -63,6 +63,8 @@ constexpr std::size_t GetSizeInRange(const KMemoryInfo& info, VAddr start, VAddr KPageTable::KPageTable(Core::System& system_) : system{system_} {} +KPageTable::~KPageTable() = default; + ResultCode KPageTable::InitializeForProcess(FileSys::ProgramAddressSpaceType as_type, bool enable_aslr, VAddr code_addr, std::size_t code_size, KMemoryManager::Pool pool) { diff --git a/src/core/hle/kernel/k_page_table.h b/src/core/hle/kernel/k_page_table.h index 60ae9b9e8..ecae939a0 100644 --- a/src/core/hle/kernel/k_page_table.h +++ b/src/core/hle/kernel/k_page_table.h @@ -7,6 +7,7 @@ #include #include +#include "common/common_funcs.h" #include "common/common_types.h" #include "common/page_table.h" #include "core/file_sys/program_metadata.h" @@ -22,9 +23,13 @@ namespace Kernel { class KMemoryBlockManager; -class KPageTable final : NonCopyable { +class KPageTable final { public: + YUZU_NON_COPYABLE(KPageTable); + YUZU_NON_MOVEABLE(KPageTable); + explicit KPageTable(Core::System& system_); + ~KPageTable(); ResultCode InitializeForProcess(FileSys::ProgramAddressSpaceType as_type, bool enable_aslr, VAddr code_addr, std::size_t code_size, diff --git a/src/core/hle/kernel/k_slab_heap.h b/src/core/hle/kernel/k_slab_heap.h index 0ad74b0a0..05c0bec9c 100644 --- a/src/core/hle/kernel/k_slab_heap.h +++ b/src/core/hle/kernel/k_slab_heap.h @@ -7,6 +7,7 @@ #include #include "common/assert.h" +#include "common/common_funcs.h" #include "common/common_types.h" namespace Kernel { @@ -15,13 +16,17 @@ class KernelCore; namespace impl { -class KSlabHeapImpl final : NonCopyable { +class KSlabHeapImpl final { public: + YUZU_NON_COPYABLE(KSlabHeapImpl); + YUZU_NON_MOVEABLE(KSlabHeapImpl); + struct Node { Node* next{}; }; constexpr KSlabHeapImpl() = default; + constexpr ~KSlabHeapImpl() = default; void Initialize(std::size_t size) { ASSERT(head == nullptr); @@ -64,9 +69,13 @@ private: } // namespace impl -class KSlabHeapBase : NonCopyable { +class KSlabHeapBase { public: + YUZU_NON_COPYABLE(KSlabHeapBase); + YUZU_NON_MOVEABLE(KSlabHeapBase); + constexpr KSlabHeapBase() = default; + constexpr ~KSlabHeapBase() = default; constexpr bool Contains(uintptr_t addr) const { return start <= addr && addr < end; diff --git a/src/core/loader/loader.h b/src/core/loader/loader.h index 7b1bac3f7..8b6b3b68f 100644 --- a/src/core/loader/loader.h +++ b/src/core/loader/loader.h @@ -11,6 +11,7 @@ #include #include +#include "common/common_funcs.h" #include "common/common_types.h" #include "core/file_sys/control_metadata.h" #include "core/file_sys/vfs.h" @@ -139,8 +140,11 @@ std::string GetResultStatusString(ResultStatus status); std::ostream& operator<<(std::ostream& os, ResultStatus status); /// Interface for loading an application -class AppLoader : NonCopyable { +class AppLoader { public: + YUZU_NON_COPYABLE(AppLoader); + YUZU_NON_MOVEABLE(AppLoader); + struct LoadParameters { s32 main_thread_priority; u64 main_thread_stack_size; diff --git a/src/video_core/renderer_base.h b/src/video_core/renderer_base.h index bb204454e..c5f974080 100644 --- a/src/video_core/renderer_base.h +++ b/src/video_core/renderer_base.h @@ -5,9 +5,10 @@ #pragma once #include +#include #include -#include +#include "common/common_funcs.h" #include "common/common_types.h" #include "core/frontend/emu_window.h" #include "video_core/gpu.h" @@ -28,8 +29,11 @@ struct RendererSettings { Layout::FramebufferLayout screenshot_framebuffer_layout; }; -class RendererBase : NonCopyable { +class RendererBase { public: + YUZU_NON_COPYABLE(RendererBase); + YUZU_NON_MOVEABLE(RendererBase); + explicit RendererBase(Core::Frontend::EmuWindow& window, std::unique_ptr context); virtual ~RendererBase(); diff --git a/src/video_core/renderer_opengl/gl_resource_manager.h b/src/video_core/renderer_opengl/gl_resource_manager.h index b2d5bfd3b..84e07f8bd 100644 --- a/src/video_core/renderer_opengl/gl_resource_manager.h +++ b/src/video_core/renderer_opengl/gl_resource_manager.h @@ -7,12 +7,14 @@ #include #include #include -#include "common/common_types.h" +#include "common/common_funcs.h" namespace OpenGL { -class OGLRenderbuffer : private NonCopyable { +class OGLRenderbuffer final { public: + YUZU_NON_COPYABLE(OGLRenderbuffer); + OGLRenderbuffer() = default; OGLRenderbuffer(OGLRenderbuffer&& o) noexcept : handle(std::exchange(o.handle, 0)) {} @@ -36,8 +38,10 @@ public: GLuint handle = 0; }; -class OGLTexture : private NonCopyable { +class OGLTexture final { public: + YUZU_NON_COPYABLE(OGLTexture); + OGLTexture() = default; OGLTexture(OGLTexture&& o) noexcept : handle(std::exchange(o.handle, 0)) {} @@ -61,8 +65,10 @@ public: GLuint handle = 0; }; -class OGLTextureView : private NonCopyable { +class OGLTextureView final { public: + YUZU_NON_COPYABLE(OGLTextureView); + OGLTextureView() = default; OGLTextureView(OGLTextureView&& o) noexcept : handle(std::exchange(o.handle, 0)) {} @@ -86,8 +92,10 @@ public: GLuint handle = 0; }; -class OGLSampler : private NonCopyable { +class OGLSampler final { public: + YUZU_NON_COPYABLE(OGLSampler); + OGLSampler() = default; OGLSampler(OGLSampler&& o) noexcept : handle(std::exchange(o.handle, 0)) {} @@ -111,8 +119,10 @@ public: GLuint handle = 0; }; -class OGLShader : private NonCopyable { +class OGLShader final { public: + YUZU_NON_COPYABLE(OGLShader); + OGLShader() = default; OGLShader(OGLShader&& o) noexcept : handle(std::exchange(o.handle, 0)) {} @@ -132,8 +142,10 @@ public: GLuint handle = 0; }; -class OGLProgram : private NonCopyable { +class OGLProgram final { public: + YUZU_NON_COPYABLE(OGLProgram); + OGLProgram() = default; OGLProgram(OGLProgram&& o) noexcept : handle(std::exchange(o.handle, 0)) {} @@ -154,8 +166,10 @@ public: GLuint handle = 0; }; -class OGLAssemblyProgram : private NonCopyable { +class OGLAssemblyProgram final { public: + YUZU_NON_COPYABLE(OGLAssemblyProgram); + OGLAssemblyProgram() = default; OGLAssemblyProgram(OGLAssemblyProgram&& o) noexcept : handle(std::exchange(o.handle, 0)) {} @@ -176,8 +190,10 @@ public: GLuint handle = 0; }; -class OGLPipeline : private NonCopyable { +class OGLPipeline final { public: + YUZU_NON_COPYABLE(OGLPipeline); + OGLPipeline() = default; OGLPipeline(OGLPipeline&& o) noexcept : handle{std::exchange(o.handle, 0)} {} @@ -198,8 +214,10 @@ public: GLuint handle = 0; }; -class OGLBuffer : private NonCopyable { +class OGLBuffer final { public: + YUZU_NON_COPYABLE(OGLBuffer); + OGLBuffer() = default; OGLBuffer(OGLBuffer&& o) noexcept : handle(std::exchange(o.handle, 0)) {} @@ -223,8 +241,10 @@ public: GLuint handle = 0; }; -class OGLSync : private NonCopyable { +class OGLSync final { public: + YUZU_NON_COPYABLE(OGLSync); + OGLSync() = default; OGLSync(OGLSync&& o) noexcept : handle(std::exchange(o.handle, nullptr)) {} @@ -247,8 +267,10 @@ public: GLsync handle = 0; }; -class OGLFramebuffer : private NonCopyable { +class OGLFramebuffer final { public: + YUZU_NON_COPYABLE(OGLFramebuffer); + OGLFramebuffer() = default; OGLFramebuffer(OGLFramebuffer&& o) noexcept : handle(std::exchange(o.handle, 0)) {} @@ -272,8 +294,10 @@ public: GLuint handle = 0; }; -class OGLQuery : private NonCopyable { +class OGLQuery final { public: + YUZU_NON_COPYABLE(OGLQuery); + OGLQuery() = default; OGLQuery(OGLQuery&& o) noexcept : handle(std::exchange(o.handle, 0)) {} -- cgit v1.2.3 From ade44ac2ea66777e412644a273a43cbada55e6d6 Mon Sep 17 00:00:00 2001 From: Lioncash Date: Wed, 2 Feb 2022 13:18:58 -0500 Subject: common_types: Remove NonCopyable struct Now that we're moved over to the YUZU_ defines, we can get rid of this struct. --- src/common/common_types.h | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/src/common/common_types.h b/src/common/common_types.h index 4cec89fbd..99bffc460 100644 --- a/src/common/common_types.h +++ b/src/common/common_types.h @@ -46,13 +46,3 @@ using GPUVAddr = u64; ///< Represents a pointer in the GPU virtual address space using u128 = std::array; static_assert(sizeof(u128) == 16, "u128 must be 128 bits wide"); - -// An inheritable class to disallow the copy constructor and operator= functions -class NonCopyable { -protected: - constexpr NonCopyable() = default; - ~NonCopyable() = default; - - NonCopyable(const NonCopyable&) = delete; - NonCopyable& operator=(const NonCopyable&) = delete; -}; -- cgit v1.2.3