1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
pub mod allocation; pub mod result; pub use holochain_serialized_bytes::prelude::*; pub use result::*; use crate::allocation::Allocation; use crate::allocation::ALLOCATION_ITEMS; pub type Ptr = u64; pub type Len = u64; /// an unwrapped AllocationPtr that is on the other side of the host/wasm boundary pub type RemotePtr = Ptr; /// AllocationPtr wraps a ptr that is used to pass the location of an Allocation /// between the host and guest (in either direction). /// The AllocationPtr intentionally does not implement Clone /// The From<Allocation> and Into<Allocation> round trip handles manually allocating /// and deallocating an internal vector that is shared across host/guest /// If the AllocationPtr was to be cloned the shared vector could be allocated and /// deallocated in an undefined way pub struct AllocationPtr(Ptr); impl AllocationPtr { /// normally we don't want to expose the inner Ptr because cloning or reusing it /// can lead to bad allocation and deallocation /// in the case that we pass the inner Ptr over to the host we do need to access it /// this function is just like From<AllocationPtr> for Ptr but renamed to make it /// clear that it has only one valid use-case pub fn as_remote_ptr(&self) -> RemotePtr { self.0 } pub fn from_remote_ptr(host_ptr: RemotePtr) -> Self { Self(host_ptr) } /// get the Allocation for this Allocation _without_ deallocating the Allocation in the process /// usually you do not want to do this because From<AllocationPtr> for Allocation consumes the /// original AllocationPtr and returns a new identical Allocation pub fn peek_allocation(&self) -> Allocation { let allocation_slice: &[u64] = unsafe { std::slice::from_raw_parts(self.0 as _, ALLOCATION_ITEMS) }; [allocation_slice[0], allocation_slice[1]] } }