[−][src]Trait shared_memory::SharedMemCast
Trait used to indicate that a type can be cast over the shared memory.
Read WARNING before implementing this manually on your own types.
For now, shared_memory implements the trait on almost all primitive types.
Deriving Automatically
You can avoid checking your structs/enums manually by using #[derive(SharedMemCast)]. This
will automatically check that all fields of your type implement the SharedMemCast trait. That
means that you can safely use your type as long as your program compiles.
use shared_memory::SharedMemCast; #[derive(SharedMemCast)] struct SomeState { num_listenners: u32, message: [u8; 256], }
If you tried to use Vec<i32> or some other type that isn't safe to cast, you would get a
compiler error.
WARNING
Only implement this trait if you understand the implications of mapping Rust types to shared memory. When doing so, you should be mindful of :
- Does my type have any pointers in its internal representation ?
- This is important because pointers in your type need to also point to the shared memory for it to be usable by other processes
- Can my type resize its contents ?
- If so, the type probably cannot be safely used over shared memory because your type might call alloc/realloc/free on shared memory addresses
- Does my type allow for initialisation after instantiation ?
- A [R|W]lock to the shared memory returns a reference to your type. That means that any use of that reference assumes that the type was properly initialized.
An example of a type that shouldn't be cast to the shared memory would be Vec. Vec internaly contains a pointer to a slice containing its data and some other metadata. This means that to cast a Vec to the shared memory, the memory has to already be initialized with valid pointers and metadata. Granted we could initialize those fields manually, the use of the vector might then trigger a free/realloc on our shared memory.