quickgpu/builders/
pipeline_cache_descriptor_builder.rs1pub use super::super::Nested;
5pub use std::{borrow::Cow, num::NonZeroU32, ops::Range};
6pub trait Field {}
7pub trait IsOptional {}
8#[doc = "\nBuilder for [`wgpu::PipelineCacheDescriptor`]\n \nSet all required fields and any optional fields, then call `build()`.\n\nBuilder field setters:\n - [data](PipelineCacheDescriptorBuilder::data) Optional, defaults to `None`\n - [fallback](PipelineCacheDescriptorBuilder::fallback) Required\n"]
9pub struct PipelineCacheDescriptorBuilder<'a, CS: State<'a>> {
10 label: CS::Label,
11 data: CS::Data,
12 fallback: CS::Fallback,
13}
14impl<'a> PipelineCacheDescriptorBuilder<'a, Empty> {
15 pub fn new() -> PipelineCacheDescriptorBuilder<'a, Empty> {
16 PipelineCacheDescriptorBuilder {
17 label: LabelEmpty,
18 data: DataEmpty,
19 fallback: FallbackEmpty,
20 }
21 }
22}
23#[doc = "\nReturns [PipelineCacheDescriptorBuilder] for building [`wgpu::PipelineCacheDescriptor`]\n \nSet all required fields and any optional fields, then call `build()`.\n\nBuilder field setters:\n - [data](PipelineCacheDescriptorBuilder::data) Optional, defaults to `None`\n - [fallback](PipelineCacheDescriptorBuilder::fallback) Required\n"]
24pub fn pipeline_cache_descriptor<'a>(
25 label: wgpu::Label<'a>,
26) -> PipelineCacheDescriptorBuilder<'a, SetLabel<Empty>> {
27 PipelineCacheDescriptorBuilder::new().label(label)
28}
29pub struct LabelEmpty;
30impl Field for LabelEmpty {}
31pub trait LabelIsEmpty {}
32impl LabelIsEmpty for LabelEmpty {}
33pub trait IsSetLabel<'a> {
34 fn get(self) -> wgpu::Label<'a>;
35}
36impl<'a> IsSetLabel<'a> for LabelEmpty {
37 fn get(self) -> wgpu::Label<'a> {
38 None
39 }
40}
41pub struct LabelValue<'a>(pub wgpu::Label<'a>);
42impl<'a> Field for LabelValue<'a> {}
43impl<'a> IsSetLabel<'a> for LabelValue<'a> {
44 fn get(self) -> wgpu::Label<'a> {
45 self.0
46 }
47}
48pub struct DataEmpty;
49impl Field for DataEmpty {}
50pub trait DataIsEmpty {}
51impl DataIsEmpty for DataEmpty {}
52pub trait IsSetData<'a> {
53 fn get(self) -> Option<&'a [u8]>;
54}
55impl<'a> IsSetData<'a> for DataEmpty {
56 fn get(self) -> Option<&'a [u8]> {
57 None
58 }
59}
60pub struct DataValue<'a>(pub Option<&'a [u8]>);
61impl<'a> Field for DataValue<'a> {}
62impl<'a> IsSetData<'a> for DataValue<'a> {
63 fn get(self) -> Option<&'a [u8]> {
64 self.0
65 }
66}
67pub struct FallbackEmpty;
68impl Field for FallbackEmpty {}
69pub trait FallbackIsEmpty {}
70impl FallbackIsEmpty for FallbackEmpty {}
71pub trait IsSetFallback {
72 fn get(self) -> bool;
73}
74pub struct FallbackValue(pub bool);
75impl Field for FallbackValue {}
76impl IsSetFallback for FallbackValue {
77 fn get(self) -> bool {
78 self.0
79 }
80}
81pub trait State<'a> {
82 type Label: Field;
83 type Data: Field;
84 type Fallback: Field;
85}
86pub struct Empty;
87impl<'a> State<'a> for Empty {
88 type Label = LabelEmpty;
89 type Data = DataEmpty;
90 type Fallback = FallbackEmpty;
91}
92pub struct SetLabel<CS>(CS);
93impl<'a, CS: State<'a>> State<'a> for SetLabel<CS> {
94 type Label = LabelValue<'a>;
95 type Data = CS::Data;
96 type Fallback = CS::Fallback;
97}
98pub struct SetData<CS>(CS);
99impl<'a, CS: State<'a>> State<'a> for SetData<CS> {
100 type Label = CS::Label;
101 type Data = DataValue<'a>;
102 type Fallback = CS::Fallback;
103}
104pub struct SetFallback<CS>(CS);
105impl<'a, CS: State<'a>> State<'a> for SetFallback<CS> {
106 type Label = CS::Label;
107 type Data = CS::Data;
108 type Fallback = FallbackValue;
109}
110impl<'a, CS: State<'a>> PipelineCacheDescriptorBuilder<'a, CS> {
111 #[doc = "Setter for [wgpu::PipelineCacheDescriptor::label]. Optional, defaults to `None`.\n"]
112 pub fn label(self, label: wgpu::Label<'a>) -> PipelineCacheDescriptorBuilder<'a, SetLabel<CS>>
113 where
114 CS::Label: LabelIsEmpty,
115 {
116 PipelineCacheDescriptorBuilder {
117 label: LabelValue(label),
118 data: self.data,
119 fallback: self.fallback,
120 }
121 }
122 #[doc = "Setter for [wgpu::PipelineCacheDescriptor::data]. Optional, defaults to `None`.\n"]
123 pub fn data(self, data: &'a [u8]) -> PipelineCacheDescriptorBuilder<'a, SetData<CS>>
124 where
125 CS::Data: DataIsEmpty,
126 {
127 PipelineCacheDescriptorBuilder {
128 label: self.label,
129 data: DataValue(Some(data)),
130 fallback: self.fallback,
131 }
132 }
133 #[doc = "Setter for [wgpu::PipelineCacheDescriptor::data]. Optional, defaults to `None`.\n"]
134 pub fn maybe_data(
135 self,
136 data: Option<&'a [u8]>,
137 ) -> PipelineCacheDescriptorBuilder<'a, SetData<CS>>
138 where
139 CS::Data: DataIsEmpty,
140 {
141 PipelineCacheDescriptorBuilder {
142 label: self.label,
143 data: DataValue(data),
144 fallback: self.fallback,
145 }
146 }
147 #[doc = "Setter for [wgpu::PipelineCacheDescriptor::fallback]. Required.\n"]
148 pub fn fallback(self, fallback: bool) -> PipelineCacheDescriptorBuilder<'a, SetFallback<CS>>
149 where
150 CS::Fallback: FallbackIsEmpty,
151 {
152 PipelineCacheDescriptorBuilder {
153 label: self.label,
154 data: self.data,
155 fallback: FallbackValue(fallback),
156 }
157 }
158}
159pub trait Complete<'a>:
160 State<'a, Label: IsSetLabel<'a>, Data: IsSetData<'a>, Fallback: IsSetFallback>
161{
162}
163impl<'a, CS: State<'a, Label: IsSetLabel<'a>, Data: IsSetData<'a>, Fallback: IsSetFallback>>
164 Complete<'a> for CS
165{
166}
167impl<'a, CS: Complete<'a>> PipelineCacheDescriptorBuilder<'a, CS> {
168 pub fn build(self) -> wgpu::PipelineCacheDescriptor<'a> {
169 wgpu::PipelineCacheDescriptor {
170 label: IsSetLabel::get(self.label),
171 data: IsSetData::get(self.data),
172 fallback: IsSetFallback::get(self.fallback),
173 }
174 }
175}
176impl<'a> Nested<wgpu::PipelineCacheDescriptor<'a>> for wgpu::PipelineCacheDescriptor<'a> {
177 fn unnest(self) -> wgpu::PipelineCacheDescriptor<'a> {
178 self
179 }
180}
181impl<'a, CS: Complete<'a>> Nested<wgpu::PipelineCacheDescriptor<'a>>
182 for PipelineCacheDescriptorBuilder<'a, CS>
183{
184 fn unnest(self) -> wgpu::PipelineCacheDescriptor<'a> {
185 self.build()
186 }
187}
188#[cfg(test)]
189mod tests {
190 #[allow(unused_imports)]
191 #[allow(unused_imports)]
192 use std::num::NonZeroU32;
193 #[test]
194 pub fn test_default() {
195 assert_eq!(
196 format!("{:#?}", super::IsSetLabel::get(super::LabelEmpty)),
197 format!("{:#?}", wgpu::Label::default()),
198 );
199 assert_eq!(
200 format!("{:#?}", super::IsSetData::get(super::DataEmpty)),
201 format!("{:#?}", Option::<&[u8]>::default()),
202 );
203 }
204}