qusql-mysql 0.1.0

Async mysql connector
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

//! Adds a drop handle wrapper, that calls a function with the value when it is dropped
use std::{
    mem::ManuallyDrop,
    ops::{Deref, DerefMut},
};

/// Container for Content, that calls Drop with content when dropped
pub(crate) struct HandleDrop<Content, Drop: FnOnce(Content)>(ManuallyDrop<(Content, Drop)>);

impl<Content, Drop: FnOnce(Content)> HandleDrop<Content, Drop> {
    /// Create a new instant
    pub(crate) fn new(content: Content, drop: Drop) -> Self {
        Self(ManuallyDrop::new((content, drop)))
    }

    /// Return content without calling drop
    pub(crate) fn release(mut self) -> Content {
        // Safety: This is safe because we call std::mem::forget immediately after, and
        // drop is the only other taker
        let (content, _) = unsafe { ManuallyDrop::take(&mut self.0) };
        std::mem::forget(self);
        content
    }
}

impl<Content, Drop: FnOnce(Content)> Deref for HandleDrop<Content, Drop> {
    type Target = Content;

    fn deref(&self) -> &Self::Target {
        &self.0.0
    }
}

impl<Content, Drop: FnOnce(Content)> DerefMut for HandleDrop<Content, Drop> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0.0
    }
}

impl<Content, Drop: FnOnce(Content)> std::ops::Drop for HandleDrop<Content, Drop> {
    fn drop(&mut self) {
        // Safety: This is safe because all other takes call std::mem::forget
        let (content, drop) = unsafe { ManuallyDrop::take(&mut self.0) };
        drop(content)
    }
}