juiz_core 0.0.4

Core library for JUIZ application. This package is not required if you want to build juiz functional module.
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98



use std::sync::{Mutex, Arc, atomic::AtomicI64};



use crate::prelude::*;


pub enum ExecutionContextState {
    STARTED = 1,
    STOPPED = 2,
    UNKNOWN = 99,
}

impl ExecutionContextState {

    pub fn to_i64(&self) -> i64 {
        match *self {
            ExecutionContextState::STARTED => {1},
            ExecutionContextState::STOPPED => {2},
            ExecutionContextState::UNKNOWN => {99}
        }
    }

    pub fn from(i: i64) -> Self {
        match i {
            1 => ExecutionContextState::STARTED,
            2 => ExecutionContextState::STOPPED,
            _ => ExecutionContextState::UNKNOWN,
        }
    }
}

impl ToString for ExecutionContextState {
    fn to_string(&self) -> String {
        match *self {
            ExecutionContextState::STARTED => {"STARTED".to_owned()},
            ExecutionContextState::STOPPED => {"STOPPED".to_owned()},
            ExecutionContextState::UNKNOWN => {"UNKNOWN".to_owned()}
        }
    }
}

pub struct ExecutionContextCore {
    target_processes: Vec<ProcessPtr>,
    pub state: AtomicI64,
}

impl ExecutionContextCore {

    pub fn new() -> Arc<Mutex<ExecutionContextCore>> {
        Arc::new(Mutex::new(ExecutionContextCore{
            target_processes: Vec::new(),
            state: AtomicI64::new(ExecutionContextState::STOPPED.to_i64()),
        }))
    }

    pub fn bind(&mut self, target_process: ProcessPtr) -> JuizResult<()> {
        self.target_processes.push(target_process);
        Ok(())
    }

    pub fn unbind(&mut self, target_process_id: Identifier) -> JuizResult<()> {
        let mut remove_index: Option<usize> = None;
        for (i, p) in self.target_processes.iter().enumerate() {
            if target_process_id == *p.identifier() {
                remove_index = Some(i);
            }
        }
        if let Some(index) = remove_index {
            let _pp = self.target_processes.remove(index);
        }
        Ok(())
    }


    pub fn get_state(&self) -> ExecutionContextState {
        ExecutionContextState::from(self.state.load(std::sync::atomic::Ordering::SeqCst))
    }

    ///
    /// 実行コンテキストの周期処理のコア部分。この中でターゲットプロセスすべてのexecuteを呼ぶ。
    pub fn svc(&self) -> JuizResult<Value> {
        for tp in self.target_processes.iter() {
            let _ = tp.lock()?.execute()?;
        }
        Ok(jvalue!({}))
    }

    pub fn profile(&self) -> JuizResult<Value> {
        Ok(jvalue!({
            "targets": self.target_processes.iter().map(|tp| { Ok(tp.identifier().clone()) }).collect::<JuizResult<Vec<String>>>()?,
            "state": ExecutionContextState::from(self.state.load(std::sync::atomic::Ordering::SeqCst)).to_string()
        }))
    }
}