BSPointerHandle RE

Author: powerof3

include/RE/B/BSPointerHandle.h

@@ -63,7 +63,7 @@ namespace RE
 		}
 
 		[[nodiscard]] explicit operator bool() const noexcept { return has_value(); }
-		[[nodiscard]] bool has_value() const noexcept { return _handle != 0; }
+		[[nodiscard]] bool     has_value() const noexcept { return _handle != 0; }
 
 		[[nodiscard]] value_type value() const noexcept { return _handle; }
 
@@ -152,17 +152,17 @@ namespace RE
 
 		void reset() noexcept { _handle.reset(); }
 
-		[[nodiscard]] NiPointer<T> get() const
+		[[nodiscard]] NiPointer<T> get()
 		{
 			NiPointer<T> ptr;
 			get_smartptr(ptr);
 			return ptr;
 		}
 
-		[[nodiscard]] NiPointer<T> getsafe() const
+		[[nodiscard]] NiPointer<T> get() const
 		{
 			NiPointer<T> ptr;
-			get_validated_smartptr(ptr);
+			get_smartptr(ptr);
 			return ptr;
 		}
 
@@ -185,8 +185,8 @@ namespace RE
 		friend class BSPointerHandle;
 
 		void get_handle(T* a_ptr);
+		bool get_smartptr(NiPointer<T>& a_smartPointerOut);
 		bool get_smartptr(NiPointer<T>& a_smartPointerOut) const;
-		bool get_validated_smartptr(NiPointer<T>& a_smartPointerOut) const;
 
 		Handle _handle;
 	};
@@ -222,17 +222,17 @@ namespace RE
 			return func(a_ptr);
 		}
 
-		static bool GetSmartPointer(const BSPointerHandle<T>& a_handle, NiPointer<T>& a_smartPointerOut)
+		static bool GetSmartPointer(BSPointerHandle<T>& a_handle, NiPointer<T>& a_smartPointerOut)  // clears the handle
 		{
-			using func_t = decltype(&BSPointerHandleManagerInterface<T, Manager>::GetSmartPointer);
-			static REL::Relocation<func_t> func{ RELOCATION_ID(12204, 12332) };
+			using func_t = bool (*)(BSPointerHandle<T>&, NiPointer<T>&);
+			static REL::Relocation<func_t> func{ RELOCATION_ID(12785, 12922) };
 			return func(a_handle, a_smartPointerOut);
 		}
 
-		static bool GetHandleValidatedSmartPointer(const BSPointerHandle<T>& a_handle, NiPointer<T>& a_smartPointerOut)
+		static bool GetSmartPointer(const BSPointerHandle<T>& a_handle, NiPointer<T>& a_smartPointerOut)
 		{
-			using func_t = decltype(&BSPointerHandleManagerInterface<T, Manager>::GetHandleValidatedSmartPointer);
-			static REL::Relocation<func_t> func{ RELOCATION_ID(12785, 12922) };
+			using func_t = bool (*)(const BSPointerHandle<T>&, NiPointer<T>&);
+			static REL::Relocation<func_t> func{ RELOCATION_ID(12204, 12332) };
 			return func(a_handle, a_smartPointerOut);
 		}
 	};
@@ -248,14 +248,14 @@ namespace RE
 	}
 
 	template <class T, class Handle>
-	bool BSPointerHandle<T, Handle>::get_smartptr(NiPointer<T>& a_smartPointerOut) const
+	bool BSPointerHandle<T, Handle>::get_smartptr(NiPointer<T>& a_smartPointerOut)
 	{
 		return BSPointerHandleManagerInterface<T>::GetSmartPointer(*this, a_smartPointerOut);
 	}
 
 	template <class T, class Handle>
-	bool BSPointerHandle<T, Handle>::get_validated_smartptr(NiPointer<T>& a_smartPointerOut) const
+	bool BSPointerHandle<T, Handle>::get_smartptr(NiPointer<T>& a_smartPointerOut) const
 	{
-		return BSPointerHandleManagerInterface<T>::GetHandleValidatedSmartPointer(*this, a_smartPointerOut);
+		return BSPointerHandleManagerInterface<T>::GetSmartPointer(*this, a_smartPointerOut);
 	}
 }

include/RE/B/BSPointerHandleManager.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "RE/B/BSHandleRefObject.h"
+#include "RE/B/BSPointerHandle.h"
 #include "RE/N/NiSmartPointer.h"
 
 namespace RE
@@ -12,23 +12,42 @@ namespace RE
 		struct Entry
 		{
 		public:
-			enum EntryBitfieldConstants : std::uint32_t
+			enum class EntryBitfieldConstants
 			{
-				//kAgeInc = (1 << T::kFreeListBits),	// 0x100000
-				//kFreeListMask = kAgeInc - 1,	// 0xFFFFF
-				//kInUseBit = kAgeInc << kAgeShift	// 0x4000000
+				kAgeInc = 1 << 20,            // (1 << T::kFreeListBits)
+				kFreeListMask = kAgeInc - 1,  // 0xFFFFF
+				kInUseBit = 1 << 26           // kAgeInc << T::kAgeShift
 			};
 
+			[[nodiscard]] bool IsInUse() const
+			{
+				return handleEntryBits.any(EntryBitfieldConstants::kInUseBit);
+			}
+
 			// members
-			std::uint32_t                handleEntryBits;  // 00
-			std::uint32_t                pad04;            // 04
-			NiPointer<BSHandleRefObject> pointer;          // 08
+			REX::EnumSet<EntryBitfieldConstants, std::uint32_t> handleEntryBits;  // 00
+			std::uint32_t                                       pad04;            // 04
+			NiPointer<BSHandleRefObject>                        pointer;          // 08
 		};
+		static_assert(sizeof(Entry) == 0x10);
+
+		[[nodiscard]] static bool IsValid(const ObjectRefHandle& a_handle)
+		{
+			using func_t = decltype(&BSPointerHandleManager<TESObjectREFR>::IsValid);
+			static REL::Relocation<func_t> func{ RELOCATION_ID(75454, 77239) };
+			return func(a_handle);
+		}
 
 		[[nodiscard]] static auto GetHandleEntries()
 		{
 			static REL::Relocation<Entry(*)[0x100000]> entries{ RELOCATION_ID(514478, 400622) };
 			return std::span<Entry, 0x100000>{ *entries };
 		}
+
+		[[nodiscard]] static BSReadWriteLock& GetHandleManagerLock()
+		{
+			static REL::Relocation<BSReadWriteLock*> handleManagerLock{ RELOCATION_ID(514477, 400621) };
+			return *handleManagerLock;
+		}
 	};
 }