vantage-vista 2.5.0

Universal, schema-bearing data handle for the Vantage data framework
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

//! [`Transaction::wrap`] and [`Transaction::resolver`]: how a Vista joins a
//! transaction.

use std::sync::Arc;

use vantage_core::Result;

use super::{Transaction, cant_take_part, shell::TxShell};
use crate::{resolver::VistaResolver, vista::Vista};

impl Transaction {
    /// `vista`, reading and writing through this transaction. Its shell is
    /// rebound now; a shell that can't rebind errors at the wrapped Vista's
    /// first use, not here. Every Vista the result returns (`get_ref`
    /// targets) is wrapped too.
    pub fn wrap(&self, vista: &Vista) -> Vista {
        let rebound = self
            .check_open()
            .and_then(|()| vista.shell().rebind(self))
            .map_err(|err| {
                if err.is_unsupported() {
                    cant_take_part(vista.name())
                } else {
                    err
                }
            });
        let name = vista.name().to_string();
        vista
            .clone()
            .map_shell(|original| TxShell::new(original, rebound, name, self.clone()))
    }

    /// `base`, with every Vista it resolves, or adopts, wrapped in this
    /// transaction.
    pub fn resolver(&self, base: Arc<dyn VistaResolver>) -> Arc<dyn VistaResolver> {
        Arc::new(TxResolver {
            tx: self.clone(),
            base,
        })
    }
}

struct TxResolver {
    tx: Transaction,
    base: Arc<dyn VistaResolver>,
}

impl VistaResolver for TxResolver {
    fn vista(&self, name: &str) -> Result<Vista> {
        Ok(self.tx.wrap(&self.base.vista(name)?))
    }

    fn adopt(&self, vista: Vista) -> Vista {
        self.tx.wrap(&self.base.adopt(vista))
    }
}