Skip to main content

cm_rust/
capability.rs

1// Copyright 2026 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use cm_rust_derive::FidlDecl;
6use cm_types::{Name, Path, RelativePath};
7use fidl_fuchsia_component_decl as fdecl;
8use fidl_fuchsia_io as fio;
9use from_enum::FromEnum;
10
11use crate::{
12    CapabilityTypeName, ConfigValue, FidlIntoNative, NativeIntoFidl, StorageDirectorySource,
13};
14
15#[cfg(fuchsia_api_level_at_least = "HEAD")]
16use cm_types::DeliveryType;
17
18#[cfg(feature = "serde")]
19use crate::serde_ext;
20
21#[cfg(feature = "serde")]
22use serde::{Deserialize, Serialize};
23
24#[cfg_attr(
25    feature = "serde",
26    derive(Deserialize, Serialize),
27    serde(tag = "type", rename_all = "snake_case")
28)]
29#[derive(FidlDecl, FromEnum, Debug, Clone, PartialEq, Eq)]
30#[fidl_decl(fidl_union = "fdecl::Capability")]
31pub enum CapabilityDecl {
32    Service(ServiceDecl),
33    Protocol(ProtocolDecl),
34    Directory(DirectoryDecl),
35    Storage(StorageDecl),
36    Runner(RunnerDecl),
37    Resolver(ResolverDecl),
38    EventStream(EventStreamDecl),
39    Dictionary(DictionaryDecl),
40    Config(ConfigurationDecl),
41}
42
43#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
44#[derive(FidlDecl, Debug, Clone, PartialEq, Eq)]
45#[fidl_decl(fidl_table = "fdecl::Service")]
46pub struct ServiceDecl {
47    pub name: Name,
48    pub source_path: Option<Path>,
49}
50
51#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
52#[derive(FidlDecl, Debug, Clone, PartialEq, Eq)]
53#[fidl_decl(fidl_table = "fdecl::Protocol")]
54pub struct ProtocolDecl {
55    pub name: Name,
56    pub source_path: Option<Path>,
57    #[fidl_decl(default)]
58    #[cfg(fuchsia_api_level_at_least = "HEAD")]
59    pub delivery: DeliveryType,
60}
61
62#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
63#[derive(FidlDecl, Debug, Clone, PartialEq, Eq)]
64#[fidl_decl(fidl_table = "fdecl::Directory")]
65pub struct DirectoryDecl {
66    pub name: Name,
67    pub source_path: Option<Path>,
68
69    #[cfg_attr(
70        feature = "serde",
71        serde(
72            deserialize_with = "serde_ext::deserialize_fio_operations",
73            serialize_with = "serde_ext::serialize_fio_operations"
74        )
75    )]
76    pub rights: fio::Operations,
77}
78
79#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
80#[derive(FidlDecl, Debug, Clone, PartialEq, Eq)]
81#[fidl_decl(fidl_table = "fdecl::Storage")]
82pub struct StorageDecl {
83    pub name: Name,
84    pub source: StorageDirectorySource,
85    pub backing_dir: Name,
86    #[fidl_decl(default_preserve_none)]
87    pub subdir: RelativePath,
88    #[cfg_attr(feature = "serde", serde(with = "serde_ext::StorageId"))]
89    pub storage_id: fdecl::StorageId,
90}
91
92#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
93#[derive(FidlDecl, Debug, Clone, PartialEq, Eq)]
94#[fidl_decl(fidl_table = "fdecl::Runner")]
95pub struct RunnerDecl {
96    pub name: Name,
97    pub source_path: Option<Path>,
98}
99
100#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
101#[derive(FidlDecl, Debug, Clone, PartialEq, Eq)]
102#[fidl_decl(fidl_table = "fdecl::Resolver")]
103pub struct ResolverDecl {
104    pub name: Name,
105    pub source_path: Option<Path>,
106}
107
108#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
109#[derive(FidlDecl, Debug, Clone, PartialEq, Eq)]
110#[fidl_decl(fidl_table = "fdecl::EventStream")]
111pub struct EventStreamDecl {
112    pub name: Name,
113}
114
115#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
116#[derive(FidlDecl, Debug, Clone, PartialEq, Eq)]
117#[fidl_decl(fidl_table = "fdecl::Dictionary")]
118pub struct DictionaryDecl {
119    pub name: Name,
120    pub source_path: Option<Path>,
121}
122
123#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
124#[derive(FidlDecl, Debug, Clone, PartialEq, Eq)]
125#[fidl_decl(fidl_table = "fdecl::Configuration")]
126pub struct ConfigurationDecl {
127    pub name: Name,
128    pub value: ConfigValue,
129}
130
131impl CapabilityDecl {
132    pub fn name(&self) -> &Name {
133        match self {
134            CapabilityDecl::Directory(decl) => &decl.name,
135            CapabilityDecl::Protocol(decl) => &decl.name,
136            CapabilityDecl::Resolver(decl) => &decl.name,
137            CapabilityDecl::Runner(decl) => &decl.name,
138            CapabilityDecl::Service(decl) => &decl.name,
139            CapabilityDecl::Storage(decl) => &decl.name,
140            CapabilityDecl::EventStream(decl) => &decl.name,
141            CapabilityDecl::Dictionary(decl) => &decl.name,
142            CapabilityDecl::Config(decl) => &decl.name,
143        }
144    }
145
146    pub fn path(&self) -> Option<&Path> {
147        match self {
148            CapabilityDecl::Directory(decl) => decl.source_path.as_ref(),
149            CapabilityDecl::Protocol(decl) => decl.source_path.as_ref(),
150            CapabilityDecl::Resolver(decl) => decl.source_path.as_ref(),
151            CapabilityDecl::Runner(decl) => decl.source_path.as_ref(),
152            CapabilityDecl::Service(decl) => decl.source_path.as_ref(),
153            CapabilityDecl::Storage(_) => None,
154            CapabilityDecl::EventStream(_) => None,
155            CapabilityDecl::Dictionary(_) => None,
156            CapabilityDecl::Config(_) => None,
157        }
158    }
159}
160
161impl From<&CapabilityDecl> for CapabilityTypeName {
162    fn from(capability: &CapabilityDecl) -> Self {
163        match capability {
164            CapabilityDecl::Service(_) => Self::Service,
165            CapabilityDecl::Protocol(_) => Self::Protocol,
166            CapabilityDecl::Directory(_) => Self::Directory,
167            CapabilityDecl::Storage(_) => Self::Storage,
168            CapabilityDecl::Runner(_) => Self::Runner,
169            CapabilityDecl::Resolver(_) => Self::Resolver,
170            CapabilityDecl::EventStream(_) => Self::EventStream,
171            CapabilityDecl::Dictionary(_) => Self::Dictionary,
172            CapabilityDecl::Config(_) => Self::Config,
173        }
174    }
175}