harmos-sdk 0.1.13

Harmos SDK for authoring plugins and operations over the Harmos runtime.
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
117
118
119

/* ***
 *
 * Harmos
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * ***
 */

// Lifecycle Preparation And Role-Specific Configuration

/* === Modules === */

/* === Re-Exports === */

/* === Imports === */

// Standard Library Imports
use std::sync::Arc;

// Third Party Imports

// Local Imports
use crate::Lifecycle;
use crate::lifecycle::Context;
use crate::operations::{OperationCatalog, StartupError};

/* === Constants === */

/* === Macros === */

/* === Type Aliases === */

/* === Structs === */

pub struct Setup<L: Lifecycle> {
    configuration: <L::Context as Context>::Configuration,
    replacing: bool,
}

/* === Enums === */

/* === Traits === */

#[doc(hidden)]
pub trait SetupConfiguration: Send + 'static {
    fn resource<T: Send + Sync + 'static>(&mut self, value: Arc<T>, replace: bool);
    fn validate(&mut self) -> Result<(), StartupError>;
}

#[doc(hidden)]
pub trait ApplicationConfiguration: SetupConfiguration {
    type Lane;
    type LaneSettings;

    fn lane(&mut self, lane: Self::Lane, settings: Self::LaneSettings);
    fn operations<C: OperationCatalog>(&mut self, lane: Self::Lane);
}

/* === Implementations === */

impl<L: Lifecycle> Setup<L> {
    #[doc(hidden)]
    pub fn new(configuration: <L::Context as Context>::Configuration) -> Self {
        Self { configuration, replacing: false }
    }

    pub fn resource<T: Send + Sync + 'static>(&mut self, value: impl Into<Arc<T>>) -> &mut Self {
        self.configuration.resource(value.into(), self.replacing);
        self
    }

    pub fn settings(&mut self) -> &mut <L::Context as Context>::Configuration {
        &mut self.configuration
    }

    #[doc(hidden)]
    pub fn overrides(&mut self, update: impl FnOnce(&mut Self)) {
        self.replacing = true;
        update(self);
        self.replacing = false;
    }

    #[doc(hidden)]
    pub fn validate(&mut self) -> Result<(), StartupError> {
        self.configuration.validate()
    }

    #[doc(hidden)]
    pub fn into_configuration(self) -> <L::Context as Context>::Configuration {
        self.configuration
    }
}

impl<L: Lifecycle> Setup<L>
where
    <L::Context as Context>::Configuration: ApplicationConfiguration,
{
    pub fn lane(
        &mut self, lane: <<L::Context as Context>::Configuration as ApplicationConfiguration>::Lane,
        settings: <<L::Context as Context>::Configuration as ApplicationConfiguration>::LaneSettings,
    ) -> &mut Self {
        self.configuration.lane(lane, settings);
        self
    }

    pub fn operations<C: OperationCatalog>(
        &mut self, lane: <<L::Context as Context>::Configuration as ApplicationConfiguration>::Lane,
    ) -> &mut Self {
        self.configuration.operations::<C>(lane);
        self
    }
}

/* === Public Functions === */

/* === Private Functions === */

/* === Tests === */