1 
/// A light scoped wrapper over a raw *mut pointer.
2 
///
3 
/// Implements destruction of the pointer when it goes out of scope, but provides no other
4 
/// guarantees.
5 
pub struct Scoped<T> {
6 
    pub ptr: *mut T,
7 
    destructor: fn(*mut T),
8 
}
9 

            

        

            

                10
            

            

                
            

            

                
// Could use

            

        

            

                11
            

            

                
            

            

                
// https://doc.rust-lang.org/std/alloc/trait.Allocator.html with box (in nightly only)

            

        

            

                12
            

            

                
            

            

                
// or

            

        

            

                13
            

            

                
            

            

                
// https://docs.rs/scopeguard/latest/scopeguard/

            

        

            

                14
            

            

                
            

            

                
// instead

            

        

            

                15
            

            

                
            

            

                
impl<T> Scoped<T> {

            

        

            

                16
            

            

                105
            

            

                
    pub unsafe fn new(ptr: *mut T, destructor: fn(*mut T)) -> Scoped<T> {

            

        

            

                17
            

            

                105
            

            

                
        Scoped { ptr, destructor }

            

        

            

                18
            

            

                105
            

            

                
    }

            

        

            

                19
            

            

                
            

            

                
}

            

        

            

                20
            

            

                
            

            

                

            

        

            

                21
            

            

                
            

            

                
// https://doc.rust-lang.org/nomicon/destructors.html

            

        

            

                22
            

            

                
            

            

                
impl<T> Drop for Scoped<T> {

            

        

            

                23
            

            

                105
            

            

                
    fn drop(&mut self) {

            

        

            

                24
            

            

                105
            

            

                
        (self.destructor)(self.ptr);

            

        

            

                25
            

            

                105
            

            

                
    }

            

        

            

                26
            

            

                
            

            

                
}