libuv 2.12.0

A safe rust wrapper for libuv
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use crate::{FromInner, Inner, IntoInner};
use uv::{uv_queue_work, uv_work_t};

callbacks! {
    pub WorkCB(req: WorkReq);
    pub AfterWorkCB(req: WorkReq, status: crate::Result<u32>);
}

/// Additional data stored on the request
pub(crate) struct WorkDataFields<'a> {
    work_cb: WorkCB<'a>,
    after_work_cb: AfterWorkCB<'a>,
}

/// Callback for uv_queue_work
extern "C" fn uv_work_cb(req: *mut uv_work_t) {
    let dataptr = crate::Req::get_data(uv_handle!(req));
    if !dataptr.is_null() {
        unsafe {
            if let super::WorkData(d) = &mut *dataptr {
                d.work_cb.call(req.into_inner());
            }
        }
    }
}

extern "C" fn uv_after_work_cb(req: *mut uv_work_t, status: i32) {
    let dataptr = crate::Req::get_data(uv_handle!(req));
    if !dataptr.is_null() {
        unsafe {
            if let super::WorkData(d) = &mut *dataptr {
                let status = if status < 0 {
                    Err(crate::Error::from_inner(status as uv::uv_errno_t))
                } else {
                    Ok(status as _)
                };
                d.after_work_cb.call(req.into_inner(), status);
            }
        }
    }

    // free memory
    let mut req = WorkReq::from_inner(req);
    req.destroy();
}

/// Work request type.
#[derive(Clone, Copy)]
pub struct WorkReq {
    req: *mut uv_work_t,
}

impl WorkReq {
    /// Create a new work request
    pub fn new<CB: Into<WorkCB<'static>>, ACB: Into<AfterWorkCB<'static>>>(
        work_cb: CB,
        after_work_cb: ACB,
    ) -> crate::Result<WorkReq> {
        let layout = std::alloc::Layout::new::<uv_work_t>();
        let req = unsafe { std::alloc::alloc(layout) as *mut uv_work_t };
        if req.is_null() {
            return Err(crate::Error::ENOMEM);
        }

        let work_cb = work_cb.into();
        let after_work_cb = after_work_cb.into();
        crate::Req::initialize_data(
            uv_handle!(req),
            super::WorkData(WorkDataFields {
                work_cb,
                after_work_cb,
            }),
        );

        Ok(WorkReq { req })
    }

    /// Loop that started this request and where completion will be reported
    pub fn r#loop(&self) -> crate::Loop {
        unsafe { (*self.req).loop_ }.into_inner()
    }

    pub fn destroy(&mut self) {
        crate::Req::free_data(uv_handle!(self.req));

        let layout = std::alloc::Layout::new::<uv_work_t>();
        unsafe { std::alloc::dealloc(self.req as _, layout) };
    }
}

impl FromInner<*mut uv_work_t> for WorkReq {
    fn from_inner(req: *mut uv_work_t) -> WorkReq {
        WorkReq { req }
    }
}

impl Inner<*mut uv_work_t> for WorkReq {
    fn inner(&self) -> *mut uv_work_t {
        self.req
    }
}

impl Inner<*mut uv::uv_req_t> for WorkReq {
    fn inner(&self) -> *mut uv::uv_req_t {
        uv_handle!(self.req)
    }
}

impl From<WorkReq> for crate::Req {
    fn from(work: WorkReq) -> crate::Req {
        crate::Req::from_inner(Inner::<*mut uv::uv_req_t>::inner(&work))
    }
}

impl crate::ToReq for WorkReq {
    fn to_req(&self) -> crate::Req {
        crate::Req::from_inner(Inner::<*mut uv::uv_req_t>::inner(self))
    }
}

impl crate::ReqTrait for WorkReq {}

impl crate::Loop {
    /// Initializes a work request which will run the given work_cb in a thread from the
    /// threadpool. Once work_cb is completed, after_work_cb will be called on the loop thread.
    ///
    /// This request can be cancelled with Req::cancel().
    pub fn queue_work<CB: Into<WorkCB<'static>>, ACB: Into<AfterWorkCB<'static>>>(
        &self,
        work_cb: CB,
        after_work_cb: ACB,
    ) -> crate::Result<WorkReq> {
        let work_cb = work_cb.into();
        let uv_work_cb = use_c_callback!(uv_work_cb, work_cb);
        let mut req = WorkReq::new(work_cb, after_work_cb)?;
        let uv_after_work_cb = Some(uv_after_work_cb as _);
        let result = crate::uvret(unsafe {
            uv_queue_work(self.into_inner(), req.inner(), uv_work_cb, uv_after_work_cb)
        });
        if result.is_err() {
            req.destroy();
        }
        result.map(|_| req)
    }
}