pub struct Env<'a> { /* private fields */ }
Expand description
On each NIF call, a Env is passed in. The Env is used for most operations that involve communicating with the BEAM, like decoding and encoding terms.
There is no way to allocate a Env at the moment, but this may be possible in the future.
Implementations§
source§impl<'a> Env<'a>
impl<'a> Env<'a>
sourcepub fn pid(self) -> LocalPid
pub fn pid(self) -> LocalPid
Return the calling process’s pid.
§Panics
Panics if this environment is process-independent. (The only way to get such an
environment is to use OwnedEnv
. The Env
that Rustler passes to NIFs when they’re
called is always associated with the calling Erlang process.)
sourcepub fn is_process_alive(self, pid: LocalPid) -> bool
pub fn is_process_alive(self, pid: LocalPid) -> bool
Checks whether the given process is alive
source§impl<'a> Env<'a>
impl<'a> Env<'a>
sourcepub unsafe fn new<T>(_lifetime_marker: &'a T, env: NIF_ENV) -> Env<'a>
pub unsafe fn new<T>(_lifetime_marker: &'a T, env: NIF_ENV) -> Env<'a>
Create a new Env. For the _lifetime_marker
argument, pass a
reference to any local variable that has its own lifetime, different
from all other Env
values. The purpose of the argument is to make
it easier to know for sure that the Env
you’re creating has a
unique lifetime (i.e. that you’re following the most important safety
rule of Rustler).
§Unsafe
Don’t create multiple Env
s with the same lifetime.
pub fn as_c_arg(self) -> NIF_ENV
sourcepub fn error_tuple(self, reason: impl Encoder) -> Term<'a>
pub fn error_tuple(self, reason: impl Encoder) -> Term<'a>
Convenience method for building a tuple {error, Reason}
.
sourcepub fn send(
self,
pid: &LocalPid,
message: impl Encoder
) -> Result<(), SendError>
pub fn send( self, pid: &LocalPid, message: impl Encoder ) -> Result<(), SendError>
Send a message to a process.
The Erlang VM imposes some odd restrictions on sending messages. You can send messages in either of these situations:
-
The current thread is managed by the Erlang VM, and
self
is the environment of the calling process (that is, the environment that Rustler passed in to your NIF); or -
The current thread is not managed by the Erlang VM.
The result indicates whether the send was successful, see also enif_send.
§Panics
Panics if the above rules are broken (by trying to send a message from
an OwnedEnv
on a thread that’s managed by the Erlang VM).
sourcepub fn whereis_pid(self, name_or_pid: impl Encoder) -> Option<LocalPid>
pub fn whereis_pid(self, name_or_pid: impl Encoder) -> Option<LocalPid>
Attempts to find the PID of a process registered by name_or_pid
Safe wrapper around enif_whereis_pid
.
§Returns
Some(pid)
ifname_or_pid
is already a PID.Some(pid)
ifname_or_pid
is an atom and an alive process is currently registered under the given name.None
ifname_or_pid
is an atom but there is no alive process registered under this name.None
ifname_or_pid
is not a PID or atom.
sourcepub fn binary_to_term(self, data: &[u8]) -> Option<(Term<'a>, usize)>
pub fn binary_to_term(self, data: &[u8]) -> Option<(Term<'a>, usize)>
Decodes binary data to a term.
Follows the erlang External Term Format.
Trait Implementations§
source§impl<'a, 'b> PartialEq<Env<'b>> for Env<'a>
impl<'a, 'b> PartialEq<Env<'b>> for Env<'a>
Two environments are equal if they’re the same NIF_ENV
value.
A Env<'a>
is equal to a Env<'b>
if and only if 'a
and 'b
are the same lifetime.