mpstthree 0.1.17

A library implementing Multiparty Session Types for 2 or more participants
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
57
58
59
60

use super::super::{GlobalElements, Tree};
use std::io::Write;

/// Generate all endpoints in the global_elements.output file using all elements gathered from
/// the nuscr protocol.
pub(crate) fn generate_endpoints(
    global_elements: &mut GlobalElements,
    main_tree: &Tree,
) -> Result<(), Box<dyn std::error::Error>> {
    match global_elements.output.as_mut() {
        Some(generated_file) => {
            writeln!(
                generated_file,
                "// Endpoints in depth {}",
                main_tree
                    .index
                    .iter()
                    .map(|&id| id.to_string())
                    .collect::<Vec<String>>()
                    .join(".")
            )?;
            // Generate the endpoints
            for role in global_elements.roles.iter() {
                writeln!(generated_file, "// Endpoint for role {}", role)?;

                for endpoint in main_tree.endpoints.get(role).unwrap() {
                    write!(generated_file, "type {} = MeshedChannels<", endpoint)?;
                    for other_role in global_elements.roles.iter() {
                        if other_role != role {
                            write!(
                                generated_file,
                                "{}, ",
                                main_tree
                                    .first_message
                                    .get(role)
                                    .unwrap()
                                    .get(other_role)
                                    .unwrap()
                            )?;
                        }
                    }
                    writeln!(
                        generated_file,
                        "{}, Name{}>;",
                        main_tree.first_stack.get(role).unwrap(),
                        role
                    )?;
                }
                writeln!(generated_file)?;
            }

            for sub_tree in &main_tree.sub_trees {
                generate_endpoints(global_elements, sub_tree)?;
            }

            Ok(())
        }
        None => Err("Generated file was not initialised.".into()),
    }
}