Wie kann ich einen Verweis auf etwas in einer RefCell zurückgeben, ohne die Kapselung zu unterbrechen?

Question

Ich habe eine Struktur, die innere Veränderlichkeit hat.

use std::cell::RefCell; 

struct MutableInterior { 
    hideMe: i32, 
    vec: Vec<i32>, 
} 
struct Foo { 
    //although not used in this particular snippet, 
    //the motivating problem uses interior mutability 
    //via RefCell. 
    interior: RefCell<MutableInterior>, 
} 

impl Foo { 
    pub fn getItems(&self) -> &Vec<i32> { 
     &self.interior.borrow().vec 
    } 
} 

fn main() { 
    let f = Foo { 
     interior: RefCell::new(MutableInterior { 
      vec: Vec::new(), 
      hideMe: 2, 
     }), 
    }; 
    let borrowed_f = &f; 
    let items = borrowed_f.getItems(); 
} 

Erzeugt den Fehler:

error: borrowed value does not live long enough 
    --> src/main.rs:16:10 
    | 
16 |   &self.interior.borrow().vec 
    |   ^^^^^^^^^^^^^^^^^^^^^^ does not live long enough 
17 |  } 
    |  - temporary value only lives until here 
    | 
note: borrowed value must be valid for the anonymous lifetime #1 defined on the body at 15:40... 
    --> src/main.rs:15:41 
    | 
15 |  pub fn getItems(&self) -> &Vec<i32> { 
    | _________________________________________^ starting here... 
16 | |   &self.interior.borrow().vec 
17 | |  } 
    | |_____^ ...ending here 

Das Problem ist, dass ich nicht vec entlehnt gibt eine Funktion auf Foo, die eine haben kann, weil das geliehene vec nur gültig für die gesamte Lebensdauer des Ref ist , aber die Ref geht sofort aus dem Anwendungsbereich.

ich denke, die Refbecause dableiben müssen:

RefCell uses Rust's lifetimes to implement 'dynamic borrowing', a process whereby one can claim temporary, exclusive, mutable access to the inner value. Borrows for RefCells are tracked 'at runtime', unlike Rust's native reference types which are entirely tracked statically, at compile time. Because RefCell borrows are dynamic it is possible to attempt to borrow a value that is already mutably borrowed; when this happens it results in task panic.

Jetzt habe ich stattdessen eine Funktion wie diese schreiben könnte, die den gesamten Innenraum zurückgibt:

pub fn getMutableInterior(&self) -> std::cell::Ref<MutableInterior>; 

jedoch möglicherweise diese aussetzt Felder (MutableInterior.hideMe in Dieses Beispiel), die wirklich private Implementierungsdetails zu Foo sind.

Idealerweise möchte ich nur die vec selbst, möglicherweise mit einer Wache, um das dynamische Ausleihen Verhalten zu implementieren. Dann müssen sich Anrufer nicht über hideMe informieren.

Answer 1

Sie können eine schaffen neue Struktur ähnlich der Ref<'a,T> Wache zurück von RefCell::borrow(), um es außerhalb des Gültigkeitsbereichs gehen mit dieser Ref und vermeiden wickeln, wie folgt aus:

use std::cell::Ref; 

struct FooGuard<'a> { 
    guard: Ref<'a, MutableInterior> 
} 

dann können Sie Umsetzung der Deref Merkmal dafür, so dass es wie verwendet werden kann, wenn es ein war:

use std::ops::Deref; 

impl<'b> Deref for FooGuard<'b> { 
    type Target = Vec<i32>; 

    fn deref(&self) -> &Vec<i32> { 
     &self.guard.vec 
    } 
} 

danach, sim Lage aktualisieren Sie Ihre getItems() Methode eine FooGuard Instanz zurückzugeben:

impl Foo { 
    pub fn getItems(&self) -> FooGuard { 
     FooGuard { guard: self.interior.borrow() } 
    } 
} 

und Deref macht die Magie:

fn main() { 
    let f = Foo { 
     interior: RefCell::new(MutableInterior{ vec: Vec::new(), hideMe: 2 }) 
    }; 
    let borrowed_f = &f; 
    let items = borrowed_f.getItems(); 
    let v: &Vec<i32> = &items; 
}