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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

use std::cell::RefCell;
use std::sync::Arc;

use nando_support::{activation_intent::NandoResult, epic_control::ECB, log_entry};
use object_tracker::ObjectTracker;
use ownership_tracker::OwnershipTracker;

pub struct TxnContext {
    namespace: String,
    log_entry: Arc<RefCell<log_entry::TransactionLogEntry>>,
    ecb: Option<Arc<RefCell<ECB>>>,
    object_tracker: Arc<ObjectTracker>,
    ownership_tracker: Arc<&'static OwnershipTracker>,
}

impl TxnContext {
    pub fn new(
        log_entry: Arc<RefCell<log_entry::TransactionLogEntry>>,
        object_tracker: Arc<ObjectTracker>,
        ownership_tracker: &'static OwnershipTracker,
        _num_args: usize,
    ) -> Self {
        Self {
            namespace: String::default(),
            log_entry: Arc::clone(&log_entry),
            ecb: None,
            object_tracker: Arc::clone(&object_tracker),
            ownership_tracker: Arc::new(ownership_tracker),
        }
    }

    pub fn get_ecb(&self) -> Option<Arc<RefCell<ECB>>> {
        match self.ecb {
            None => None,
            Some(ref e) => Some(Arc::clone(e)),
        }
    }

    pub fn set_ecb(&mut self, ecb: Option<Arc<RefCell<ECB>>>) {
        self.ecb = ecb;
    }

    pub fn set_namespace(&mut self, namespace: &str) {
        self.namespace = namespace.to_string();
    }

    pub fn get_namespace(&self) -> &str {
        &self.namespace
    }

    pub fn get_log_entry(&self) -> Arc<RefCell<log_entry::TransactionLogEntry>> {
        Arc::clone(&self.log_entry)
    }

    pub fn get_object_tracker(&self) -> Arc<ObjectTracker> {
        Arc::clone(&self.object_tracker)
    }

    pub fn get_ownership_tracker(&self) -> &'static OwnershipTracker {
        &self.ownership_tracker
    }

    pub fn is_part_of_epic(&self) -> bool {
        self.ecb.is_some()
    }

    pub fn set_ecb_result(&self, result: NandoResult) {
        let ecb = self.ecb.as_ref().unwrap();
        ecb.borrow_mut().set_result(result);
    }
}