mem_addr.hpp

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <type_traits>
 
namespace plugify {
    class MemAddr {
    public:
        MemAddr() noexcept : _ptr{0} {}
 
        MemAddr(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)} {}
 
        operator uintptr_t() const noexcept {
            return _ptr;
        }
 
        operator void*() const noexcept {
            return reinterpret_cast<void*>(_ptr);
        }
 
        explicit operator bool() const noexcept {
            return _ptr != 0;
        }
 
        bool operator!=(const MemAddr& addr) const noexcept {
            return _ptr != addr._ptr;
        }
 
        bool operator==(const MemAddr& addr) const noexcept {
            return _ptr == addr._ptr;
        }
 
        bool operator==(const uintptr_t& addr) const noexcept {
            return _ptr == addr;
        }
 
        uintptr_t GetPtr() const noexcept {
            return _ptr;
        }
 
        template<class T>
        T GetValue() const noexcept {
            return *reinterpret_cast<T*>(_ptr);
        }
 
        template<typename T>
        T CCast() const noexcept {
            return (T) _ptr;
        }
 
        template<typename T>
        T RCast() const noexcept {
            return reinterpret_cast<T>(_ptr);
        }
 
        template<typename T>
        T UCast() const noexcept {
            union {
                uintptr_t m_ptr;
                T cptr;
            } cast;
            return cast.m_ptr = _ptr, cast.cptr;
        }
 
        MemAddr Offset(ptrdiff_t offset) const noexcept {
            return _ptr + static_cast<uintptr_t>(offset);
        }
 
        MemAddr& OffsetSelf(ptrdiff_t offset) noexcept {
            _ptr += static_cast<uintptr_t>(offset);
            return *this;
        }
 
        MemAddr Deref(ptrdiff_t deref = 1) const {
            uintptr_t reference = _ptr;
 
            while (deref--) {
                if (reference)
                    reference = *reinterpret_cast<uintptr_t*>(reference);
            }
 
            return reference;
        }
 
        MemAddr& DerefSelf(ptrdiff_t deref = 1) {
            while (deref--) {
                if (_ptr)
                    _ptr = *reinterpret_cast<uintptr_t*>(_ptr);
            }
 
            return *this;
        }
 
        MemAddr FollowNearCall(ptrdiff_t opcodeOffset = 0x1, ptrdiff_t nextInstructionOffset = 0x5) const {
            return ResolveRelativeAddress(opcodeOffset, nextInstructionOffset);
        }
 
        MemAddr& FollowNearCallSelf(ptrdiff_t opcodeOffset = 0x1, ptrdiff_t nextInstructionOffset = 0x5) {
            return ResolveRelativeAddressSelf(opcodeOffset, nextInstructionOffset);
        }
 
        MemAddr ResolveRelativeAddress(ptrdiff_t registerOffset = 0x0, 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 + (uintptr_t) relativeAddress;
        }
 
        MemAddr& ResolveRelativeAddressSelf(ptrdiff_t registerOffset = 0x0, 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:
        uintptr_t _ptr; 
    };
}// namespace plugify