Ограничение объектов время жизни в Rust

Question

Я обернув библиотеку C, и она имеет стандартный вид контекста объекта:

library_context* context = library_create_context(); 

И затем, используя которые вы можете создать несколько объектов:

library_object* object = library_create_object(context); 

И уничтожить их обоих:

library_destroy_object(object); 
library_destroy_context(context); 

Так я обернут это в Rust структур:

struct Context { 
    raw_context: *mut library_context, 
} 

impl Context { 
    fn new() -> Context { 
     Context { 
      raw_context: unsafe { library_create_context() }, 
     } 
    } 

    fn create_object(&mut self) -> Object { 
     Object { 
      raw_object: unsafe { library_create_object(self.raw_context) }, 
     } 
    } 
} 

impl Drop for Context { 
    fn drop(&mut self) { 
     unsafe { 
      library_context_destroy(self.raw_context); 
     } 
    } 
} 

struct Object { 
    raw_object: *mut library_object, 
} 

impl Drop for Object { 
    fn drop(&mut self) { 
     unsafe { 
      library_object_destroy(self.raw_object); 
     } 
    } 
} 

Так что теперь я могу это сделать, и это похоже на работу:

fn main() { 
    let mut ctx = Context::new(); 
    let ob = ctx.create_object(); 
} 

Однако, я также могу это сделать:

fn main() { 
    let mut ctx = Context::new(); 
    let ob = ctx.create_object(); 
    drop(ctx); 

    do_something_with(ob); 
} 

Т.е. контекст библиотеки уничтожается до того, как создаются объекты.

Могу ли я каким-либо образом использовать систему жизни Rust для предотвращения компиляции вышеуказанного кода?

Answer 1

Да, просто использовать нормальные времена жизни:

#[derive(Debug)] 
struct Context(u8); 

impl Context { 
    fn new() -> Context { 
     Context(0) 
    } 

    fn create_object(&mut self) -> Object { 
     Object { 
      context: self, 
      raw_object: 1, 
     } 
    } 
} 

#[derive(Debug)] 
struct Object<'a> { 
    context: &'a Context, 
    raw_object: u8, 
} 

fn main() { 
    let mut ctx = Context::new(); 
    let ob = ctx.create_object(); 
    drop(ctx); 

    println!("{:?}", ob); 
} 

Это потерпит неудачу с

error[E0505]: cannot move out of `ctx` because it is borrowed 
    --> src/main.rs:26:10 
    | 
25 |  let ob = ctx.create_object(); 
    |    --- borrow of `ctx` occurs here 
26 |  drop(ctx); 
    |   ^^^ move out of `ctx` occurs here 

Иногда люди любят использовать PhantomData, но я не уверен, что я вижу преимущество здесь:

fn create_object(&mut self) -> Object { 
    Object { 
     marker: PhantomData, 
     raw_object: 1, 
    } 
} 

#[derive(Debug)] 
struct Object<'a> { 
    marker: PhantomData<&'a()>, 
    raw_object: u8, 
}