mem_addr.hpp

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <type_traits>
 
namespace plugify {
    class MemAddr {
    public:
        constexpr MemAddr() noexcept
            : _ptr{ 0 } {
        }
 
        constexpr MemAddr(const uintptr_t ptr) noexcept
            : _ptr{ ptr } {
        }
 
        template <typename T>
            requires(std::is_pointer_v<T> or std::is_null_pointer_v<T>)
        MemAddr(T ptr) noexcept
            : _ptr{ reinterpret_cast<uintptr_t>(ptr) } {
        }
 
        constexpr MemAddr(const MemAddr& other) noexcept = default;
 
        constexpr MemAddr(MemAddr&& other) noexcept = default;
 
        constexpr MemAddr& operator=(const MemAddr& other) noexcept = default;
 
        constexpr MemAddr& operator=(MemAddr&& other) noexcept = default;
 
        constexpr operator uintptr_t() const noexcept {
            return _ptr;
        }
 
        constexpr operator void*() const noexcept {
            return _addr;
        }
 
        constexpr explicit operator bool() const noexcept {
            return _ptr != 0;
        }
 
        constexpr bool operator!=(const MemAddr addr) const noexcept {
            return _ptr != addr._ptr;
        }
 
        constexpr bool operator<(const MemAddr addr) const noexcept {
            return _ptr < addr._ptr;
        }
 
        constexpr bool operator==(const MemAddr addr) const noexcept {
            return _ptr == addr._ptr;
        }
 
        constexpr bool operator==(const uintptr_t addr) const noexcept {
            return _ptr == addr;
        }
 
        constexpr uintptr_t GetPtr() const noexcept {
            return _ptr;
        }
 
        template <class T>
        constexpr T GetValue() const noexcept {
            return *reinterpret_cast<T*>(_ptr);
        }
 
        template <typename T>
        constexpr T CCast() const noexcept {
            return (T) _ptr;
        }
 
        template <typename T>
        constexpr T RCast() const noexcept {
            return reinterpret_cast<T>(_ptr);
        }
 
        template <typename T>
        constexpr T UCast() const noexcept {
            union {
                uintptr_t ptr;
                T val;
            } cast;
 
            return cast.ptr = _ptr, cast.val;
        }
 
        constexpr MemAddr Offset(const ptrdiff_t offset) const noexcept {
            return _ptr + static_cast<uintptr_t>(offset);
        }
 
        constexpr MemAddr& OffsetSelf(const ptrdiff_t offset) noexcept {
            _ptr += static_cast<uintptr_t>(offset);
            return *this;
        }
 
        constexpr MemAddr Deref(ptrdiff_t deref = 1) const {
            uintptr_t reference = _ptr;
 
            while (deref--) {
                if (reference) {
                    reference = *reinterpret_cast<uintptr_t*>(reference);
                }
            }
 
            return reference;
        }
 
        constexpr MemAddr& DerefSelf(ptrdiff_t deref = 1) {
            while (deref--) {
                if (_ptr) {
                    _ptr = *reinterpret_cast<uintptr_t*>(_ptr);
                }
            }
 
            return *this;
        }
 
        MemAddr FollowNearCall(
            const ptrdiff_t opcodeOffset = 0x1,
            const ptrdiff_t nextInstructionOffset = 0x5
        ) const {
            return ResolveRelativeAddress(opcodeOffset, nextInstructionOffset);
        }
 
        MemAddr& FollowNearCallSelf(
            const ptrdiff_t opcodeOffset = 0x1,
            const ptrdiff_t nextInstructionOffset = 0x5
        ) {
            return ResolveRelativeAddressSelf(opcodeOffset, nextInstructionOffset);
        }
 
        MemAddr ResolveRelativeAddress(
            const ptrdiff_t registerOffset = 0x0,
            const ptrdiff_t nextInstructionOffset = 0x4
        ) const {
            const uintptr_t skipRegister = _ptr + static_cast<uintptr_t>(registerOffset);
            const int32_t relativeAddress = *reinterpret_cast<int32_t*>(skipRegister);
            const uintptr_t nextInstruction = _ptr + static_cast<uintptr_t>(nextInstructionOffset);
            return nextInstruction + static_cast<uintptr_t>(relativeAddress);
        }
 
        MemAddr& ResolveRelativeAddressSelf(
            const ptrdiff_t registerOffset = 0x0,
            const ptrdiff_t nextInstructionOffset = 0x4
        ) {
            const uintptr_t skipRegister = _ptr + static_cast<uintptr_t>(registerOffset);
            const int32_t relativeAddress = *reinterpret_cast<int32_t*>(skipRegister);
            const uintptr_t nextInstruction = _ptr + static_cast<uintptr_t>(nextInstructionOffset);
            _ptr = nextInstruction + static_cast<uintptr_t>(relativeAddress);
            return *this;
        }
 
    private:
        union {
            void* _addr;
            uintptr_t _ptr;
        };  
    };
}  // namespace plugify