mem_addr.hpp

#pragma once
 
#include <cstddef>
#include <cstdint>
 
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