switchback-codec-pb 0.0.1-0.dev.4

Binary codec for the switchback IR in the switchback 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
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
99
100
101
102
103
104
105
106
107

//! Contract, group, and companion mapping.

use std::path::PathBuf;

use switchback_traits::{Companion, Group, GroupId, ManualContract, SpecVersion};

use crate::convert::{manual, opt_string, string_opt};
use crate::pb;

use super::{entity, protocol};

pub fn contract_to_proto(contract: &ManualContract) -> switchback_traits::Result<pb::Contract> {
    Ok(pb::Contract {
        family: contract.family.clone(),
        version: contract.version.as_str().to_string(),
        groups: contract
            .groups
            .iter()
            .map(group_to_proto)
            .collect::<switchback_traits::Result<_>>()?,
        companions: contract.companions.iter().map(companion_to_proto).collect(),
        protocols: protocol::protocols_to_proto(&contract.protocols),
        ..Default::default()
    })
}

pub fn contract_from_proto(contract: pb::Contract) -> switchback_traits::Result<ManualContract> {
    Ok(ManualContract {
        family: contract.family,
        version: SpecVersion::from(contract.version),
        groups: contract
            .groups
            .into_iter()
            .map(group_from_proto)
            .collect::<switchback_traits::Result<_>>()?,
        companions: contract
            .companions
            .into_iter()
            .map(companion_from_proto)
            .collect(),
        protocols: protocol::protocols_from_proto(contract.protocols),
    })
}

fn group_to_proto(group: &Group) -> switchback_traits::Result<pb::Group> {
    Ok(pb::Group {
        id: group.id.as_str().to_string(),
        dir: group.dir.clone(),
        title: group.title.clone(),
        overview: opt_string(&group.overview),
        source: group
            .source
            .as_ref()
            .map(manual::source_to_proto)
            .map(buffa::MessageField::some)
            .unwrap_or_default(),
        entities: group
            .entities
            .iter()
            .map(entity::entity_to_proto)
            .collect::<switchback_traits::Result<_>>()?,
        ..Default::default()
    })
}

fn group_from_proto(group: pb::Group) -> switchback_traits::Result<Group> {
    Ok(Group {
        id: GroupId::from(group.id),
        dir: group.dir,
        title: group.title,
        overview: string_opt(group.overview),
        source: if group.source.is_set() {
            Some(manual::source_from_proto(&group.source))
        } else {
            None
        },
        entities: group
            .entities
            .into_iter()
            .map(entity::entity_from_proto)
            .collect::<switchback_traits::Result<_>>()?,
        source_path: PathBuf::new(),
    })
}

fn companion_to_proto(companion: &Companion) -> pb::Companion {
    pb::Companion {
        output_name: companion.output_name.clone(),
        bytes: companion.bytes.clone(),
        media_type: companion.media_type.clone(),
        title: companion.title.clone(),
        source_dir: companion.source_dir.clone(),
        stem: companion.stem.clone(),
        ..Default::default()
    }
}

fn companion_from_proto(companion: pb::Companion) -> Companion {
    Companion {
        output_name: companion.output_name,
        bytes: companion.bytes,
        media_type: companion.media_type,
        title: companion.title,
        source_dir: companion.source_dir,
        stem: companion.stem,
    }
}