hebi 0.4.0

A dynamic scripting language
Documentation 
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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

macro_rules! decl_ref {
  (struct $name:ident($inner:ty)) => {
    #[derive(Clone)]
    #[repr(C)]
    pub struct $name<'cx> {
      inner: $inner,
      lifetime: ::core::marker::PhantomData<&'cx ()>,
    }

    impl<'cx> ::std::fmt::Debug for $name<'cx> {
      fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::std::fmt::Debug::fmt(&self.inner, f)
      }
    }

    impl<'cx> ::std::fmt::Display for $name<'cx> {
      fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        ::std::fmt::Display::fmt(&self.inner, f)
      }
    }

    unsafe impl<'cx> $crate::public::IsSimpleRef for $name<'cx> {}

    impl $crate::public::Bind for $inner {
      type Ref<'cx> = $name<'cx>;

      unsafe fn bind_raw<'cx>(self) -> Self::Ref<'cx> {
        ::std::mem::transmute::<Self, Self::Ref<'cx>>(self)
      }
    }

    impl<'cx> $crate::public::Unbind for $name<'cx> {
      type Owned = $inner;

      fn unbind(self) -> Self::Owned {
        unsafe { ::std::mem::transmute::<Self, Self::Owned>(self) }
      }
    }
  };
}

macro_rules! impl_object_ref {
  ($T:ident, $Owned:ty) => {
    impl<'cx> $crate::public::object::ObjectRef<'cx> for $T<'cx> {
      fn as_any(&self, _: $crate::public::Global<'cx>) -> $crate::public::object::Any<'cx> {
        let ptr = self.inner.clone().into_any();
        unsafe { ptr.bind_raw::<'cx>() }
      }

      fn from_any(
        v: $crate::public::object::Any<'cx>,
        _: $crate::public::Global<'cx>,
      ) -> Option<Self> {
        v.inner
          .cast::<$Owned>()
          .ok()
          .map(|v| unsafe { v.bind_raw::<'cx>() })
      }
    }

    impl<'cx> $crate::public::object::private::Sealed for $T<'cx> {}
  };
}