genotype_compiler 0.16.1

Genotype language compiler
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

use crate::prelude::internal::*;

/// Remote compiler.
pub struct GtcRemote {
    state: GtCompilerState,
    backend: GtbRemote,
}

impl GtcRemote {
    pub async fn handle_runtime_request(
        &mut self,
        request: GtcRemoteRuntimeRequest,
    ) -> Result<GtcRemoteRuntimeRequestResponse> {
        match request {
            GtcRemoteRuntimeRequest::LoadInProject(GtcRemoteRuntimeRequestLoadInProject {
                ..
            }) => {
                let meta = self.load_in_project().await?;
                Ok(GtcRemoteRuntimeRequestResponse::LoadInProject(
                    GtcRemoteRuntimeRequestResponseLoadInProject { meta },
                ))
            }

            GtcRemoteRuntimeRequest::LoadInModules(GtcRemoteRuntimeRequestLoadInModules {
                ..
            }) => {
                let meta = self.load_in_modules().await?;
                Ok(GtcRemoteRuntimeRequestResponse::LoadInModules(
                    GtcRemoteRuntimeRequestResponseLoadInModules { meta },
                ))
            }

            GtcRemoteRuntimeRequest::Compile(GtcRemoteRuntimeRequestCompile { .. }) => {
                let meta = self.compile().await?;
                Ok(GtcRemoteRuntimeRequestResponse::Compile(
                    GtcRemoteRuntimeRequestResponseCompile { meta },
                ))
            }
        }
    }
}

impl GtCompiler<GtcRemoteProps> for GtcRemote {
    fn new(props: GtcRemoteProps) -> Result<Self> {
        let (interop, cwd_path, base_path, config_path) = props;

        let backend = GtbRemote::new(interop, cwd_path, base_path);

        Ok(Self {
            state: GtCompilerState::New {
                config_path,
                meta: GtcMetaNew {},
            },
            backend,
        })
    }

    fn state(&self) -> &GtCompilerState {
        &self.state
    }

    fn state_mut(&mut self) -> &mut GtCompilerState {
        &mut self.state
    }

    fn backend(&self) -> &impl GtBackend {
        &self.backend
    }
}

pub type GtcRemoteProps = (
    Box<dyn GtbRemoteInterop>,
    GtpCwdPath,
    GtpCwdRelativePath,
    Option<GtpCwdRelativePath>,
);