Current state

Author: filmor

rustler/src/sys/types.rs

@@ -19,6 +19,7 @@ pub type ERL_NIF_TERM = ERL_NIF_UINT;
 //#[derive(Debug, Copy, Clone)]
 //#[repr(C)]
 //pub struct ERL_NIF_TERM(ERL_NIF_UINT);  // Don't do this, 32 bit calling convention is different for structs and ints.
+// Would work with repr(transparent)!
 
 /// See [ErlNifEnv](http://www.erlang.org/doc/man/erl_nif.html#ErlNifEnv) in the Erlang docs.
 #[derive(Debug)]

rustler/src/types/atom.rs

@@ -84,7 +84,34 @@ impl Atom {
     }
 }
 
-impl<'a> Wrapper<'a> for Atom {
+// Wrapper
+//
+// Should be an ErlNifTerm along with its origin environment.
+//
+// For Atoms and LocalPids, the term is not associated with any environment, so we can
+// just store the term itself. For other types, we need to store the environment
+// as well, so we can create a new Term from it later.
+//
+// The objects are not safe to use outside of the function call, so they are not `clone`, or `copy`
+// or even movable.
+//
+// Maybe use references everywhere instead of objects?
+//
+// A function call would then look like this:
+//
+// ```rust
+// fn foo<'a>(env: Env<'a>, atom: &'a Atom, map: &'a Map) -> NifResult<()> {
+//    let atom = Atom::from_term(term)?;
+//    let term = atom.to_term(env);
+// }
+// ```
+//
+// Instead of `PhantomData` we could use `std::marker::Unsize` to make the type
+// unsized. This would allow us to use the type as a reference, but it would
+// also make it impossible to use as a value. This would be a problem for
+// `Term` and `Env`, which are both values.
+
+impl Wrapper for Atom {
     const WRAPPED_TYPE: crate::TermType = crate::TermType::Atom;
 
     fn unwrap(&self) -> Term<'a> {

rustler/src/wrapped_types/wrapper.rs

@@ -9,32 +9,27 @@ impl From<WrapperError> for crate::Error {
     }
 }
 
-pub trait Wrapper<'a>: Sized {
+pub trait Wrapper: Sized {
     const WRAPPED_TYPE: TermType;
 
-    unsafe fn wrap_ptr_unchecked(env: Env<'a>, ptr: ERL_NIF_TERM) -> Self {
+    unsafe fn wrap_ptr_unchecked<'a>(env: Env<'a>, ptr: ERL_NIF_TERM) -> Self {
         Self::wrap_unchecked(Term::new(env, ptr))
     }
 
-    fn wrap(term: Term<'a>) -> Result<Self, WrapperError> {
+    fn wrap<'a>(term: Term<'a>) -> Result<Self, WrapperError> {
         if term.get_type() == Self::WRAPPED_TYPE {
             unsafe { Ok(Self::wrap_unchecked(term)) }
         } else {
             Err(WrapperError)
         }
     }
 
-    fn unwrap(&self) -> Term<'a>;
-    unsafe fn wrap_unchecked(term: Term<'a>) -> Self;
-}
+    fn unwrap<'a>(&self, env: Env<'a>) -> Term<'a>;
 
-impl<'a, T> From<T> for Term<'a>
-where
-    T: Wrapper<'a>,
-{
-    fn from(term: T) -> Self {
-        term.unwrap()
+    unsafe fn unwrap_ptr_unchecked<'a>(&self, env: Env<'a>) -> ERL_NIF_TERM {
+        self.unwrap(env).as_c_arg()
     }
+    unsafe fn wrap_unchecked<'a>(term: Term<'a>) -> Self;
 }
 
 macro_rules! wrapper {
@@ -54,20 +49,20 @@ macro_rules! wrapper {
             /// If the term is already is in the provided env, it will be directly returned.
             /// Otherwise the term will be copied over.
             pub fn in_env<'b>(&self, env: Env<'b>) -> $name<'b> {
-                let term = self.unwrap().in_env(env);
+                let term = self.unwrap(env);
                 unsafe { $name::wrap_unchecked(term) }
             }
         }
 
-        impl<'a> Wrapper<'a> for $name<'a> {
+        impl<'a> Wrapper for $name<'a> {
             const WRAPPED_TYPE: $crate::TermType = $term_type;
 
-            unsafe fn wrap_unchecked(term: Term<'a>) -> Self {
+            unsafe fn wrap_unchecked<'b>(term: Term<'b>) -> Self {
                 $name(term)
             }
 
-            fn unwrap(&self) -> Term<'a> {
-                self.0
+            fn unwrap<'b>(&self, env: Env<'b>) -> Term<'b> {
+                self.0.in_env(env)
             }
         }
 
@@ -97,7 +92,77 @@ macro_rules! wrapper {
 
         impl<'a> $crate::Encoder for $name<'a> {
             fn encode<'b>(&self, env: $crate::Env<'b>) -> Term<'b> {
-                self.0.encode(env)
+                self.unwrap().encode(env)
+            }
+        }
+
+        // impl<'a> std::hash::Hash for $name<'a> {
+        //     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        //         self.0.hash(state);
+        //     }
+        // }
+        //
+        impl<'a> std::fmt::Debug for $name<'a> {
+            fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+                self.0.fmt(f)
+            }
+        }
+    };
+}
+
+macro_rules! wrapper_impls {
+    ($name: ident, $term_type:path) => {
+        impl<'a> $name<'a> {
+            /// Returns a representation of self in the given Env.
+            ///
+            /// If the term is already is in the provided env, it will be directly returned.
+            /// Otherwise the term will be copied over.
+            pub fn in_env<'b>(&self, env: Env<'b>) -> $name<'b> {
+                use $crate::wrapped_types::Wrapper;
+                let term = self.unwrap().in_env(env);
+                unsafe { $name::wrap_unchecked(term) }
+            }
+        }
+
+        impl<'a> std::ops::Deref for $name<'a> {
+            type Target = Term<'a>;
+
+            fn deref(&self) -> &Self::Target {
+                &self.unwrap()
+            }
+        }
+
+        impl<'a> TryFrom<Term<'a>> for $name<'a> {
+            type Error = $crate::Error;
+
+            fn try_from(term: Term<'a>) -> Result<Self, Self::Error> {
+                use $crate::wrapped_types::Wrapper;
+                Self::wrap(term).or(Err($crate::Error::BadArg))
+            }
+        }
+
+        impl<'a> $crate::Decoder<'a> for $name<'a> {
+            fn decode(term: Term<'a>) -> $crate::NifResult<Self> {
+                use $crate::wrapped_types::Wrapper;
+                Self::wrap(term).or(Err($crate::Error::BadArg))
+            }
+        }
+
+        impl<'a> $crate::Encoder for $name<'a> {
+            fn encode<'b>(&self, env: $crate::Env<'b>) -> Term<'b> {
+                self.unwrap().encode(env)
+            }
+        }
+
+        impl<'a> std::hash::Hash for $name<'a> {
+            fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+                self.unwrap().hash(state);
+            }
+        }
+
+        impl<'a> std::fmt::Debug for $name<'a> {
+            fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+                self.unwrap().fmt(f)
             }
         }
     };