Struct Pointer

pub struct Pointer<T> {
    pub ptr: *mut T,
}

Pointer wrapper struct for raw pointers This is for wrapping raw pointers to make them safe for multithreading

This is for internal use only

Fields

ptr: *mut T

raw pointer

Implementations

impl<T> Pointer<T>

pub fn cast<U>(&self) -> Pointer<U>

cast the pointer to a new type

Arguments

U - the new type

Returns

Pointer<U>

pub fn get_ptr(&self) -> *mut T

return raw pointer

Returns

*mut T

Example

use tensor_pointer::Pointer;
let mut _a = 10;
let a = Pointer::<i32>::new(_a as *mut i32);
let b = a.get_ptr();
assert_eq!(b, _a as *mut i32);

pub fn new(ptr: *mut T) -> Self

Wrap a raw pointer into a Pointer struct for supporting Send in multithreading, zero cost

Arguments

ptr - *mut T

Returns

Pointer<T>

Example

use tensor_pointer::Pointer;
let mut _a = 10i32;
let a = Pointer::<i32>::new(_a as *mut i32);
assert_eq!(a.read(), 10);

pub fn modify(&mut self, offset: i64, value: T)

modify the value of the pointer in the address by the specified offset

Arguments

offset - the offset from the current address value - the value to be written

Example

use tensor_pointer::Pointer;
let mut _a = unsafe { std::alloc::alloc(std::alloc::Layout::new::<i32>()) as *mut i32 };
let mut a = Pointer::<i32>::new(_a);
a.modify(0, 10);
assert_eq!(a.read(), 10);
unsafe { std::alloc::dealloc(_a as *mut u8, std::alloc::Layout::new::<i32>()); }

pub fn add(&mut self, offset: usize)

inplace increment the value of the pointer in the current address

Arguments

value - the value to be added

Example

use tensor_pointer::Pointer;
let mut _a = unsafe { std::alloc::alloc(std::alloc::Layout::new::<i32>()) as *mut i32 };
unsafe { _a.write(10); }
let mut a = Pointer::<i32>::new(_a);
a.add(0);
assert_eq!(a.read(), 10);
unsafe { std::alloc::dealloc(_a as *mut u8, std::alloc::Layout::new::<i32>()); }

pub fn offset(&mut self, offset: i64)

inplace offset the value of the pointer in the current address

Arguments

offset - the offset to be added

Example

use tensor_pointer::Pointer;
let mut _a = unsafe { std::alloc::alloc(std::alloc::Layout::new::<i32>()) as *mut i32 };
unsafe { _a.write(10); }
let mut a = Pointer::<i32>::new(_a);
a.offset(0);
assert_eq!(a.read(), 10);
unsafe { std::alloc::dealloc(_a as *mut u8, std::alloc::Layout::new::<i32>()); }

Trait Implementations

impl<T> Add<i64> for Pointer<T>

type Output = Pointer<T>

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> Self::Output

Performs the + operation.

impl<T> Add<isize> for Pointer<T>

type Output = Pointer<T>

The resulting type after applying the + operator.

fn add(self, rhs: isize) -> Self::Output

Performs the + operation.

impl<T> Add<usize> for &mut Pointer<T>

type Output = Pointer<T>

The resulting type after applying the + operator.

fn add(self, rhs: usize) -> Self::Output

Performs the + operation.

impl<T> Add<usize> for Pointer<T>

type Output = Pointer<T>

The resulting type after applying the + operator.

fn add(self, rhs: usize) -> Self::Output

Performs the + operation.

impl<T> AddAssign<i64> for &mut Pointer<T>

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl<T> AddAssign<i64> for Pointer<T>

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl<T> AddAssign<isize> for Pointer<T>

fn add_assign(&mut self, rhs: isize)

Performs the += operation.

impl<T> AddAssign<usize> for &mut Pointer<T>

fn add_assign(&mut self, rhs: usize)

Performs the += operation.

impl<T> AddAssign<usize> for Pointer<T>

fn add_assign(&mut self, rhs: usize)

Performs the += operation.

impl<T> Clone for Pointer<T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Pointer<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Deref for Pointer<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for Pointer<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: Display> Display for Pointer<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Index<i64> for Pointer<T>

type Output = T

The returned type after indexing.

fn index(&self, index: i64) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: Display> Index<isize> for Pointer<T>

type Output = T

The returned type after indexing.

fn index(&self, index: isize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: Display> Index<usize> for Pointer<T>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: Display> IndexMut<i64> for Pointer<T>

fn index_mut(&mut self, index: i64) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T: Display> IndexMut<isize> for Pointer<T>

fn index_mut(&mut self, index: isize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T: Display> IndexMut<usize> for Pointer<T>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T> SubAssign<i64> for &mut Pointer<T>

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<T> SubAssign<i64> for Pointer<T>

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<T> SubAssign<isize> for Pointer<T>

fn sub_assign(&mut self, rhs: isize)

Performs the -= operation.

impl<T> SubAssign<usize> for Pointer<T>

fn sub_assign(&mut self, rhs: usize)

Performs the -= operation.

impl<T> Send for Pointer<T>

impl<T> Sync for Pointer<T>