1use 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}