rquickjs 0.0.1

High level bindings to the quickjs javascript engine
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

use crate::context::Ctx;
use derivative::Derivative;
use rquickjs_sys as qjs;
use std::{marker::PhantomData, mem};

/// A owned reference to a javascript object
#[derive(Derivative)]
#[derivative(PartialEq, Debug)]
pub struct JsRef<'js, Ty: JsRefType> {
    #[derivative(PartialEq = "ignore")]
    pub(crate) ctx: Ctx<'js>,
    pub(crate) ptr: *mut libc::c_void,
    marker: PhantomData<Ty>,
}

impl<'js, Ty: JsRefType> JsRef<'js, Ty> {
    pub unsafe fn from_js_value(ctx: Ctx<'js>, val: qjs::JSValue) -> Self {
        debug_assert_eq!(val.tag, Ty::TAG);
        JsRef {
            ctx,
            ptr: val.u.ptr,
            marker: PhantomData,
        }
    }

    pub fn to_js_value(&self) -> qjs::JSValue {
        qjs::JSValue {
            u: qjs::JSValueUnion { ptr: self.ptr },
            tag: Ty::TAG,
        }
    }
}

impl<'js, Ty: JsRefType> Clone for JsRef<'js, Ty> {
    fn clone(&self) -> Self {
        unsafe {
            let p: *mut qjs::JSRefCountHeader = mem::transmute(self.ptr);
            (*p).ref_count += 1;
        }
        JsRef {
            ctx: self.ctx,
            ptr: self.ptr,
            marker: PhantomData,
        }
    }
}

impl<Ty: JsRefType> Drop for JsRef<'_, Ty> {
    fn drop(&mut self) {
        unsafe {
            let p: *mut qjs::JSRefCountHeader = mem::transmute(self.ptr);
            (*p).ref_count -= 1;
            if (*p).ref_count <= 0 {
                let v = self.to_js_value();
                qjs::__JS_FreeValue(self.ctx.ctx, v);
            }
        }
    }
}

pub trait JsRefType {
    const TAG: i64;
}

pub struct JsStringType;

impl JsRefType for JsStringType {
    const TAG: i64 = qjs::JS_TAG_STRING as i64;
}

pub struct JsObjectType;

impl JsRefType for JsObjectType {
    const TAG: i64 = qjs::JS_TAG_OBJECT as i64;
}

pub struct JsModuleType;

impl JsRefType for JsModuleType {
    const TAG: i64 = qjs::JS_TAG_MODULE as i64;
}

pub type JsStringRef<'js> = JsRef<'js, JsStringType>;
pub type JsObjectRef<'js> = JsRef<'js, JsObjectType>;
pub type JsModuleRef<'js> = JsRef<'js, JsModuleType>;