Skip to main content

compose_lens/model/
resource.rs

1//! Top-level volumes, configs, secrets, and service grants.
2
3use super::{BooleanValue, FieldReference, KeyValueEntry, Labels, Located};
4use crate::source::SourceSpan;
5
6/// A typed top-level volume definition.
7#[derive(Debug, Clone, PartialEq, Eq)]
8pub struct VolumeDefinition {
9    name: Located<String>,
10    span: SourceSpan,
11    driver: Option<Located<String>>,
12    driver_opts: Vec<KeyValueEntry>,
13    external: Option<Located<BooleanValue>>,
14    labels: Option<Labels>,
15    custom_name: Option<Located<String>>,
16    extension_fields: Vec<FieldReference>,
17    unknown_fields: Vec<FieldReference>,
18}
19
20impl VolumeDefinition {
21    pub(crate) fn new(name: Located<String>, span: SourceSpan) -> Self {
22        Self {
23            name,
24            span,
25            driver: None,
26            driver_opts: Vec::new(),
27            external: None,
28            labels: None,
29            custom_name: None,
30            extension_fields: Vec::new(),
31            unknown_fields: Vec::new(),
32        }
33    }
34    pub(crate) fn set_driver(&mut self, value: Located<String>) {
35        self.driver = Some(value);
36    }
37    pub(crate) fn set_driver_opts(&mut self, value: Vec<KeyValueEntry>) {
38        self.driver_opts = value;
39    }
40    pub(crate) fn set_external(&mut self, value: Located<BooleanValue>) {
41        self.external = Some(value);
42    }
43    pub(crate) fn set_labels(&mut self, value: Labels) {
44        self.labels = Some(value);
45    }
46    pub(crate) fn set_custom_name(&mut self, value: Located<String>) {
47        self.custom_name = Some(value);
48    }
49    pub(crate) fn push_extension(&mut self, value: FieldReference) {
50        self.extension_fields.push(value);
51    }
52    pub(crate) fn push_unknown(&mut self, value: FieldReference) {
53        self.unknown_fields.push(value);
54    }
55
56    /// Returns the model identifier.
57    #[must_use]
58    pub const fn name(&self) -> &Located<String> {
59        &self.name
60    }
61    /// Returns the complete definition span.
62    #[must_use]
63    pub const fn span(&self) -> SourceSpan {
64        self.span
65    }
66    /// Returns the volume driver.
67    #[must_use]
68    pub const fn driver(&self) -> Option<&Located<String>> {
69        self.driver.as_ref()
70    }
71    /// Returns driver options.
72    #[must_use]
73    pub fn driver_opts(&self) -> &[KeyValueEntry] {
74        &self.driver_opts
75    }
76    /// Returns the external-lifecycle setting.
77    #[must_use]
78    pub const fn external(&self) -> Option<&Located<BooleanValue>> {
79        self.external.as_ref()
80    }
81    /// Returns labels with their syntax form retained.
82    #[must_use]
83    pub const fn labels(&self) -> Option<&Labels> {
84        self.labels.as_ref()
85    }
86    /// Returns the platform-level custom name.
87    #[must_use]
88    pub const fn custom_name(&self) -> Option<&Located<String>> {
89        self.custom_name.as_ref()
90    }
91    /// Returns retained `x-` fields.
92    #[must_use]
93    pub fn extension_fields(&self) -> &[FieldReference] {
94        &self.extension_fields
95    }
96    /// Returns unrecognized fields.
97    #[must_use]
98    pub fn unknown_fields(&self) -> &[FieldReference] {
99        &self.unknown_fields
100    }
101}
102
103/// A typed top-level config definition.
104#[derive(Debug, Clone, PartialEq, Eq)]
105pub struct ConfigDefinition {
106    name: Located<String>,
107    span: SourceSpan,
108    file: Option<Located<String>>,
109    environment: Option<Located<String>>,
110    content: Option<Located<String>>,
111    external: Option<Located<BooleanValue>>,
112    custom_name: Option<Located<String>>,
113    extension_fields: Vec<FieldReference>,
114    unknown_fields: Vec<FieldReference>,
115}
116
117impl ConfigDefinition {
118    pub(crate) fn new(name: Located<String>, span: SourceSpan) -> Self {
119        Self {
120            name,
121            span,
122            file: None,
123            environment: None,
124            content: None,
125            external: None,
126            custom_name: None,
127            extension_fields: Vec::new(),
128            unknown_fields: Vec::new(),
129        }
130    }
131    pub(crate) fn set_file(&mut self, value: Located<String>) {
132        self.file = Some(value);
133    }
134    pub(crate) fn set_environment(&mut self, value: Located<String>) {
135        self.environment = Some(value);
136    }
137    pub(crate) fn set_content(&mut self, value: Located<String>) {
138        self.content = Some(value);
139    }
140    pub(crate) fn set_external(&mut self, value: Located<BooleanValue>) {
141        self.external = Some(value);
142    }
143    pub(crate) fn set_custom_name(&mut self, value: Located<String>) {
144        self.custom_name = Some(value);
145    }
146    pub(crate) fn push_extension(&mut self, value: FieldReference) {
147        self.extension_fields.push(value);
148    }
149    pub(crate) fn push_unknown(&mut self, value: FieldReference) {
150        self.unknown_fields.push(value);
151    }
152
153    /// Returns the model identifier.
154    #[must_use]
155    pub const fn name(&self) -> &Located<String> {
156        &self.name
157    }
158    /// Returns the complete definition span.
159    #[must_use]
160    pub const fn span(&self) -> SourceSpan {
161        self.span
162    }
163    /// Returns the source file path.
164    #[must_use]
165    pub const fn file(&self) -> Option<&Located<String>> {
166        self.file.as_ref()
167    }
168    /// Returns the host environment-variable source name.
169    #[must_use]
170    pub const fn environment(&self) -> Option<&Located<String>> {
171        self.environment.as_ref()
172    }
173    /// Returns inline config content.
174    #[must_use]
175    pub const fn content(&self) -> Option<&Located<String>> {
176        self.content.as_ref()
177    }
178    /// Returns the external-lifecycle setting.
179    #[must_use]
180    pub const fn external(&self) -> Option<&Located<BooleanValue>> {
181        self.external.as_ref()
182    }
183    /// Returns the platform-level custom name.
184    #[must_use]
185    pub const fn custom_name(&self) -> Option<&Located<String>> {
186        self.custom_name.as_ref()
187    }
188    /// Returns retained `x-` fields.
189    #[must_use]
190    pub fn extension_fields(&self) -> &[FieldReference] {
191        &self.extension_fields
192    }
193    /// Returns unrecognized fields.
194    #[must_use]
195    pub fn unknown_fields(&self) -> &[FieldReference] {
196        &self.unknown_fields
197    }
198}
199
200/// A typed top-level secret definition.
201#[derive(Debug, Clone, PartialEq, Eq)]
202pub struct SecretDefinition {
203    name: Located<String>,
204    span: SourceSpan,
205    file: Option<Located<String>>,
206    environment: Option<Located<String>>,
207    external: Option<Located<BooleanValue>>,
208    custom_name: Option<Located<String>>,
209    extension_fields: Vec<FieldReference>,
210    unknown_fields: Vec<FieldReference>,
211}
212
213impl SecretDefinition {
214    pub(crate) fn new(name: Located<String>, span: SourceSpan) -> Self {
215        Self {
216            name,
217            span,
218            file: None,
219            environment: None,
220            external: None,
221            custom_name: None,
222            extension_fields: Vec::new(),
223            unknown_fields: Vec::new(),
224        }
225    }
226    pub(crate) fn set_file(&mut self, value: Located<String>) {
227        self.file = Some(value);
228    }
229    pub(crate) fn set_environment(&mut self, value: Located<String>) {
230        self.environment = Some(value);
231    }
232    pub(crate) fn set_external(&mut self, value: Located<BooleanValue>) {
233        self.external = Some(value);
234    }
235    pub(crate) fn set_custom_name(&mut self, value: Located<String>) {
236        self.custom_name = Some(value);
237    }
238    pub(crate) fn push_extension(&mut self, value: FieldReference) {
239        self.extension_fields.push(value);
240    }
241    pub(crate) fn push_unknown(&mut self, value: FieldReference) {
242        self.unknown_fields.push(value);
243    }
244
245    /// Returns the model identifier.
246    #[must_use]
247    pub const fn name(&self) -> &Located<String> {
248        &self.name
249    }
250    /// Returns the complete definition span.
251    #[must_use]
252    pub const fn span(&self) -> SourceSpan {
253        self.span
254    }
255    /// Returns the source file path.
256    #[must_use]
257    pub const fn file(&self) -> Option<&Located<String>> {
258        self.file.as_ref()
259    }
260    /// Returns the host environment-variable source name.
261    #[must_use]
262    pub const fn environment(&self) -> Option<&Located<String>> {
263        self.environment.as_ref()
264    }
265    /// Returns the external-lifecycle setting.
266    #[must_use]
267    pub const fn external(&self) -> Option<&Located<BooleanValue>> {
268        self.external.as_ref()
269    }
270    /// Returns the platform-level custom name.
271    #[must_use]
272    pub const fn custom_name(&self) -> Option<&Located<String>> {
273        self.custom_name.as_ref()
274    }
275    /// Returns retained `x-` fields.
276    #[must_use]
277    pub fn extension_fields(&self) -> &[FieldReference] {
278        &self.extension_fields
279    }
280    /// Returns unrecognized fields.
281    #[must_use]
282    pub fn unknown_fields(&self) -> &[FieldReference] {
283        &self.unknown_fields
284    }
285}
286
287/// Long syntax shared by service config and secret grants.
288#[derive(Debug, Clone, PartialEq, Eq)]
289pub struct LongGrant {
290    span: SourceSpan,
291    source: Option<Located<String>>,
292    target: Option<Located<String>>,
293    uid: Option<Located<String>>,
294    gid: Option<Located<String>>,
295    mode: Option<Located<String>>,
296    extension_fields: Vec<FieldReference>,
297    unknown_fields: Vec<FieldReference>,
298}
299
300impl LongGrant {
301    pub(crate) fn new(span: SourceSpan) -> Self {
302        Self {
303            span,
304            source: None,
305            target: None,
306            uid: None,
307            gid: None,
308            mode: None,
309            extension_fields: Vec::new(),
310            unknown_fields: Vec::new(),
311        }
312    }
313    pub(crate) fn set_source(&mut self, value: Located<String>) {
314        self.source = Some(value);
315    }
316    pub(crate) fn set_target(&mut self, value: Located<String>) {
317        self.target = Some(value);
318    }
319    pub(crate) fn set_uid(&mut self, value: Located<String>) {
320        self.uid = Some(value);
321    }
322    pub(crate) fn set_gid(&mut self, value: Located<String>) {
323        self.gid = Some(value);
324    }
325    pub(crate) fn set_mode(&mut self, value: Located<String>) {
326        self.mode = Some(value);
327    }
328    pub(crate) fn push_extension(&mut self, value: FieldReference) {
329        self.extension_fields.push(value);
330    }
331    pub(crate) fn push_unknown(&mut self, value: FieldReference) {
332        self.unknown_fields.push(value);
333    }
334
335    /// Returns the complete mapping span.
336    #[must_use]
337    pub const fn span(&self) -> SourceSpan {
338        self.span
339    }
340    /// Returns the referenced resource name.
341    #[must_use]
342    pub const fn source(&self) -> Option<&Located<String>> {
343        self.source.as_ref()
344    }
345    /// Returns the container target.
346    #[must_use]
347    pub const fn target(&self) -> Option<&Located<String>> {
348        self.target.as_ref()
349    }
350    /// Returns the requested user ID spelling.
351    #[must_use]
352    pub const fn uid(&self) -> Option<&Located<String>> {
353        self.uid.as_ref()
354    }
355    /// Returns the requested group ID spelling.
356    #[must_use]
357    pub const fn gid(&self) -> Option<&Located<String>> {
358        self.gid.as_ref()
359    }
360    /// Returns the requested permission-mode spelling.
361    #[must_use]
362    pub const fn mode(&self) -> Option<&Located<String>> {
363        self.mode.as_ref()
364    }
365    /// Returns retained `x-` fields.
366    #[must_use]
367    pub fn extension_fields(&self) -> &[FieldReference] {
368        &self.extension_fields
369    }
370    /// Returns unrecognized fields.
371    #[must_use]
372    pub fn unknown_fields(&self) -> &[FieldReference] {
373        &self.unknown_fields
374    }
375}
376
377/// A service config grant with its syntax form retained.
378#[derive(Debug, Clone, PartialEq, Eq)]
379pub enum ConfigGrant {
380    /// Config-name short syntax.
381    Short(Located<String>),
382    /// Mapping-based long syntax.
383    Long(Box<LongGrant>),
384}
385
386/// A service secret grant with its syntax form retained.
387#[derive(Debug, Clone, PartialEq, Eq)]
388pub enum SecretGrant {
389    /// Secret-name short syntax.
390    Short(Located<String>),
391    /// Mapping-based long syntax.
392    Long(Box<LongGrant>),
393}