coil-wasm 0.1.0

WASM extension runtime and host APIs for the Coil 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
108
109
110
111
112
113
114
115
116

use crate::validation::validate_token;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ModuleDataRepositoryKind {
    Owned,
    Shared,
}

impl std::fmt::Display for ModuleDataRepositoryKind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Owned => f.write_str("owned"),
            Self::Shared => f.write_str("shared"),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ModuleDataRepository {
    pub id: String,
    pub kind: ModuleDataRepositoryKind,
}

impl ModuleDataRepository {
    pub fn owned(id: impl Into<String>) -> Result<Self, crate::error::WasmModelError> {
        Ok(Self {
            id: validate_token("data_repository_id", id.into())?,
            kind: ModuleDataRepositoryKind::Owned,
        })
    }

    pub fn shared(id: impl Into<String>) -> Result<Self, crate::error::WasmModelError> {
        Ok(Self {
            id: validate_token("data_repository_id", id.into())?,
            kind: ModuleDataRepositoryKind::Shared,
        })
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ModuleDataContract {
    pub owner_extension_id: String,
    pub owner_handler_id: String,
    pub repository: ModuleDataRepository,
    pub resource: String,
}

impl ModuleDataContract {
    pub fn new(
        owner_extension_id: impl Into<String>,
        owner_handler_id: impl Into<String>,
        resource: impl Into<String>,
    ) -> Result<Self, crate::error::WasmModelError> {
        let resource = validate_token("data_contract_resource", resource.into())?;
        let repository = ModuleDataRepository::owned(resource.clone())?;
        Ok(Self {
            owner_extension_id: validate_token(
                "data_contract_owner_extension_id",
                owner_extension_id.into(),
            )?,
            owner_handler_id: validate_token(
                "data_contract_owner_handler_id",
                owner_handler_id.into(),
            )?,
            repository,
            resource,
        })
    }

    pub fn with_repository(
        owner_extension_id: impl Into<String>,
        owner_handler_id: impl Into<String>,
        repository: ModuleDataRepository,
    ) -> Result<Self, crate::error::WasmModelError> {
        let resource = repository.id.clone();
        Ok(Self {
            owner_extension_id: validate_token(
                "data_contract_owner_extension_id",
                owner_extension_id.into(),
            )?,
            owner_handler_id: validate_token(
                "data_contract_owner_handler_id",
                owner_handler_id.into(),
            )?,
            repository,
            resource,
        })
    }

    pub fn owned_repository(
        owner_extension_id: impl Into<String>,
        owner_handler_id: impl Into<String>,
        repository: impl Into<String>,
    ) -> Result<Self, crate::error::WasmModelError> {
        Self::with_repository(
            owner_extension_id,
            owner_handler_id,
            ModuleDataRepository::owned(repository)?,
        )
    }

    pub fn repository_id(&self) -> &str {
        &self.repository.id
    }

    pub fn summary(&self, access: &str, sequence: u64) -> String {
        format!(
            "module={} handler={} repository={} repository_kind={} access={} sequence={sequence}",
            self.owner_extension_id,
            self.owner_handler_id,
            self.repository.id,
            self.repository.kind,
            access,
        )
    }
}