interoptopus_csharp 0.16.0-alpha.20

The C# backend for Interoptopus.
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

use interoptopus::inventory::RustInventory;
use interoptopus_backends::output::Multibuf;
use interoptopus_csharp::RustLibrary;
use interoptopus_csharp::extensions::{PostModelPass, PostOutputPass, RustCodegenExtension};
use interoptopus_csharp::pass::Outcome::Unchanged;
use interoptopus_csharp::pass::{ModelResult, OutputResult};
use std::error::Error;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};

#[derive(Default)]
#[allow(clippy::struct_field_names)]
pub struct MyExtension {
    init_called: Arc<AtomicBool>,
    post_model_called: Arc<AtomicBool>,
    post_output_called: Arc<AtomicBool>,
}

impl RustCodegenExtension for MyExtension {
    fn init(&mut self, _: &mut RustInventory) {
        self.init_called.store(true, Ordering::Relaxed);
    }

    fn post_model_cycle(&mut self, _: &RustInventory, _: PostModelPass) -> ModelResult {
        self.post_model_called.store(true, Ordering::Relaxed);
        Ok(Unchanged)
    }

    fn post_model_all(&mut self, _: &RustInventory, _: PostModelPass) -> Result<(), interoptopus_csharp::Error> {
        Ok(())
    }

    fn post_output(&mut self, _: &mut Multibuf, _: PostOutputPass) -> OutputResult {
        self.post_output_called.store(true, Ordering::Relaxed);
        Ok(())
    }
}

#[test]
fn can_register() -> Result<(), Box<dyn Error>> {
    let inventory = RustInventory::new();
    let init_called = Arc::new(AtomicBool::new(false));
    let post_model_called = Arc::new(AtomicBool::new(false));
    let post_output_called = Arc::new(AtomicBool::new(false));
    let ext = MyExtension { init_called: init_called.clone(), post_model_called: post_model_called.clone(), post_output_called: post_output_called.clone() };

    let _ = RustLibrary::builder(inventory).with_extension(ext).build().process()?;

    assert!(init_called.load(Ordering::Relaxed));
    assert!(post_model_called.load(Ordering::Relaxed));
    assert!(post_output_called.load(Ordering::Relaxed));

    Ok(())
}