Struct SendSyncPtr

pub struct SendSyncPtr<T: ?Sized>(/* private fields */);

A pointer that implements Send and Sync regardless of whether T implements both Send and Sync.

Safety

This pointer can be sent to another worker. Owner must guarantee that sending the pointer is safe. For instance, if you are controlling access to pointer over workers completely, it will be safe in terms of Send and Sync.

Implementations

impl<T: ?Sized> SendSyncPtr<T>

pub const fn new(ptr: NonNull<T>) -> Self

Creates a SendSyncPtr by wrapping the given pointer.

Examples

use my_ecs::ds::SendSyncPtr;
use std::ptr::NonNull;

let mut v = 0;
let ptr = NonNull::new(&mut v as *mut i32).unwrap();
let ptr = SendSyncPtr::new(ptr);

pub const fn dangling() -> Self

where T: Sized,

Creates a SendSyncPtr that is dangling, but well-aligned.

In many Rust functions, they require aligned pointers even if they are some trash values. This function will be usuful in that cases.

Examples

use my_ecs::ds::SendSyncPtr;
use std::ptr::NonNull;

let dangling = SendSyncPtr::<i32>::dangling();

pub fn is_dangling(&self) -> bool

where T: Sized,

Returns true if the pointer is dangling.

Examples

use my_ecs::ds::SendSyncPtr;

let dangling = SendSyncPtr::<i32>::dangling();
assert!(dangling.is_dangling());

pub const fn as_nonnull(self) -> NonNull<T>

Creates a NonNull from this pointer.

Examples

use my_ecs::ds::SendSyncPtr;
use std::ptr::NonNull;

let mut v = 0;
let nn = NonNull::new(&mut v as *mut i32).unwrap();
let ptr = SendSyncPtr::new(nn);
assert_eq!(ptr.as_nonnull(), nn);

pub const fn as_ptr(self) -> *mut T

Creates a raw pointer from this pointer.

Examples

use my_ecs::ds::SendSyncPtr;
use std::ptr::NonNull;

let mut v = 0;
let nn = NonNull::new(&mut v as *mut i32).unwrap();
let ptr = SendSyncPtr::new(nn);
assert_eq!(ptr.as_ptr(), nn.as_ptr());

pub const unsafe fn as_ref<'a>(&self) -> &'a T

Returns a shared reference to the value.

Safety

See NonNull::as_ref.

Examples

use my_ecs::ds::SendSyncPtr;
use std::ptr::NonNull;

let mut v = 0;
let ptr = NonNull::new(&mut v as *mut i32).unwrap();
let ptr = SendSyncPtr::new(ptr);
let ref_v = unsafe { ptr.as_ref() };
assert_eq!(ref_v, &v);

pub unsafe fn as_mut<'a>(&mut self) -> &'a mut T

Returns a mutable reference to the value.

Safety

See NonNull::as_mut.

Examples

use my_ecs::ds::SendSyncPtr;
use std::ptr::NonNull;

let mut v = 0;
let ptr = NonNull::new(&mut v as *mut i32).unwrap();
let mut ptr = SendSyncPtr::new(ptr);
let mut_v = unsafe { ptr.as_mut() };
assert_eq!(mut_v, &mut v);

pub const unsafe fn add(self, count: usize) -> Self

where T: Sized,

Adds an offset to the pointer then returns the result.

Note that count is in units of T. For example, count = 3 means 12 bytes offset if T is i32.

Safety

See NonNull::add.

Examples

use my_ecs::ds::SendSyncPtr;
use std::ptr::NonNull;

let arr: [char; 3] = ['a', 'b', 'c'];
let ptr = NonNull::new(arr.as_ptr().cast_mut()).unwrap();
let ptr = SendSyncPtr::new(ptr);

let ref_v = unsafe { ptr.add(1).as_ref() };
assert_eq!(ref_v, &'b');

let ref_v = unsafe { ptr.add(2).as_ref() };
assert_eq!(ref_v, &'c');

pub const unsafe fn sub(self, count: usize) -> Self

where T: Sized,

Subtracts an offset from the pointer then returns the result.

Note that count is in units of T. For example, count = 3 means 12 bytes offset if T is i32.

Safety

See NonNull::sub.

Examples

use my_ecs::ds::SendSyncPtr;
use std::ptr::NonNull;

let arr: [char; 3] = ['a', 'b', 'c'];
let ptr = NonNull::new((&arr[2] as *const char).cast_mut()).unwrap();
let ptr = SendSyncPtr::new(ptr);

let ref_v = unsafe { ptr.sub(1).as_ref() };
assert_eq!(ref_v, &'b');

let ref_v = unsafe { ptr.sub(2).as_ref() };
assert_eq!(ref_v, &'a');

pub const fn cast<U>(self) -> SendSyncPtr<U>

Casts the pointer to another type.

Examples

use my_ecs::ds::SendSyncPtr;
use std::ptr::NonNull;

let mut v = 0x1234_5678;
let ptr = NonNull::new(&mut v as *mut i32).unwrap();
let ptr = SendSyncPtr::new(ptr);

let ptr = ptr.cast::<[u8; 4]>();
let ref_v = unsafe { ptr.as_ref() };
assert_eq!(*ref_v, i32::to_ne_bytes(v));

Trait Implementations

impl<T: ?Sized> Clone for SendSyncPtr<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + ?Sized> Debug for SendSyncPtr<T>

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

Formats the value using the given formatter.

impl<T: ?Sized> Hash for SendSyncPtr<T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: ?Sized> Ord for SendSyncPtr<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: ?Sized> PartialEq for SendSyncPtr<T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: ?Sized> PartialOrd for SendSyncPtr<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: ?Sized> Copy for SendSyncPtr<T>

impl<T: ?Sized> Eq for SendSyncPtr<T>

impl<T: ?Sized> Send for SendSyncPtr<T>

impl<T: ?Sized> Sync for SendSyncPtr<T>