You can not select more than 25 topics
			Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
		
		
		
		
		
			
		
			
				
					
					
						
							55 lines
						
					
					
						
							1.3 KiB
						
					
					
				
			
		
		
		
			
			
			
				
					
				
				
					
				
			
		
		
	
	
							55 lines
						
					
					
						
							1.3 KiB
						
					
					
				
								#pragma once
							 | 
						|
								
							 | 
						|
								#include <type_traits>
							 | 
						|
								
							 | 
						|
								template <typename T>
							 | 
						|
								struct alignas(8) pointer_wrapper {
							 | 
						|
								    static_assert(std::is_object_v<T>, "T must be an object type");
							 | 
						|
								
							 | 
						|
								    pointer_wrapper() noexcept = default;
							 | 
						|
								
							 | 
						|
								    explicit pointer_wrapper(T* p) noexcept : ptr(p) {}
							 | 
						|
								
							 | 
						|
								    explicit pointer_wrapper(T&& x) noexcept
							 | 
						|
								    {
							 | 
						|
								        T& ref = std::forward<T&&>(x);
							 | 
						|
								        ptr    = std::addressof(ref);
							 | 
						|
								    }
							 | 
						|
								
							 | 
						|
								    T& get() const noexcept { return *ptr; }
							 | 
						|
								
							 | 
						|
								    auto operator->() const noexcept { return ptr; }
							 | 
						|
								
							 | 
						|
								    operator T&() const noexcept { return *ptr; }
							 | 
						|
								
							 | 
						|
								    auto operator*() const noexcept { return *ptr; }
							 | 
						|
								
							 | 
						|
								    auto operator*() noexcept { return *ptr; }
							 | 
						|
								
							 | 
						|
								    T copy() const noexcept { return *ptr; }
							 | 
						|
								
							 | 
						|
								    auto raw() const noexcept -> T* { return ptr; }
							 | 
						|
								
							 | 
						|
								    operator bool() const noexcept { return ptr != nullptr; }
							 | 
						|
								
							 | 
						|
								    void clear() noexcept { ptr = nullptr; }
							 | 
						|
								
							 | 
						|
								    bool operator==(const pointer_wrapper<T>& other) const noexcept { return ptr == other.ptr; }
							 | 
						|
								
							 | 
						|
								    bool operator!=(const pointer_wrapper<T>& other) const noexcept { return ptr != other.ptr; }
							 | 
						|
								
							 | 
						|
								private:
							 | 
						|
								    T* ptr{nullptr};
							 | 
						|
								};
							 | 
						|
								
							 | 
						|
								template <typename T>
							 | 
						|
								auto make_pointer_wrapper(T* p) noexcept -> pointer_wrapper<T>
							 | 
						|
								{
							 | 
						|
								    return pointer_wrapper<T>(p);
							 | 
						|
								}
							 | 
						|
								
							 | 
						|
								template <typename T>
							 | 
						|
								auto make_pointer_wrapper(T& x) noexcept -> pointer_wrapper<T>
							 | 
						|
								{
							 | 
						|
								    return pointer_wrapper<T>(&x);
							 | 
						|
								}
							 |