1 #![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
2 #[cfg(feature = "Win32_Graphics_Direct3D12")]
3 #[inline]
DMLCreateDevice<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Graphics::Direct3D12::ID3D12Device>, T: ::windows::runtime::Interface>(d3d12device: Param0, flags: DML_CREATE_DEVICE_FLAGS, result__: *mut ::std::option::Option<T>) -> ::windows::runtime::Result<()>4 pub unsafe fn DMLCreateDevice<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Graphics::Direct3D12::ID3D12Device>, T: ::windows::runtime::Interface>(d3d12device: Param0, flags: DML_CREATE_DEVICE_FLAGS, result__: *mut ::std::option::Option<T>) -> ::windows::runtime::Result<()> {
5     #[cfg(windows)]
6     {
7         #[link(name = "windows")]
8         extern "system" {
9             fn DMLCreateDevice(d3d12device: ::windows::runtime::RawPtr, flags: DML_CREATE_DEVICE_FLAGS, riid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT;
10         }
11         DMLCreateDevice(d3d12device.into_param().abi(), ::std::mem::transmute(flags), &<T as ::windows::runtime::Interface>::IID, result__ as *mut _ as *mut _).ok()
12     }
13     #[cfg(not(windows))]
14     unimplemented!("Unsupported target OS");
15 }
16 #[cfg(feature = "Win32_Graphics_Direct3D12")]
17 #[inline]
DMLCreateDevice1<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Graphics::Direct3D12::ID3D12Device>, T: ::windows::runtime::Interface>(d3d12device: Param0, flags: DML_CREATE_DEVICE_FLAGS, minimumfeaturelevel: DML_FEATURE_LEVEL, result__: *mut ::std::option::Option<T>) -> ::windows::runtime::Result<()>18 pub unsafe fn DMLCreateDevice1<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Graphics::Direct3D12::ID3D12Device>, T: ::windows::runtime::Interface>(d3d12device: Param0, flags: DML_CREATE_DEVICE_FLAGS, minimumfeaturelevel: DML_FEATURE_LEVEL, result__: *mut ::std::option::Option<T>) -> ::windows::runtime::Result<()> {
19     #[cfg(windows)]
20     {
21         #[link(name = "windows")]
22         extern "system" {
23             fn DMLCreateDevice1(d3d12device: ::windows::runtime::RawPtr, flags: DML_CREATE_DEVICE_FLAGS, minimumfeaturelevel: DML_FEATURE_LEVEL, riid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT;
24         }
25         DMLCreateDevice1(d3d12device.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(minimumfeaturelevel), &<T as ::windows::runtime::Interface>::IID, result__ as *mut _ as *mut _).ok()
26     }
27     #[cfg(not(windows))]
28     unimplemented!("Unsupported target OS");
29 }
30 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
31 #[repr(C)]
32 pub struct DML_ACTIVATION_CELU_OPERATOR_DESC {
33     pub InputTensor: *mut DML_TENSOR_DESC,
34     pub OutputTensor: *mut DML_TENSOR_DESC,
35     pub Alpha: f32,
36 }
37 impl DML_ACTIVATION_CELU_OPERATOR_DESC {}
38 impl ::std::default::Default for DML_ACTIVATION_CELU_OPERATOR_DESC {
default() -> Self39     fn default() -> Self {
40         unsafe { ::std::mem::zeroed() }
41     }
42 }
43 impl ::std::fmt::Debug for DML_ACTIVATION_CELU_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result44     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
45         fmt.debug_struct("DML_ACTIVATION_CELU_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("Alpha", &self.Alpha).finish()
46     }
47 }
48 impl ::std::cmp::PartialEq for DML_ACTIVATION_CELU_OPERATOR_DESC {
eq(&self, other: &Self) -> bool49     fn eq(&self, other: &Self) -> bool {
50         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.Alpha == other.Alpha
51     }
52 }
53 impl ::std::cmp::Eq for DML_ACTIVATION_CELU_OPERATOR_DESC {}
54 unsafe impl ::windows::runtime::Abi for DML_ACTIVATION_CELU_OPERATOR_DESC {
55     type Abi = Self;
56     type DefaultType = Self;
57 }
58 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
59 #[repr(C)]
60 pub struct DML_ACTIVATION_ELU_OPERATOR_DESC {
61     pub InputTensor: *mut DML_TENSOR_DESC,
62     pub OutputTensor: *mut DML_TENSOR_DESC,
63     pub Alpha: f32,
64 }
65 impl DML_ACTIVATION_ELU_OPERATOR_DESC {}
66 impl ::std::default::Default for DML_ACTIVATION_ELU_OPERATOR_DESC {
default() -> Self67     fn default() -> Self {
68         unsafe { ::std::mem::zeroed() }
69     }
70 }
71 impl ::std::fmt::Debug for DML_ACTIVATION_ELU_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result72     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
73         fmt.debug_struct("DML_ACTIVATION_ELU_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("Alpha", &self.Alpha).finish()
74     }
75 }
76 impl ::std::cmp::PartialEq for DML_ACTIVATION_ELU_OPERATOR_DESC {
eq(&self, other: &Self) -> bool77     fn eq(&self, other: &Self) -> bool {
78         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.Alpha == other.Alpha
79     }
80 }
81 impl ::std::cmp::Eq for DML_ACTIVATION_ELU_OPERATOR_DESC {}
82 unsafe impl ::windows::runtime::Abi for DML_ACTIVATION_ELU_OPERATOR_DESC {
83     type Abi = Self;
84     type DefaultType = Self;
85 }
86 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
87 #[repr(C)]
88 pub struct DML_ACTIVATION_HARDMAX_OPERATOR_DESC {
89     pub InputTensor: *mut DML_TENSOR_DESC,
90     pub OutputTensor: *mut DML_TENSOR_DESC,
91 }
92 impl DML_ACTIVATION_HARDMAX_OPERATOR_DESC {}
93 impl ::std::default::Default for DML_ACTIVATION_HARDMAX_OPERATOR_DESC {
default() -> Self94     fn default() -> Self {
95         unsafe { ::std::mem::zeroed() }
96     }
97 }
98 impl ::std::fmt::Debug for DML_ACTIVATION_HARDMAX_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result99     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
100         fmt.debug_struct("DML_ACTIVATION_HARDMAX_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).finish()
101     }
102 }
103 impl ::std::cmp::PartialEq for DML_ACTIVATION_HARDMAX_OPERATOR_DESC {
eq(&self, other: &Self) -> bool104     fn eq(&self, other: &Self) -> bool {
105         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor
106     }
107 }
108 impl ::std::cmp::Eq for DML_ACTIVATION_HARDMAX_OPERATOR_DESC {}
109 unsafe impl ::windows::runtime::Abi for DML_ACTIVATION_HARDMAX_OPERATOR_DESC {
110     type Abi = Self;
111     type DefaultType = Self;
112 }
113 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
114 #[repr(C)]
115 pub struct DML_ACTIVATION_HARD_SIGMOID_OPERATOR_DESC {
116     pub InputTensor: *mut DML_TENSOR_DESC,
117     pub OutputTensor: *mut DML_TENSOR_DESC,
118     pub Alpha: f32,
119     pub Beta: f32,
120 }
121 impl DML_ACTIVATION_HARD_SIGMOID_OPERATOR_DESC {}
122 impl ::std::default::Default for DML_ACTIVATION_HARD_SIGMOID_OPERATOR_DESC {
default() -> Self123     fn default() -> Self {
124         unsafe { ::std::mem::zeroed() }
125     }
126 }
127 impl ::std::fmt::Debug for DML_ACTIVATION_HARD_SIGMOID_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result128     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
129         fmt.debug_struct("DML_ACTIVATION_HARD_SIGMOID_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("Alpha", &self.Alpha).field("Beta", &self.Beta).finish()
130     }
131 }
132 impl ::std::cmp::PartialEq for DML_ACTIVATION_HARD_SIGMOID_OPERATOR_DESC {
eq(&self, other: &Self) -> bool133     fn eq(&self, other: &Self) -> bool {
134         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.Alpha == other.Alpha && self.Beta == other.Beta
135     }
136 }
137 impl ::std::cmp::Eq for DML_ACTIVATION_HARD_SIGMOID_OPERATOR_DESC {}
138 unsafe impl ::windows::runtime::Abi for DML_ACTIVATION_HARD_SIGMOID_OPERATOR_DESC {
139     type Abi = Self;
140     type DefaultType = Self;
141 }
142 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
143 #[repr(C)]
144 pub struct DML_ACTIVATION_IDENTITY_OPERATOR_DESC {
145     pub InputTensor: *mut DML_TENSOR_DESC,
146     pub OutputTensor: *mut DML_TENSOR_DESC,
147 }
148 impl DML_ACTIVATION_IDENTITY_OPERATOR_DESC {}
149 impl ::std::default::Default for DML_ACTIVATION_IDENTITY_OPERATOR_DESC {
default() -> Self150     fn default() -> Self {
151         unsafe { ::std::mem::zeroed() }
152     }
153 }
154 impl ::std::fmt::Debug for DML_ACTIVATION_IDENTITY_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result155     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
156         fmt.debug_struct("DML_ACTIVATION_IDENTITY_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).finish()
157     }
158 }
159 impl ::std::cmp::PartialEq for DML_ACTIVATION_IDENTITY_OPERATOR_DESC {
eq(&self, other: &Self) -> bool160     fn eq(&self, other: &Self) -> bool {
161         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor
162     }
163 }
164 impl ::std::cmp::Eq for DML_ACTIVATION_IDENTITY_OPERATOR_DESC {}
165 unsafe impl ::windows::runtime::Abi for DML_ACTIVATION_IDENTITY_OPERATOR_DESC {
166     type Abi = Self;
167     type DefaultType = Self;
168 }
169 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
170 #[repr(C)]
171 pub struct DML_ACTIVATION_LEAKY_RELU_OPERATOR_DESC {
172     pub InputTensor: *mut DML_TENSOR_DESC,
173     pub OutputTensor: *mut DML_TENSOR_DESC,
174     pub Alpha: f32,
175 }
176 impl DML_ACTIVATION_LEAKY_RELU_OPERATOR_DESC {}
177 impl ::std::default::Default for DML_ACTIVATION_LEAKY_RELU_OPERATOR_DESC {
default() -> Self178     fn default() -> Self {
179         unsafe { ::std::mem::zeroed() }
180     }
181 }
182 impl ::std::fmt::Debug for DML_ACTIVATION_LEAKY_RELU_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result183     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
184         fmt.debug_struct("DML_ACTIVATION_LEAKY_RELU_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("Alpha", &self.Alpha).finish()
185     }
186 }
187 impl ::std::cmp::PartialEq for DML_ACTIVATION_LEAKY_RELU_OPERATOR_DESC {
eq(&self, other: &Self) -> bool188     fn eq(&self, other: &Self) -> bool {
189         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.Alpha == other.Alpha
190     }
191 }
192 impl ::std::cmp::Eq for DML_ACTIVATION_LEAKY_RELU_OPERATOR_DESC {}
193 unsafe impl ::windows::runtime::Abi for DML_ACTIVATION_LEAKY_RELU_OPERATOR_DESC {
194     type Abi = Self;
195     type DefaultType = Self;
196 }
197 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
198 #[repr(C)]
199 pub struct DML_ACTIVATION_LINEAR_OPERATOR_DESC {
200     pub InputTensor: *mut DML_TENSOR_DESC,
201     pub OutputTensor: *mut DML_TENSOR_DESC,
202     pub Alpha: f32,
203     pub Beta: f32,
204 }
205 impl DML_ACTIVATION_LINEAR_OPERATOR_DESC {}
206 impl ::std::default::Default for DML_ACTIVATION_LINEAR_OPERATOR_DESC {
default() -> Self207     fn default() -> Self {
208         unsafe { ::std::mem::zeroed() }
209     }
210 }
211 impl ::std::fmt::Debug for DML_ACTIVATION_LINEAR_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result212     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
213         fmt.debug_struct("DML_ACTIVATION_LINEAR_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("Alpha", &self.Alpha).field("Beta", &self.Beta).finish()
214     }
215 }
216 impl ::std::cmp::PartialEq for DML_ACTIVATION_LINEAR_OPERATOR_DESC {
eq(&self, other: &Self) -> bool217     fn eq(&self, other: &Self) -> bool {
218         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.Alpha == other.Alpha && self.Beta == other.Beta
219     }
220 }
221 impl ::std::cmp::Eq for DML_ACTIVATION_LINEAR_OPERATOR_DESC {}
222 unsafe impl ::windows::runtime::Abi for DML_ACTIVATION_LINEAR_OPERATOR_DESC {
223     type Abi = Self;
224     type DefaultType = Self;
225 }
226 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
227 #[repr(C)]
228 pub struct DML_ACTIVATION_LOG_SOFTMAX_OPERATOR_DESC {
229     pub InputTensor: *mut DML_TENSOR_DESC,
230     pub OutputTensor: *mut DML_TENSOR_DESC,
231 }
232 impl DML_ACTIVATION_LOG_SOFTMAX_OPERATOR_DESC {}
233 impl ::std::default::Default for DML_ACTIVATION_LOG_SOFTMAX_OPERATOR_DESC {
default() -> Self234     fn default() -> Self {
235         unsafe { ::std::mem::zeroed() }
236     }
237 }
238 impl ::std::fmt::Debug for DML_ACTIVATION_LOG_SOFTMAX_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result239     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
240         fmt.debug_struct("DML_ACTIVATION_LOG_SOFTMAX_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).finish()
241     }
242 }
243 impl ::std::cmp::PartialEq for DML_ACTIVATION_LOG_SOFTMAX_OPERATOR_DESC {
eq(&self, other: &Self) -> bool244     fn eq(&self, other: &Self) -> bool {
245         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor
246     }
247 }
248 impl ::std::cmp::Eq for DML_ACTIVATION_LOG_SOFTMAX_OPERATOR_DESC {}
249 unsafe impl ::windows::runtime::Abi for DML_ACTIVATION_LOG_SOFTMAX_OPERATOR_DESC {
250     type Abi = Self;
251     type DefaultType = Self;
252 }
253 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
254 #[repr(C)]
255 pub struct DML_ACTIVATION_PARAMETERIZED_RELU_OPERATOR_DESC {
256     pub InputTensor: *mut DML_TENSOR_DESC,
257     pub SlopeTensor: *mut DML_TENSOR_DESC,
258     pub OutputTensor: *mut DML_TENSOR_DESC,
259 }
260 impl DML_ACTIVATION_PARAMETERIZED_RELU_OPERATOR_DESC {}
261 impl ::std::default::Default for DML_ACTIVATION_PARAMETERIZED_RELU_OPERATOR_DESC {
default() -> Self262     fn default() -> Self {
263         unsafe { ::std::mem::zeroed() }
264     }
265 }
266 impl ::std::fmt::Debug for DML_ACTIVATION_PARAMETERIZED_RELU_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result267     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
268         fmt.debug_struct("DML_ACTIVATION_PARAMETERIZED_RELU_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("SlopeTensor", &self.SlopeTensor).field("OutputTensor", &self.OutputTensor).finish()
269     }
270 }
271 impl ::std::cmp::PartialEq for DML_ACTIVATION_PARAMETERIZED_RELU_OPERATOR_DESC {
eq(&self, other: &Self) -> bool272     fn eq(&self, other: &Self) -> bool {
273         self.InputTensor == other.InputTensor && self.SlopeTensor == other.SlopeTensor && self.OutputTensor == other.OutputTensor
274     }
275 }
276 impl ::std::cmp::Eq for DML_ACTIVATION_PARAMETERIZED_RELU_OPERATOR_DESC {}
277 unsafe impl ::windows::runtime::Abi for DML_ACTIVATION_PARAMETERIZED_RELU_OPERATOR_DESC {
278     type Abi = Self;
279     type DefaultType = Self;
280 }
281 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
282 #[repr(C)]
283 pub struct DML_ACTIVATION_PARAMETRIC_SOFTPLUS_OPERATOR_DESC {
284     pub InputTensor: *mut DML_TENSOR_DESC,
285     pub OutputTensor: *mut DML_TENSOR_DESC,
286     pub Alpha: f32,
287     pub Beta: f32,
288 }
289 impl DML_ACTIVATION_PARAMETRIC_SOFTPLUS_OPERATOR_DESC {}
290 impl ::std::default::Default for DML_ACTIVATION_PARAMETRIC_SOFTPLUS_OPERATOR_DESC {
default() -> Self291     fn default() -> Self {
292         unsafe { ::std::mem::zeroed() }
293     }
294 }
295 impl ::std::fmt::Debug for DML_ACTIVATION_PARAMETRIC_SOFTPLUS_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result296     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
297         fmt.debug_struct("DML_ACTIVATION_PARAMETRIC_SOFTPLUS_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("Alpha", &self.Alpha).field("Beta", &self.Beta).finish()
298     }
299 }
300 impl ::std::cmp::PartialEq for DML_ACTIVATION_PARAMETRIC_SOFTPLUS_OPERATOR_DESC {
eq(&self, other: &Self) -> bool301     fn eq(&self, other: &Self) -> bool {
302         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.Alpha == other.Alpha && self.Beta == other.Beta
303     }
304 }
305 impl ::std::cmp::Eq for DML_ACTIVATION_PARAMETRIC_SOFTPLUS_OPERATOR_DESC {}
306 unsafe impl ::windows::runtime::Abi for DML_ACTIVATION_PARAMETRIC_SOFTPLUS_OPERATOR_DESC {
307     type Abi = Self;
308     type DefaultType = Self;
309 }
310 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
311 #[repr(C)]
312 pub struct DML_ACTIVATION_RELU_GRAD_OPERATOR_DESC {
313     pub InputTensor: *mut DML_TENSOR_DESC,
314     pub InputGradientTensor: *mut DML_TENSOR_DESC,
315     pub OutputGradientTensor: *mut DML_TENSOR_DESC,
316 }
317 impl DML_ACTIVATION_RELU_GRAD_OPERATOR_DESC {}
318 impl ::std::default::Default for DML_ACTIVATION_RELU_GRAD_OPERATOR_DESC {
default() -> Self319     fn default() -> Self {
320         unsafe { ::std::mem::zeroed() }
321     }
322 }
323 impl ::std::fmt::Debug for DML_ACTIVATION_RELU_GRAD_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result324     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
325         fmt.debug_struct("DML_ACTIVATION_RELU_GRAD_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("InputGradientTensor", &self.InputGradientTensor).field("OutputGradientTensor", &self.OutputGradientTensor).finish()
326     }
327 }
328 impl ::std::cmp::PartialEq for DML_ACTIVATION_RELU_GRAD_OPERATOR_DESC {
eq(&self, other: &Self) -> bool329     fn eq(&self, other: &Self) -> bool {
330         self.InputTensor == other.InputTensor && self.InputGradientTensor == other.InputGradientTensor && self.OutputGradientTensor == other.OutputGradientTensor
331     }
332 }
333 impl ::std::cmp::Eq for DML_ACTIVATION_RELU_GRAD_OPERATOR_DESC {}
334 unsafe impl ::windows::runtime::Abi for DML_ACTIVATION_RELU_GRAD_OPERATOR_DESC {
335     type Abi = Self;
336     type DefaultType = Self;
337 }
338 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
339 #[repr(C)]
340 pub struct DML_ACTIVATION_RELU_OPERATOR_DESC {
341     pub InputTensor: *mut DML_TENSOR_DESC,
342     pub OutputTensor: *mut DML_TENSOR_DESC,
343 }
344 impl DML_ACTIVATION_RELU_OPERATOR_DESC {}
345 impl ::std::default::Default for DML_ACTIVATION_RELU_OPERATOR_DESC {
default() -> Self346     fn default() -> Self {
347         unsafe { ::std::mem::zeroed() }
348     }
349 }
350 impl ::std::fmt::Debug for DML_ACTIVATION_RELU_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result351     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
352         fmt.debug_struct("DML_ACTIVATION_RELU_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).finish()
353     }
354 }
355 impl ::std::cmp::PartialEq for DML_ACTIVATION_RELU_OPERATOR_DESC {
eq(&self, other: &Self) -> bool356     fn eq(&self, other: &Self) -> bool {
357         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor
358     }
359 }
360 impl ::std::cmp::Eq for DML_ACTIVATION_RELU_OPERATOR_DESC {}
361 unsafe impl ::windows::runtime::Abi for DML_ACTIVATION_RELU_OPERATOR_DESC {
362     type Abi = Self;
363     type DefaultType = Self;
364 }
365 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
366 #[repr(C)]
367 pub struct DML_ACTIVATION_SCALED_ELU_OPERATOR_DESC {
368     pub InputTensor: *mut DML_TENSOR_DESC,
369     pub OutputTensor: *mut DML_TENSOR_DESC,
370     pub Alpha: f32,
371     pub Gamma: f32,
372 }
373 impl DML_ACTIVATION_SCALED_ELU_OPERATOR_DESC {}
374 impl ::std::default::Default for DML_ACTIVATION_SCALED_ELU_OPERATOR_DESC {
default() -> Self375     fn default() -> Self {
376         unsafe { ::std::mem::zeroed() }
377     }
378 }
379 impl ::std::fmt::Debug for DML_ACTIVATION_SCALED_ELU_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result380     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
381         fmt.debug_struct("DML_ACTIVATION_SCALED_ELU_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("Alpha", &self.Alpha).field("Gamma", &self.Gamma).finish()
382     }
383 }
384 impl ::std::cmp::PartialEq for DML_ACTIVATION_SCALED_ELU_OPERATOR_DESC {
eq(&self, other: &Self) -> bool385     fn eq(&self, other: &Self) -> bool {
386         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.Alpha == other.Alpha && self.Gamma == other.Gamma
387     }
388 }
389 impl ::std::cmp::Eq for DML_ACTIVATION_SCALED_ELU_OPERATOR_DESC {}
390 unsafe impl ::windows::runtime::Abi for DML_ACTIVATION_SCALED_ELU_OPERATOR_DESC {
391     type Abi = Self;
392     type DefaultType = Self;
393 }
394 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
395 #[repr(C)]
396 pub struct DML_ACTIVATION_SCALED_TANH_OPERATOR_DESC {
397     pub InputTensor: *mut DML_TENSOR_DESC,
398     pub OutputTensor: *mut DML_TENSOR_DESC,
399     pub Alpha: f32,
400     pub Beta: f32,
401 }
402 impl DML_ACTIVATION_SCALED_TANH_OPERATOR_DESC {}
403 impl ::std::default::Default for DML_ACTIVATION_SCALED_TANH_OPERATOR_DESC {
default() -> Self404     fn default() -> Self {
405         unsafe { ::std::mem::zeroed() }
406     }
407 }
408 impl ::std::fmt::Debug for DML_ACTIVATION_SCALED_TANH_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result409     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
410         fmt.debug_struct("DML_ACTIVATION_SCALED_TANH_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("Alpha", &self.Alpha).field("Beta", &self.Beta).finish()
411     }
412 }
413 impl ::std::cmp::PartialEq for DML_ACTIVATION_SCALED_TANH_OPERATOR_DESC {
eq(&self, other: &Self) -> bool414     fn eq(&self, other: &Self) -> bool {
415         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.Alpha == other.Alpha && self.Beta == other.Beta
416     }
417 }
418 impl ::std::cmp::Eq for DML_ACTIVATION_SCALED_TANH_OPERATOR_DESC {}
419 unsafe impl ::windows::runtime::Abi for DML_ACTIVATION_SCALED_TANH_OPERATOR_DESC {
420     type Abi = Self;
421     type DefaultType = Self;
422 }
423 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
424 #[repr(C)]
425 pub struct DML_ACTIVATION_SHRINK_OPERATOR_DESC {
426     pub InputTensor: *mut DML_TENSOR_DESC,
427     pub OutputTensor: *mut DML_TENSOR_DESC,
428     pub Bias: f32,
429     pub Threshold: f32,
430 }
431 impl DML_ACTIVATION_SHRINK_OPERATOR_DESC {}
432 impl ::std::default::Default for DML_ACTIVATION_SHRINK_OPERATOR_DESC {
default() -> Self433     fn default() -> Self {
434         unsafe { ::std::mem::zeroed() }
435     }
436 }
437 impl ::std::fmt::Debug for DML_ACTIVATION_SHRINK_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result438     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
439         fmt.debug_struct("DML_ACTIVATION_SHRINK_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("Bias", &self.Bias).field("Threshold", &self.Threshold).finish()
440     }
441 }
442 impl ::std::cmp::PartialEq for DML_ACTIVATION_SHRINK_OPERATOR_DESC {
eq(&self, other: &Self) -> bool443     fn eq(&self, other: &Self) -> bool {
444         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.Bias == other.Bias && self.Threshold == other.Threshold
445     }
446 }
447 impl ::std::cmp::Eq for DML_ACTIVATION_SHRINK_OPERATOR_DESC {}
448 unsafe impl ::windows::runtime::Abi for DML_ACTIVATION_SHRINK_OPERATOR_DESC {
449     type Abi = Self;
450     type DefaultType = Self;
451 }
452 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
453 #[repr(C)]
454 pub struct DML_ACTIVATION_SIGMOID_OPERATOR_DESC {
455     pub InputTensor: *mut DML_TENSOR_DESC,
456     pub OutputTensor: *mut DML_TENSOR_DESC,
457 }
458 impl DML_ACTIVATION_SIGMOID_OPERATOR_DESC {}
459 impl ::std::default::Default for DML_ACTIVATION_SIGMOID_OPERATOR_DESC {
default() -> Self460     fn default() -> Self {
461         unsafe { ::std::mem::zeroed() }
462     }
463 }
464 impl ::std::fmt::Debug for DML_ACTIVATION_SIGMOID_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result465     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
466         fmt.debug_struct("DML_ACTIVATION_SIGMOID_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).finish()
467     }
468 }
469 impl ::std::cmp::PartialEq for DML_ACTIVATION_SIGMOID_OPERATOR_DESC {
eq(&self, other: &Self) -> bool470     fn eq(&self, other: &Self) -> bool {
471         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor
472     }
473 }
474 impl ::std::cmp::Eq for DML_ACTIVATION_SIGMOID_OPERATOR_DESC {}
475 unsafe impl ::windows::runtime::Abi for DML_ACTIVATION_SIGMOID_OPERATOR_DESC {
476     type Abi = Self;
477     type DefaultType = Self;
478 }
479 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
480 #[repr(C)]
481 pub struct DML_ACTIVATION_SOFTMAX_OPERATOR_DESC {
482     pub InputTensor: *mut DML_TENSOR_DESC,
483     pub OutputTensor: *mut DML_TENSOR_DESC,
484 }
485 impl DML_ACTIVATION_SOFTMAX_OPERATOR_DESC {}
486 impl ::std::default::Default for DML_ACTIVATION_SOFTMAX_OPERATOR_DESC {
default() -> Self487     fn default() -> Self {
488         unsafe { ::std::mem::zeroed() }
489     }
490 }
491 impl ::std::fmt::Debug for DML_ACTIVATION_SOFTMAX_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result492     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
493         fmt.debug_struct("DML_ACTIVATION_SOFTMAX_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).finish()
494     }
495 }
496 impl ::std::cmp::PartialEq for DML_ACTIVATION_SOFTMAX_OPERATOR_DESC {
eq(&self, other: &Self) -> bool497     fn eq(&self, other: &Self) -> bool {
498         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor
499     }
500 }
501 impl ::std::cmp::Eq for DML_ACTIVATION_SOFTMAX_OPERATOR_DESC {}
502 unsafe impl ::windows::runtime::Abi for DML_ACTIVATION_SOFTMAX_OPERATOR_DESC {
503     type Abi = Self;
504     type DefaultType = Self;
505 }
506 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
507 #[repr(C)]
508 pub struct DML_ACTIVATION_SOFTPLUS_OPERATOR_DESC {
509     pub InputTensor: *mut DML_TENSOR_DESC,
510     pub OutputTensor: *mut DML_TENSOR_DESC,
511     pub Steepness: f32,
512 }
513 impl DML_ACTIVATION_SOFTPLUS_OPERATOR_DESC {}
514 impl ::std::default::Default for DML_ACTIVATION_SOFTPLUS_OPERATOR_DESC {
default() -> Self515     fn default() -> Self {
516         unsafe { ::std::mem::zeroed() }
517     }
518 }
519 impl ::std::fmt::Debug for DML_ACTIVATION_SOFTPLUS_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result520     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
521         fmt.debug_struct("DML_ACTIVATION_SOFTPLUS_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("Steepness", &self.Steepness).finish()
522     }
523 }
524 impl ::std::cmp::PartialEq for DML_ACTIVATION_SOFTPLUS_OPERATOR_DESC {
eq(&self, other: &Self) -> bool525     fn eq(&self, other: &Self) -> bool {
526         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.Steepness == other.Steepness
527     }
528 }
529 impl ::std::cmp::Eq for DML_ACTIVATION_SOFTPLUS_OPERATOR_DESC {}
530 unsafe impl ::windows::runtime::Abi for DML_ACTIVATION_SOFTPLUS_OPERATOR_DESC {
531     type Abi = Self;
532     type DefaultType = Self;
533 }
534 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
535 #[repr(C)]
536 pub struct DML_ACTIVATION_SOFTSIGN_OPERATOR_DESC {
537     pub InputTensor: *mut DML_TENSOR_DESC,
538     pub OutputTensor: *mut DML_TENSOR_DESC,
539 }
540 impl DML_ACTIVATION_SOFTSIGN_OPERATOR_DESC {}
541 impl ::std::default::Default for DML_ACTIVATION_SOFTSIGN_OPERATOR_DESC {
default() -> Self542     fn default() -> Self {
543         unsafe { ::std::mem::zeroed() }
544     }
545 }
546 impl ::std::fmt::Debug for DML_ACTIVATION_SOFTSIGN_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result547     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
548         fmt.debug_struct("DML_ACTIVATION_SOFTSIGN_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).finish()
549     }
550 }
551 impl ::std::cmp::PartialEq for DML_ACTIVATION_SOFTSIGN_OPERATOR_DESC {
eq(&self, other: &Self) -> bool552     fn eq(&self, other: &Self) -> bool {
553         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor
554     }
555 }
556 impl ::std::cmp::Eq for DML_ACTIVATION_SOFTSIGN_OPERATOR_DESC {}
557 unsafe impl ::windows::runtime::Abi for DML_ACTIVATION_SOFTSIGN_OPERATOR_DESC {
558     type Abi = Self;
559     type DefaultType = Self;
560 }
561 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
562 #[repr(C)]
563 pub struct DML_ACTIVATION_TANH_OPERATOR_DESC {
564     pub InputTensor: *mut DML_TENSOR_DESC,
565     pub OutputTensor: *mut DML_TENSOR_DESC,
566 }
567 impl DML_ACTIVATION_TANH_OPERATOR_DESC {}
568 impl ::std::default::Default for DML_ACTIVATION_TANH_OPERATOR_DESC {
default() -> Self569     fn default() -> Self {
570         unsafe { ::std::mem::zeroed() }
571     }
572 }
573 impl ::std::fmt::Debug for DML_ACTIVATION_TANH_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result574     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
575         fmt.debug_struct("DML_ACTIVATION_TANH_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).finish()
576     }
577 }
578 impl ::std::cmp::PartialEq for DML_ACTIVATION_TANH_OPERATOR_DESC {
eq(&self, other: &Self) -> bool579     fn eq(&self, other: &Self) -> bool {
580         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor
581     }
582 }
583 impl ::std::cmp::Eq for DML_ACTIVATION_TANH_OPERATOR_DESC {}
584 unsafe impl ::windows::runtime::Abi for DML_ACTIVATION_TANH_OPERATOR_DESC {
585     type Abi = Self;
586     type DefaultType = Self;
587 }
588 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
589 #[repr(C)]
590 pub struct DML_ACTIVATION_THRESHOLDED_RELU_OPERATOR_DESC {
591     pub InputTensor: *mut DML_TENSOR_DESC,
592     pub OutputTensor: *mut DML_TENSOR_DESC,
593     pub Alpha: f32,
594 }
595 impl DML_ACTIVATION_THRESHOLDED_RELU_OPERATOR_DESC {}
596 impl ::std::default::Default for DML_ACTIVATION_THRESHOLDED_RELU_OPERATOR_DESC {
default() -> Self597     fn default() -> Self {
598         unsafe { ::std::mem::zeroed() }
599     }
600 }
601 impl ::std::fmt::Debug for DML_ACTIVATION_THRESHOLDED_RELU_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result602     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
603         fmt.debug_struct("DML_ACTIVATION_THRESHOLDED_RELU_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("Alpha", &self.Alpha).finish()
604     }
605 }
606 impl ::std::cmp::PartialEq for DML_ACTIVATION_THRESHOLDED_RELU_OPERATOR_DESC {
eq(&self, other: &Self) -> bool607     fn eq(&self, other: &Self) -> bool {
608         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.Alpha == other.Alpha
609     }
610 }
611 impl ::std::cmp::Eq for DML_ACTIVATION_THRESHOLDED_RELU_OPERATOR_DESC {}
612 unsafe impl ::windows::runtime::Abi for DML_ACTIVATION_THRESHOLDED_RELU_OPERATOR_DESC {
613     type Abi = Self;
614     type DefaultType = Self;
615 }
616 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
617 #[repr(C)]
618 pub struct DML_ADAM_OPTIMIZER_OPERATOR_DESC {
619     pub InputParametersTensor: *mut DML_TENSOR_DESC,
620     pub InputFirstMomentTensor: *mut DML_TENSOR_DESC,
621     pub InputSecondMomentTensor: *mut DML_TENSOR_DESC,
622     pub GradientTensor: *mut DML_TENSOR_DESC,
623     pub TrainingStepTensor: *mut DML_TENSOR_DESC,
624     pub OutputParametersTensor: *mut DML_TENSOR_DESC,
625     pub OutputFirstMomentTensor: *mut DML_TENSOR_DESC,
626     pub OutputSecondMomentTensor: *mut DML_TENSOR_DESC,
627     pub LearningRate: f32,
628     pub Beta1: f32,
629     pub Beta2: f32,
630     pub Epsilon: f32,
631 }
632 impl DML_ADAM_OPTIMIZER_OPERATOR_DESC {}
633 impl ::std::default::Default for DML_ADAM_OPTIMIZER_OPERATOR_DESC {
default() -> Self634     fn default() -> Self {
635         unsafe { ::std::mem::zeroed() }
636     }
637 }
638 impl ::std::fmt::Debug for DML_ADAM_OPTIMIZER_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result639     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
640         fmt.debug_struct("DML_ADAM_OPTIMIZER_OPERATOR_DESC")
641             .field("InputParametersTensor", &self.InputParametersTensor)
642             .field("InputFirstMomentTensor", &self.InputFirstMomentTensor)
643             .field("InputSecondMomentTensor", &self.InputSecondMomentTensor)
644             .field("GradientTensor", &self.GradientTensor)
645             .field("TrainingStepTensor", &self.TrainingStepTensor)
646             .field("OutputParametersTensor", &self.OutputParametersTensor)
647             .field("OutputFirstMomentTensor", &self.OutputFirstMomentTensor)
648             .field("OutputSecondMomentTensor", &self.OutputSecondMomentTensor)
649             .field("LearningRate", &self.LearningRate)
650             .field("Beta1", &self.Beta1)
651             .field("Beta2", &self.Beta2)
652             .field("Epsilon", &self.Epsilon)
653             .finish()
654     }
655 }
656 impl ::std::cmp::PartialEq for DML_ADAM_OPTIMIZER_OPERATOR_DESC {
eq(&self, other: &Self) -> bool657     fn eq(&self, other: &Self) -> bool {
658         self.InputParametersTensor == other.InputParametersTensor
659             && self.InputFirstMomentTensor == other.InputFirstMomentTensor
660             && self.InputSecondMomentTensor == other.InputSecondMomentTensor
661             && self.GradientTensor == other.GradientTensor
662             && self.TrainingStepTensor == other.TrainingStepTensor
663             && self.OutputParametersTensor == other.OutputParametersTensor
664             && self.OutputFirstMomentTensor == other.OutputFirstMomentTensor
665             && self.OutputSecondMomentTensor == other.OutputSecondMomentTensor
666             && self.LearningRate == other.LearningRate
667             && self.Beta1 == other.Beta1
668             && self.Beta2 == other.Beta2
669             && self.Epsilon == other.Epsilon
670     }
671 }
672 impl ::std::cmp::Eq for DML_ADAM_OPTIMIZER_OPERATOR_DESC {}
673 unsafe impl ::windows::runtime::Abi for DML_ADAM_OPTIMIZER_OPERATOR_DESC {
674     type Abi = Self;
675     type DefaultType = Self;
676 }
677 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
678 #[repr(C)]
679 pub struct DML_ARGMAX_OPERATOR_DESC {
680     pub InputTensor: *mut DML_TENSOR_DESC,
681     pub OutputTensor: *mut DML_TENSOR_DESC,
682     pub AxisCount: u32,
683     pub Axes: *mut u32,
684     pub AxisDirection: DML_AXIS_DIRECTION,
685 }
686 impl DML_ARGMAX_OPERATOR_DESC {}
687 impl ::std::default::Default for DML_ARGMAX_OPERATOR_DESC {
default() -> Self688     fn default() -> Self {
689         unsafe { ::std::mem::zeroed() }
690     }
691 }
692 impl ::std::fmt::Debug for DML_ARGMAX_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result693     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
694         fmt.debug_struct("DML_ARGMAX_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("AxisCount", &self.AxisCount).field("Axes", &self.Axes).field("AxisDirection", &self.AxisDirection).finish()
695     }
696 }
697 impl ::std::cmp::PartialEq for DML_ARGMAX_OPERATOR_DESC {
eq(&self, other: &Self) -> bool698     fn eq(&self, other: &Self) -> bool {
699         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.AxisCount == other.AxisCount && self.Axes == other.Axes && self.AxisDirection == other.AxisDirection
700     }
701 }
702 impl ::std::cmp::Eq for DML_ARGMAX_OPERATOR_DESC {}
703 unsafe impl ::windows::runtime::Abi for DML_ARGMAX_OPERATOR_DESC {
704     type Abi = Self;
705     type DefaultType = Self;
706 }
707 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
708 #[repr(C)]
709 pub struct DML_ARGMIN_OPERATOR_DESC {
710     pub InputTensor: *mut DML_TENSOR_DESC,
711     pub OutputTensor: *mut DML_TENSOR_DESC,
712     pub AxisCount: u32,
713     pub Axes: *mut u32,
714     pub AxisDirection: DML_AXIS_DIRECTION,
715 }
716 impl DML_ARGMIN_OPERATOR_DESC {}
717 impl ::std::default::Default for DML_ARGMIN_OPERATOR_DESC {
default() -> Self718     fn default() -> Self {
719         unsafe { ::std::mem::zeroed() }
720     }
721 }
722 impl ::std::fmt::Debug for DML_ARGMIN_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result723     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
724         fmt.debug_struct("DML_ARGMIN_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("AxisCount", &self.AxisCount).field("Axes", &self.Axes).field("AxisDirection", &self.AxisDirection).finish()
725     }
726 }
727 impl ::std::cmp::PartialEq for DML_ARGMIN_OPERATOR_DESC {
eq(&self, other: &Self) -> bool728     fn eq(&self, other: &Self) -> bool {
729         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.AxisCount == other.AxisCount && self.Axes == other.Axes && self.AxisDirection == other.AxisDirection
730     }
731 }
732 impl ::std::cmp::Eq for DML_ARGMIN_OPERATOR_DESC {}
733 unsafe impl ::windows::runtime::Abi for DML_ARGMIN_OPERATOR_DESC {
734     type Abi = Self;
735     type DefaultType = Self;
736 }
737 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
738 #[repr(C)]
739 #[cfg(feature = "Win32_Foundation")]
740 pub struct DML_AVERAGE_POOLING_GRAD_OPERATOR_DESC {
741     pub InputGradientTensor: *mut DML_TENSOR_DESC,
742     pub OutputGradientTensor: *mut DML_TENSOR_DESC,
743     pub DimensionCount: u32,
744     pub Strides: *mut u32,
745     pub WindowSize: *mut u32,
746     pub StartPadding: *mut u32,
747     pub EndPadding: *mut u32,
748     pub IncludePadding: super::super::super::Foundation::BOOL,
749 }
750 #[cfg(feature = "Win32_Foundation")]
751 impl DML_AVERAGE_POOLING_GRAD_OPERATOR_DESC {}
752 #[cfg(feature = "Win32_Foundation")]
753 impl ::std::default::Default for DML_AVERAGE_POOLING_GRAD_OPERATOR_DESC {
default() -> Self754     fn default() -> Self {
755         unsafe { ::std::mem::zeroed() }
756     }
757 }
758 #[cfg(feature = "Win32_Foundation")]
759 impl ::std::fmt::Debug for DML_AVERAGE_POOLING_GRAD_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result760     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
761         fmt.debug_struct("DML_AVERAGE_POOLING_GRAD_OPERATOR_DESC")
762             .field("InputGradientTensor", &self.InputGradientTensor)
763             .field("OutputGradientTensor", &self.OutputGradientTensor)
764             .field("DimensionCount", &self.DimensionCount)
765             .field("Strides", &self.Strides)
766             .field("WindowSize", &self.WindowSize)
767             .field("StartPadding", &self.StartPadding)
768             .field("EndPadding", &self.EndPadding)
769             .field("IncludePadding", &self.IncludePadding)
770             .finish()
771     }
772 }
773 #[cfg(feature = "Win32_Foundation")]
774 impl ::std::cmp::PartialEq for DML_AVERAGE_POOLING_GRAD_OPERATOR_DESC {
eq(&self, other: &Self) -> bool775     fn eq(&self, other: &Self) -> bool {
776         self.InputGradientTensor == other.InputGradientTensor && self.OutputGradientTensor == other.OutputGradientTensor && self.DimensionCount == other.DimensionCount && self.Strides == other.Strides && self.WindowSize == other.WindowSize && self.StartPadding == other.StartPadding && self.EndPadding == other.EndPadding && self.IncludePadding == other.IncludePadding
777     }
778 }
779 #[cfg(feature = "Win32_Foundation")]
780 impl ::std::cmp::Eq for DML_AVERAGE_POOLING_GRAD_OPERATOR_DESC {}
781 #[cfg(feature = "Win32_Foundation")]
782 unsafe impl ::windows::runtime::Abi for DML_AVERAGE_POOLING_GRAD_OPERATOR_DESC {
783     type Abi = Self;
784     type DefaultType = Self;
785 }
786 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
787 #[repr(C)]
788 #[cfg(feature = "Win32_Foundation")]
789 pub struct DML_AVERAGE_POOLING_OPERATOR_DESC {
790     pub InputTensor: *mut DML_TENSOR_DESC,
791     pub OutputTensor: *mut DML_TENSOR_DESC,
792     pub DimensionCount: u32,
793     pub Strides: *mut u32,
794     pub WindowSize: *mut u32,
795     pub StartPadding: *mut u32,
796     pub EndPadding: *mut u32,
797     pub IncludePadding: super::super::super::Foundation::BOOL,
798 }
799 #[cfg(feature = "Win32_Foundation")]
800 impl DML_AVERAGE_POOLING_OPERATOR_DESC {}
801 #[cfg(feature = "Win32_Foundation")]
802 impl ::std::default::Default for DML_AVERAGE_POOLING_OPERATOR_DESC {
default() -> Self803     fn default() -> Self {
804         unsafe { ::std::mem::zeroed() }
805     }
806 }
807 #[cfg(feature = "Win32_Foundation")]
808 impl ::std::fmt::Debug for DML_AVERAGE_POOLING_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result809     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
810         fmt.debug_struct("DML_AVERAGE_POOLING_OPERATOR_DESC")
811             .field("InputTensor", &self.InputTensor)
812             .field("OutputTensor", &self.OutputTensor)
813             .field("DimensionCount", &self.DimensionCount)
814             .field("Strides", &self.Strides)
815             .field("WindowSize", &self.WindowSize)
816             .field("StartPadding", &self.StartPadding)
817             .field("EndPadding", &self.EndPadding)
818             .field("IncludePadding", &self.IncludePadding)
819             .finish()
820     }
821 }
822 #[cfg(feature = "Win32_Foundation")]
823 impl ::std::cmp::PartialEq for DML_AVERAGE_POOLING_OPERATOR_DESC {
eq(&self, other: &Self) -> bool824     fn eq(&self, other: &Self) -> bool {
825         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.DimensionCount == other.DimensionCount && self.Strides == other.Strides && self.WindowSize == other.WindowSize && self.StartPadding == other.StartPadding && self.EndPadding == other.EndPadding && self.IncludePadding == other.IncludePadding
826     }
827 }
828 #[cfg(feature = "Win32_Foundation")]
829 impl ::std::cmp::Eq for DML_AVERAGE_POOLING_OPERATOR_DESC {}
830 #[cfg(feature = "Win32_Foundation")]
831 unsafe impl ::windows::runtime::Abi for DML_AVERAGE_POOLING_OPERATOR_DESC {
832     type Abi = Self;
833     type DefaultType = Self;
834 }
835 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
836 #[repr(transparent)]
837 pub struct DML_AXIS_DIRECTION(pub i32);
838 pub const DML_AXIS_DIRECTION_INCREASING: DML_AXIS_DIRECTION = DML_AXIS_DIRECTION(0i32);
839 pub const DML_AXIS_DIRECTION_DECREASING: DML_AXIS_DIRECTION = DML_AXIS_DIRECTION(1i32);
840 impl ::std::convert::From<i32> for DML_AXIS_DIRECTION {
from(value: i32) -> Self841     fn from(value: i32) -> Self {
842         Self(value)
843     }
844 }
845 unsafe impl ::windows::runtime::Abi for DML_AXIS_DIRECTION {
846     type Abi = Self;
847     type DefaultType = Self;
848 }
849 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
850 #[repr(C)]
851 pub struct DML_BATCH_NORMALIZATION_GRAD_OPERATOR_DESC {
852     pub InputTensor: *mut DML_TENSOR_DESC,
853     pub InputGradientTensor: *mut DML_TENSOR_DESC,
854     pub MeanTensor: *mut DML_TENSOR_DESC,
855     pub VarianceTensor: *mut DML_TENSOR_DESC,
856     pub ScaleTensor: *mut DML_TENSOR_DESC,
857     pub OutputGradientTensor: *mut DML_TENSOR_DESC,
858     pub OutputScaleGradientTensor: *mut DML_TENSOR_DESC,
859     pub OutputBiasGradientTensor: *mut DML_TENSOR_DESC,
860     pub Epsilon: f32,
861 }
862 impl DML_BATCH_NORMALIZATION_GRAD_OPERATOR_DESC {}
863 impl ::std::default::Default for DML_BATCH_NORMALIZATION_GRAD_OPERATOR_DESC {
default() -> Self864     fn default() -> Self {
865         unsafe { ::std::mem::zeroed() }
866     }
867 }
868 impl ::std::fmt::Debug for DML_BATCH_NORMALIZATION_GRAD_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result869     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
870         fmt.debug_struct("DML_BATCH_NORMALIZATION_GRAD_OPERATOR_DESC")
871             .field("InputTensor", &self.InputTensor)
872             .field("InputGradientTensor", &self.InputGradientTensor)
873             .field("MeanTensor", &self.MeanTensor)
874             .field("VarianceTensor", &self.VarianceTensor)
875             .field("ScaleTensor", &self.ScaleTensor)
876             .field("OutputGradientTensor", &self.OutputGradientTensor)
877             .field("OutputScaleGradientTensor", &self.OutputScaleGradientTensor)
878             .field("OutputBiasGradientTensor", &self.OutputBiasGradientTensor)
879             .field("Epsilon", &self.Epsilon)
880             .finish()
881     }
882 }
883 impl ::std::cmp::PartialEq for DML_BATCH_NORMALIZATION_GRAD_OPERATOR_DESC {
eq(&self, other: &Self) -> bool884     fn eq(&self, other: &Self) -> bool {
885         self.InputTensor == other.InputTensor && self.InputGradientTensor == other.InputGradientTensor && self.MeanTensor == other.MeanTensor && self.VarianceTensor == other.VarianceTensor && self.ScaleTensor == other.ScaleTensor && self.OutputGradientTensor == other.OutputGradientTensor && self.OutputScaleGradientTensor == other.OutputScaleGradientTensor && self.OutputBiasGradientTensor == other.OutputBiasGradientTensor && self.Epsilon == other.Epsilon
886     }
887 }
888 impl ::std::cmp::Eq for DML_BATCH_NORMALIZATION_GRAD_OPERATOR_DESC {}
889 unsafe impl ::windows::runtime::Abi for DML_BATCH_NORMALIZATION_GRAD_OPERATOR_DESC {
890     type Abi = Self;
891     type DefaultType = Self;
892 }
893 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
894 #[repr(C)]
895 #[cfg(feature = "Win32_Foundation")]
896 pub struct DML_BATCH_NORMALIZATION_OPERATOR_DESC {
897     pub InputTensor: *mut DML_TENSOR_DESC,
898     pub MeanTensor: *mut DML_TENSOR_DESC,
899     pub VarianceTensor: *mut DML_TENSOR_DESC,
900     pub ScaleTensor: *mut DML_TENSOR_DESC,
901     pub BiasTensor: *mut DML_TENSOR_DESC,
902     pub OutputTensor: *mut DML_TENSOR_DESC,
903     pub Spatial: super::super::super::Foundation::BOOL,
904     pub Epsilon: f32,
905     pub FusedActivation: *mut DML_OPERATOR_DESC,
906 }
907 #[cfg(feature = "Win32_Foundation")]
908 impl DML_BATCH_NORMALIZATION_OPERATOR_DESC {}
909 #[cfg(feature = "Win32_Foundation")]
910 impl ::std::default::Default for DML_BATCH_NORMALIZATION_OPERATOR_DESC {
default() -> Self911     fn default() -> Self {
912         unsafe { ::std::mem::zeroed() }
913     }
914 }
915 #[cfg(feature = "Win32_Foundation")]
916 impl ::std::fmt::Debug for DML_BATCH_NORMALIZATION_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result917     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
918         fmt.debug_struct("DML_BATCH_NORMALIZATION_OPERATOR_DESC")
919             .field("InputTensor", &self.InputTensor)
920             .field("MeanTensor", &self.MeanTensor)
921             .field("VarianceTensor", &self.VarianceTensor)
922             .field("ScaleTensor", &self.ScaleTensor)
923             .field("BiasTensor", &self.BiasTensor)
924             .field("OutputTensor", &self.OutputTensor)
925             .field("Spatial", &self.Spatial)
926             .field("Epsilon", &self.Epsilon)
927             .field("FusedActivation", &self.FusedActivation)
928             .finish()
929     }
930 }
931 #[cfg(feature = "Win32_Foundation")]
932 impl ::std::cmp::PartialEq for DML_BATCH_NORMALIZATION_OPERATOR_DESC {
eq(&self, other: &Self) -> bool933     fn eq(&self, other: &Self) -> bool {
934         self.InputTensor == other.InputTensor && self.MeanTensor == other.MeanTensor && self.VarianceTensor == other.VarianceTensor && self.ScaleTensor == other.ScaleTensor && self.BiasTensor == other.BiasTensor && self.OutputTensor == other.OutputTensor && self.Spatial == other.Spatial && self.Epsilon == other.Epsilon && self.FusedActivation == other.FusedActivation
935     }
936 }
937 #[cfg(feature = "Win32_Foundation")]
938 impl ::std::cmp::Eq for DML_BATCH_NORMALIZATION_OPERATOR_DESC {}
939 #[cfg(feature = "Win32_Foundation")]
940 unsafe impl ::windows::runtime::Abi for DML_BATCH_NORMALIZATION_OPERATOR_DESC {
941     type Abi = Self;
942     type DefaultType = Self;
943 }
944 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
945 #[repr(C)]
946 pub struct DML_BINDING_DESC {
947     pub Type: DML_BINDING_TYPE,
948     pub Desc: *mut ::std::ffi::c_void,
949 }
950 impl DML_BINDING_DESC {}
951 impl ::std::default::Default for DML_BINDING_DESC {
default() -> Self952     fn default() -> Self {
953         unsafe { ::std::mem::zeroed() }
954     }
955 }
956 impl ::std::fmt::Debug for DML_BINDING_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result957     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
958         fmt.debug_struct("DML_BINDING_DESC").field("Type", &self.Type).field("Desc", &self.Desc).finish()
959     }
960 }
961 impl ::std::cmp::PartialEq for DML_BINDING_DESC {
eq(&self, other: &Self) -> bool962     fn eq(&self, other: &Self) -> bool {
963         self.Type == other.Type && self.Desc == other.Desc
964     }
965 }
966 impl ::std::cmp::Eq for DML_BINDING_DESC {}
967 unsafe impl ::windows::runtime::Abi for DML_BINDING_DESC {
968     type Abi = Self;
969     type DefaultType = Self;
970 }
971 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
972 #[repr(C)]
973 pub struct DML_BINDING_PROPERTIES {
974     pub RequiredDescriptorCount: u32,
975     pub TemporaryResourceSize: u64,
976     pub PersistentResourceSize: u64,
977 }
978 impl DML_BINDING_PROPERTIES {}
979 impl ::std::default::Default for DML_BINDING_PROPERTIES {
default() -> Self980     fn default() -> Self {
981         unsafe { ::std::mem::zeroed() }
982     }
983 }
984 impl ::std::fmt::Debug for DML_BINDING_PROPERTIES {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result985     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
986         fmt.debug_struct("DML_BINDING_PROPERTIES").field("RequiredDescriptorCount", &self.RequiredDescriptorCount).field("TemporaryResourceSize", &self.TemporaryResourceSize).field("PersistentResourceSize", &self.PersistentResourceSize).finish()
987     }
988 }
989 impl ::std::cmp::PartialEq for DML_BINDING_PROPERTIES {
eq(&self, other: &Self) -> bool990     fn eq(&self, other: &Self) -> bool {
991         self.RequiredDescriptorCount == other.RequiredDescriptorCount && self.TemporaryResourceSize == other.TemporaryResourceSize && self.PersistentResourceSize == other.PersistentResourceSize
992     }
993 }
994 impl ::std::cmp::Eq for DML_BINDING_PROPERTIES {}
995 unsafe impl ::windows::runtime::Abi for DML_BINDING_PROPERTIES {
996     type Abi = Self;
997     type DefaultType = Self;
998 }
999 #[derive(:: std :: clone :: Clone)]
1000 #[repr(C)]
1001 #[cfg(feature = "Win32_Graphics_Direct3D12")]
1002 pub struct DML_BINDING_TABLE_DESC {
1003     pub Dispatchable: ::std::option::Option<IDMLDispatchable>,
1004     pub CPUDescriptorHandle: super::super::super::Graphics::Direct3D12::D3D12_CPU_DESCRIPTOR_HANDLE,
1005     pub GPUDescriptorHandle: super::super::super::Graphics::Direct3D12::D3D12_GPU_DESCRIPTOR_HANDLE,
1006     pub SizeInDescriptors: u32,
1007 }
1008 #[cfg(feature = "Win32_Graphics_Direct3D12")]
1009 impl DML_BINDING_TABLE_DESC {}
1010 #[cfg(feature = "Win32_Graphics_Direct3D12")]
1011 impl ::std::default::Default for DML_BINDING_TABLE_DESC {
default() -> Self1012     fn default() -> Self {
1013         unsafe { ::std::mem::zeroed() }
1014     }
1015 }
1016 #[cfg(feature = "Win32_Graphics_Direct3D12")]
1017 impl ::std::fmt::Debug for DML_BINDING_TABLE_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1018     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1019         fmt.debug_struct("DML_BINDING_TABLE_DESC").field("Dispatchable", &self.Dispatchable).field("CPUDescriptorHandle", &self.CPUDescriptorHandle).field("GPUDescriptorHandle", &self.GPUDescriptorHandle).field("SizeInDescriptors", &self.SizeInDescriptors).finish()
1020     }
1021 }
1022 #[cfg(feature = "Win32_Graphics_Direct3D12")]
1023 impl ::std::cmp::PartialEq for DML_BINDING_TABLE_DESC {
eq(&self, other: &Self) -> bool1024     fn eq(&self, other: &Self) -> bool {
1025         self.Dispatchable == other.Dispatchable && self.CPUDescriptorHandle == other.CPUDescriptorHandle && self.GPUDescriptorHandle == other.GPUDescriptorHandle && self.SizeInDescriptors == other.SizeInDescriptors
1026     }
1027 }
1028 #[cfg(feature = "Win32_Graphics_Direct3D12")]
1029 impl ::std::cmp::Eq for DML_BINDING_TABLE_DESC {}
1030 #[cfg(feature = "Win32_Graphics_Direct3D12")]
1031 unsafe impl ::windows::runtime::Abi for DML_BINDING_TABLE_DESC {
1032     type Abi = ::std::mem::ManuallyDrop<Self>;
1033     type DefaultType = Self;
1034 }
1035 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1036 #[repr(transparent)]
1037 pub struct DML_BINDING_TYPE(pub i32);
1038 pub const DML_BINDING_TYPE_NONE: DML_BINDING_TYPE = DML_BINDING_TYPE(0i32);
1039 pub const DML_BINDING_TYPE_BUFFER: DML_BINDING_TYPE = DML_BINDING_TYPE(1i32);
1040 pub const DML_BINDING_TYPE_BUFFER_ARRAY: DML_BINDING_TYPE = DML_BINDING_TYPE(2i32);
1041 impl ::std::convert::From<i32> for DML_BINDING_TYPE {
from(value: i32) -> Self1042     fn from(value: i32) -> Self {
1043         Self(value)
1044     }
1045 }
1046 unsafe impl ::windows::runtime::Abi for DML_BINDING_TYPE {
1047     type Abi = Self;
1048     type DefaultType = Self;
1049 }
1050 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1051 #[repr(C)]
1052 #[cfg(feature = "Win32_Graphics_Direct3D12")]
1053 pub struct DML_BUFFER_ARRAY_BINDING {
1054     pub BindingCount: u32,
1055     pub Bindings: *mut DML_BUFFER_BINDING,
1056 }
1057 #[cfg(feature = "Win32_Graphics_Direct3D12")]
1058 impl DML_BUFFER_ARRAY_BINDING {}
1059 #[cfg(feature = "Win32_Graphics_Direct3D12")]
1060 impl ::std::default::Default for DML_BUFFER_ARRAY_BINDING {
default() -> Self1061     fn default() -> Self {
1062         unsafe { ::std::mem::zeroed() }
1063     }
1064 }
1065 #[cfg(feature = "Win32_Graphics_Direct3D12")]
1066 impl ::std::fmt::Debug for DML_BUFFER_ARRAY_BINDING {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1067     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1068         fmt.debug_struct("DML_BUFFER_ARRAY_BINDING").field("BindingCount", &self.BindingCount).field("Bindings", &self.Bindings).finish()
1069     }
1070 }
1071 #[cfg(feature = "Win32_Graphics_Direct3D12")]
1072 impl ::std::cmp::PartialEq for DML_BUFFER_ARRAY_BINDING {
eq(&self, other: &Self) -> bool1073     fn eq(&self, other: &Self) -> bool {
1074         self.BindingCount == other.BindingCount && self.Bindings == other.Bindings
1075     }
1076 }
1077 #[cfg(feature = "Win32_Graphics_Direct3D12")]
1078 impl ::std::cmp::Eq for DML_BUFFER_ARRAY_BINDING {}
1079 #[cfg(feature = "Win32_Graphics_Direct3D12")]
1080 unsafe impl ::windows::runtime::Abi for DML_BUFFER_ARRAY_BINDING {
1081     type Abi = Self;
1082     type DefaultType = Self;
1083 }
1084 #[derive(:: std :: clone :: Clone)]
1085 #[repr(C)]
1086 #[cfg(feature = "Win32_Graphics_Direct3D12")]
1087 pub struct DML_BUFFER_BINDING {
1088     pub Buffer: ::std::option::Option<super::super::super::Graphics::Direct3D12::ID3D12Resource>,
1089     pub Offset: u64,
1090     pub SizeInBytes: u64,
1091 }
1092 #[cfg(feature = "Win32_Graphics_Direct3D12")]
1093 impl DML_BUFFER_BINDING {}
1094 #[cfg(feature = "Win32_Graphics_Direct3D12")]
1095 impl ::std::default::Default for DML_BUFFER_BINDING {
default() -> Self1096     fn default() -> Self {
1097         unsafe { ::std::mem::zeroed() }
1098     }
1099 }
1100 #[cfg(feature = "Win32_Graphics_Direct3D12")]
1101 impl ::std::fmt::Debug for DML_BUFFER_BINDING {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1102     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1103         fmt.debug_struct("DML_BUFFER_BINDING").field("Buffer", &self.Buffer).field("Offset", &self.Offset).field("SizeInBytes", &self.SizeInBytes).finish()
1104     }
1105 }
1106 #[cfg(feature = "Win32_Graphics_Direct3D12")]
1107 impl ::std::cmp::PartialEq for DML_BUFFER_BINDING {
eq(&self, other: &Self) -> bool1108     fn eq(&self, other: &Self) -> bool {
1109         self.Buffer == other.Buffer && self.Offset == other.Offset && self.SizeInBytes == other.SizeInBytes
1110     }
1111 }
1112 #[cfg(feature = "Win32_Graphics_Direct3D12")]
1113 impl ::std::cmp::Eq for DML_BUFFER_BINDING {}
1114 #[cfg(feature = "Win32_Graphics_Direct3D12")]
1115 unsafe impl ::windows::runtime::Abi for DML_BUFFER_BINDING {
1116     type Abi = ::std::mem::ManuallyDrop<Self>;
1117     type DefaultType = Self;
1118 }
1119 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1120 #[repr(C)]
1121 pub struct DML_BUFFER_TENSOR_DESC {
1122     pub DataType: DML_TENSOR_DATA_TYPE,
1123     pub Flags: DML_TENSOR_FLAGS,
1124     pub DimensionCount: u32,
1125     pub Sizes: *mut u32,
1126     pub Strides: *mut u32,
1127     pub TotalTensorSizeInBytes: u64,
1128     pub GuaranteedBaseOffsetAlignment: u32,
1129 }
1130 impl DML_BUFFER_TENSOR_DESC {}
1131 impl ::std::default::Default for DML_BUFFER_TENSOR_DESC {
default() -> Self1132     fn default() -> Self {
1133         unsafe { ::std::mem::zeroed() }
1134     }
1135 }
1136 impl ::std::fmt::Debug for DML_BUFFER_TENSOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1137     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1138         fmt.debug_struct("DML_BUFFER_TENSOR_DESC")
1139             .field("DataType", &self.DataType)
1140             .field("Flags", &self.Flags)
1141             .field("DimensionCount", &self.DimensionCount)
1142             .field("Sizes", &self.Sizes)
1143             .field("Strides", &self.Strides)
1144             .field("TotalTensorSizeInBytes", &self.TotalTensorSizeInBytes)
1145             .field("GuaranteedBaseOffsetAlignment", &self.GuaranteedBaseOffsetAlignment)
1146             .finish()
1147     }
1148 }
1149 impl ::std::cmp::PartialEq for DML_BUFFER_TENSOR_DESC {
eq(&self, other: &Self) -> bool1150     fn eq(&self, other: &Self) -> bool {
1151         self.DataType == other.DataType && self.Flags == other.Flags && self.DimensionCount == other.DimensionCount && self.Sizes == other.Sizes && self.Strides == other.Strides && self.TotalTensorSizeInBytes == other.TotalTensorSizeInBytes && self.GuaranteedBaseOffsetAlignment == other.GuaranteedBaseOffsetAlignment
1152     }
1153 }
1154 impl ::std::cmp::Eq for DML_BUFFER_TENSOR_DESC {}
1155 unsafe impl ::windows::runtime::Abi for DML_BUFFER_TENSOR_DESC {
1156     type Abi = Self;
1157     type DefaultType = Self;
1158 }
1159 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1160 #[repr(C)]
1161 pub struct DML_CAST_OPERATOR_DESC {
1162     pub InputTensor: *mut DML_TENSOR_DESC,
1163     pub OutputTensor: *mut DML_TENSOR_DESC,
1164 }
1165 impl DML_CAST_OPERATOR_DESC {}
1166 impl ::std::default::Default for DML_CAST_OPERATOR_DESC {
default() -> Self1167     fn default() -> Self {
1168         unsafe { ::std::mem::zeroed() }
1169     }
1170 }
1171 impl ::std::fmt::Debug for DML_CAST_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1172     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1173         fmt.debug_struct("DML_CAST_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).finish()
1174     }
1175 }
1176 impl ::std::cmp::PartialEq for DML_CAST_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1177     fn eq(&self, other: &Self) -> bool {
1178         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor
1179     }
1180 }
1181 impl ::std::cmp::Eq for DML_CAST_OPERATOR_DESC {}
1182 unsafe impl ::windows::runtime::Abi for DML_CAST_OPERATOR_DESC {
1183     type Abi = Self;
1184     type DefaultType = Self;
1185 }
1186 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1187 #[repr(transparent)]
1188 pub struct DML_CONVOLUTION_DIRECTION(pub i32);
1189 pub const DML_CONVOLUTION_DIRECTION_FORWARD: DML_CONVOLUTION_DIRECTION = DML_CONVOLUTION_DIRECTION(0i32);
1190 pub const DML_CONVOLUTION_DIRECTION_BACKWARD: DML_CONVOLUTION_DIRECTION = DML_CONVOLUTION_DIRECTION(1i32);
1191 impl ::std::convert::From<i32> for DML_CONVOLUTION_DIRECTION {
from(value: i32) -> Self1192     fn from(value: i32) -> Self {
1193         Self(value)
1194     }
1195 }
1196 unsafe impl ::windows::runtime::Abi for DML_CONVOLUTION_DIRECTION {
1197     type Abi = Self;
1198     type DefaultType = Self;
1199 }
1200 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1201 #[repr(C)]
1202 pub struct DML_CONVOLUTION_INTEGER_OPERATOR_DESC {
1203     pub InputTensor: *mut DML_TENSOR_DESC,
1204     pub InputZeroPointTensor: *mut DML_TENSOR_DESC,
1205     pub FilterTensor: *mut DML_TENSOR_DESC,
1206     pub FilterZeroPointTensor: *mut DML_TENSOR_DESC,
1207     pub OutputTensor: *mut DML_TENSOR_DESC,
1208     pub DimensionCount: u32,
1209     pub Strides: *mut u32,
1210     pub Dilations: *mut u32,
1211     pub StartPadding: *mut u32,
1212     pub EndPadding: *mut u32,
1213     pub GroupCount: u32,
1214 }
1215 impl DML_CONVOLUTION_INTEGER_OPERATOR_DESC {}
1216 impl ::std::default::Default for DML_CONVOLUTION_INTEGER_OPERATOR_DESC {
default() -> Self1217     fn default() -> Self {
1218         unsafe { ::std::mem::zeroed() }
1219     }
1220 }
1221 impl ::std::fmt::Debug for DML_CONVOLUTION_INTEGER_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1222     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1223         fmt.debug_struct("DML_CONVOLUTION_INTEGER_OPERATOR_DESC")
1224             .field("InputTensor", &self.InputTensor)
1225             .field("InputZeroPointTensor", &self.InputZeroPointTensor)
1226             .field("FilterTensor", &self.FilterTensor)
1227             .field("FilterZeroPointTensor", &self.FilterZeroPointTensor)
1228             .field("OutputTensor", &self.OutputTensor)
1229             .field("DimensionCount", &self.DimensionCount)
1230             .field("Strides", &self.Strides)
1231             .field("Dilations", &self.Dilations)
1232             .field("StartPadding", &self.StartPadding)
1233             .field("EndPadding", &self.EndPadding)
1234             .field("GroupCount", &self.GroupCount)
1235             .finish()
1236     }
1237 }
1238 impl ::std::cmp::PartialEq for DML_CONVOLUTION_INTEGER_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1239     fn eq(&self, other: &Self) -> bool {
1240         self.InputTensor == other.InputTensor && self.InputZeroPointTensor == other.InputZeroPointTensor && self.FilterTensor == other.FilterTensor && self.FilterZeroPointTensor == other.FilterZeroPointTensor && self.OutputTensor == other.OutputTensor && self.DimensionCount == other.DimensionCount && self.Strides == other.Strides && self.Dilations == other.Dilations && self.StartPadding == other.StartPadding && self.EndPadding == other.EndPadding && self.GroupCount == other.GroupCount
1241     }
1242 }
1243 impl ::std::cmp::Eq for DML_CONVOLUTION_INTEGER_OPERATOR_DESC {}
1244 unsafe impl ::windows::runtime::Abi for DML_CONVOLUTION_INTEGER_OPERATOR_DESC {
1245     type Abi = Self;
1246     type DefaultType = Self;
1247 }
1248 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1249 #[repr(transparent)]
1250 pub struct DML_CONVOLUTION_MODE(pub i32);
1251 pub const DML_CONVOLUTION_MODE_CONVOLUTION: DML_CONVOLUTION_MODE = DML_CONVOLUTION_MODE(0i32);
1252 pub const DML_CONVOLUTION_MODE_CROSS_CORRELATION: DML_CONVOLUTION_MODE = DML_CONVOLUTION_MODE(1i32);
1253 impl ::std::convert::From<i32> for DML_CONVOLUTION_MODE {
from(value: i32) -> Self1254     fn from(value: i32) -> Self {
1255         Self(value)
1256     }
1257 }
1258 unsafe impl ::windows::runtime::Abi for DML_CONVOLUTION_MODE {
1259     type Abi = Self;
1260     type DefaultType = Self;
1261 }
1262 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1263 #[repr(C)]
1264 pub struct DML_CONVOLUTION_OPERATOR_DESC {
1265     pub InputTensor: *mut DML_TENSOR_DESC,
1266     pub FilterTensor: *mut DML_TENSOR_DESC,
1267     pub BiasTensor: *mut DML_TENSOR_DESC,
1268     pub OutputTensor: *mut DML_TENSOR_DESC,
1269     pub Mode: DML_CONVOLUTION_MODE,
1270     pub Direction: DML_CONVOLUTION_DIRECTION,
1271     pub DimensionCount: u32,
1272     pub Strides: *mut u32,
1273     pub Dilations: *mut u32,
1274     pub StartPadding: *mut u32,
1275     pub EndPadding: *mut u32,
1276     pub OutputPadding: *mut u32,
1277     pub GroupCount: u32,
1278     pub FusedActivation: *mut DML_OPERATOR_DESC,
1279 }
1280 impl DML_CONVOLUTION_OPERATOR_DESC {}
1281 impl ::std::default::Default for DML_CONVOLUTION_OPERATOR_DESC {
default() -> Self1282     fn default() -> Self {
1283         unsafe { ::std::mem::zeroed() }
1284     }
1285 }
1286 impl ::std::fmt::Debug for DML_CONVOLUTION_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1287     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1288         fmt.debug_struct("DML_CONVOLUTION_OPERATOR_DESC")
1289             .field("InputTensor", &self.InputTensor)
1290             .field("FilterTensor", &self.FilterTensor)
1291             .field("BiasTensor", &self.BiasTensor)
1292             .field("OutputTensor", &self.OutputTensor)
1293             .field("Mode", &self.Mode)
1294             .field("Direction", &self.Direction)
1295             .field("DimensionCount", &self.DimensionCount)
1296             .field("Strides", &self.Strides)
1297             .field("Dilations", &self.Dilations)
1298             .field("StartPadding", &self.StartPadding)
1299             .field("EndPadding", &self.EndPadding)
1300             .field("OutputPadding", &self.OutputPadding)
1301             .field("GroupCount", &self.GroupCount)
1302             .field("FusedActivation", &self.FusedActivation)
1303             .finish()
1304     }
1305 }
1306 impl ::std::cmp::PartialEq for DML_CONVOLUTION_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1307     fn eq(&self, other: &Self) -> bool {
1308         self.InputTensor == other.InputTensor
1309             && self.FilterTensor == other.FilterTensor
1310             && self.BiasTensor == other.BiasTensor
1311             && self.OutputTensor == other.OutputTensor
1312             && self.Mode == other.Mode
1313             && self.Direction == other.Direction
1314             && self.DimensionCount == other.DimensionCount
1315             && self.Strides == other.Strides
1316             && self.Dilations == other.Dilations
1317             && self.StartPadding == other.StartPadding
1318             && self.EndPadding == other.EndPadding
1319             && self.OutputPadding == other.OutputPadding
1320             && self.GroupCount == other.GroupCount
1321             && self.FusedActivation == other.FusedActivation
1322     }
1323 }
1324 impl ::std::cmp::Eq for DML_CONVOLUTION_OPERATOR_DESC {}
1325 unsafe impl ::windows::runtime::Abi for DML_CONVOLUTION_OPERATOR_DESC {
1326     type Abi = Self;
1327     type DefaultType = Self;
1328 }
1329 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1330 #[repr(transparent)]
1331 pub struct DML_CREATE_DEVICE_FLAGS(pub u32);
1332 pub const DML_CREATE_DEVICE_FLAG_NONE: DML_CREATE_DEVICE_FLAGS = DML_CREATE_DEVICE_FLAGS(0u32);
1333 pub const DML_CREATE_DEVICE_FLAG_DEBUG: DML_CREATE_DEVICE_FLAGS = DML_CREATE_DEVICE_FLAGS(1u32);
1334 impl ::std::convert::From<u32> for DML_CREATE_DEVICE_FLAGS {
from(value: u32) -> Self1335     fn from(value: u32) -> Self {
1336         Self(value)
1337     }
1338 }
1339 unsafe impl ::windows::runtime::Abi for DML_CREATE_DEVICE_FLAGS {
1340     type Abi = Self;
1341     type DefaultType = Self;
1342 }
1343 impl ::std::ops::BitOr for DML_CREATE_DEVICE_FLAGS {
1344     type Output = Self;
bitor(self, rhs: Self) -> Self1345     fn bitor(self, rhs: Self) -> Self {
1346         Self(self.0 | rhs.0)
1347     }
1348 }
1349 impl ::std::ops::BitAnd for DML_CREATE_DEVICE_FLAGS {
1350     type Output = Self;
bitand(self, rhs: Self) -> Self1351     fn bitand(self, rhs: Self) -> Self {
1352         Self(self.0 & rhs.0)
1353     }
1354 }
1355 impl ::std::ops::BitOrAssign for DML_CREATE_DEVICE_FLAGS {
bitor_assign(&mut self, rhs: Self)1356     fn bitor_assign(&mut self, rhs: Self) {
1357         self.0.bitor_assign(rhs.0)
1358     }
1359 }
1360 impl ::std::ops::BitAndAssign for DML_CREATE_DEVICE_FLAGS {
bitand_assign(&mut self, rhs: Self)1361     fn bitand_assign(&mut self, rhs: Self) {
1362         self.0.bitand_assign(rhs.0)
1363     }
1364 }
1365 impl ::std::ops::Not for DML_CREATE_DEVICE_FLAGS {
1366     type Output = Self;
not(self) -> Self1367     fn not(self) -> Self {
1368         Self(self.0.not())
1369     }
1370 }
1371 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1372 #[repr(C)]
1373 #[cfg(feature = "Win32_Foundation")]
1374 pub struct DML_CUMULATIVE_PRODUCT_OPERATOR_DESC {
1375     pub InputTensor: *mut DML_TENSOR_DESC,
1376     pub OutputTensor: *mut DML_TENSOR_DESC,
1377     pub Axis: u32,
1378     pub AxisDirection: DML_AXIS_DIRECTION,
1379     pub HasExclusiveProduct: super::super::super::Foundation::BOOL,
1380 }
1381 #[cfg(feature = "Win32_Foundation")]
1382 impl DML_CUMULATIVE_PRODUCT_OPERATOR_DESC {}
1383 #[cfg(feature = "Win32_Foundation")]
1384 impl ::std::default::Default for DML_CUMULATIVE_PRODUCT_OPERATOR_DESC {
default() -> Self1385     fn default() -> Self {
1386         unsafe { ::std::mem::zeroed() }
1387     }
1388 }
1389 #[cfg(feature = "Win32_Foundation")]
1390 impl ::std::fmt::Debug for DML_CUMULATIVE_PRODUCT_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1391     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1392         fmt.debug_struct("DML_CUMULATIVE_PRODUCT_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("Axis", &self.Axis).field("AxisDirection", &self.AxisDirection).field("HasExclusiveProduct", &self.HasExclusiveProduct).finish()
1393     }
1394 }
1395 #[cfg(feature = "Win32_Foundation")]
1396 impl ::std::cmp::PartialEq for DML_CUMULATIVE_PRODUCT_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1397     fn eq(&self, other: &Self) -> bool {
1398         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.Axis == other.Axis && self.AxisDirection == other.AxisDirection && self.HasExclusiveProduct == other.HasExclusiveProduct
1399     }
1400 }
1401 #[cfg(feature = "Win32_Foundation")]
1402 impl ::std::cmp::Eq for DML_CUMULATIVE_PRODUCT_OPERATOR_DESC {}
1403 #[cfg(feature = "Win32_Foundation")]
1404 unsafe impl ::windows::runtime::Abi for DML_CUMULATIVE_PRODUCT_OPERATOR_DESC {
1405     type Abi = Self;
1406     type DefaultType = Self;
1407 }
1408 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1409 #[repr(C)]
1410 #[cfg(feature = "Win32_Foundation")]
1411 pub struct DML_CUMULATIVE_SUMMATION_OPERATOR_DESC {
1412     pub InputTensor: *mut DML_TENSOR_DESC,
1413     pub OutputTensor: *mut DML_TENSOR_DESC,
1414     pub Axis: u32,
1415     pub AxisDirection: DML_AXIS_DIRECTION,
1416     pub HasExclusiveSum: super::super::super::Foundation::BOOL,
1417 }
1418 #[cfg(feature = "Win32_Foundation")]
1419 impl DML_CUMULATIVE_SUMMATION_OPERATOR_DESC {}
1420 #[cfg(feature = "Win32_Foundation")]
1421 impl ::std::default::Default for DML_CUMULATIVE_SUMMATION_OPERATOR_DESC {
default() -> Self1422     fn default() -> Self {
1423         unsafe { ::std::mem::zeroed() }
1424     }
1425 }
1426 #[cfg(feature = "Win32_Foundation")]
1427 impl ::std::fmt::Debug for DML_CUMULATIVE_SUMMATION_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1428     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1429         fmt.debug_struct("DML_CUMULATIVE_SUMMATION_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("Axis", &self.Axis).field("AxisDirection", &self.AxisDirection).field("HasExclusiveSum", &self.HasExclusiveSum).finish()
1430     }
1431 }
1432 #[cfg(feature = "Win32_Foundation")]
1433 impl ::std::cmp::PartialEq for DML_CUMULATIVE_SUMMATION_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1434     fn eq(&self, other: &Self) -> bool {
1435         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.Axis == other.Axis && self.AxisDirection == other.AxisDirection && self.HasExclusiveSum == other.HasExclusiveSum
1436     }
1437 }
1438 #[cfg(feature = "Win32_Foundation")]
1439 impl ::std::cmp::Eq for DML_CUMULATIVE_SUMMATION_OPERATOR_DESC {}
1440 #[cfg(feature = "Win32_Foundation")]
1441 unsafe impl ::windows::runtime::Abi for DML_CUMULATIVE_SUMMATION_OPERATOR_DESC {
1442     type Abi = Self;
1443     type DefaultType = Self;
1444 }
1445 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1446 #[repr(transparent)]
1447 pub struct DML_DEPTH_SPACE_ORDER(pub i32);
1448 pub const DML_DEPTH_SPACE_ORDER_DEPTH_COLUMN_ROW: DML_DEPTH_SPACE_ORDER = DML_DEPTH_SPACE_ORDER(0i32);
1449 pub const DML_DEPTH_SPACE_ORDER_COLUMN_ROW_DEPTH: DML_DEPTH_SPACE_ORDER = DML_DEPTH_SPACE_ORDER(1i32);
1450 impl ::std::convert::From<i32> for DML_DEPTH_SPACE_ORDER {
from(value: i32) -> Self1451     fn from(value: i32) -> Self {
1452         Self(value)
1453     }
1454 }
1455 unsafe impl ::windows::runtime::Abi for DML_DEPTH_SPACE_ORDER {
1456     type Abi = Self;
1457     type DefaultType = Self;
1458 }
1459 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1460 #[repr(C)]
1461 pub struct DML_DEPTH_TO_SPACE1_OPERATOR_DESC {
1462     pub InputTensor: *mut DML_TENSOR_DESC,
1463     pub OutputTensor: *mut DML_TENSOR_DESC,
1464     pub BlockSize: u32,
1465     pub Order: DML_DEPTH_SPACE_ORDER,
1466 }
1467 impl DML_DEPTH_TO_SPACE1_OPERATOR_DESC {}
1468 impl ::std::default::Default for DML_DEPTH_TO_SPACE1_OPERATOR_DESC {
default() -> Self1469     fn default() -> Self {
1470         unsafe { ::std::mem::zeroed() }
1471     }
1472 }
1473 impl ::std::fmt::Debug for DML_DEPTH_TO_SPACE1_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1474     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1475         fmt.debug_struct("DML_DEPTH_TO_SPACE1_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("BlockSize", &self.BlockSize).field("Order", &self.Order).finish()
1476     }
1477 }
1478 impl ::std::cmp::PartialEq for DML_DEPTH_TO_SPACE1_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1479     fn eq(&self, other: &Self) -> bool {
1480         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.BlockSize == other.BlockSize && self.Order == other.Order
1481     }
1482 }
1483 impl ::std::cmp::Eq for DML_DEPTH_TO_SPACE1_OPERATOR_DESC {}
1484 unsafe impl ::windows::runtime::Abi for DML_DEPTH_TO_SPACE1_OPERATOR_DESC {
1485     type Abi = Self;
1486     type DefaultType = Self;
1487 }
1488 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1489 #[repr(C)]
1490 pub struct DML_DEPTH_TO_SPACE_OPERATOR_DESC {
1491     pub InputTensor: *mut DML_TENSOR_DESC,
1492     pub OutputTensor: *mut DML_TENSOR_DESC,
1493     pub BlockSize: u32,
1494 }
1495 impl DML_DEPTH_TO_SPACE_OPERATOR_DESC {}
1496 impl ::std::default::Default for DML_DEPTH_TO_SPACE_OPERATOR_DESC {
default() -> Self1497     fn default() -> Self {
1498         unsafe { ::std::mem::zeroed() }
1499     }
1500 }
1501 impl ::std::fmt::Debug for DML_DEPTH_TO_SPACE_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1502     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1503         fmt.debug_struct("DML_DEPTH_TO_SPACE_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("BlockSize", &self.BlockSize).finish()
1504     }
1505 }
1506 impl ::std::cmp::PartialEq for DML_DEPTH_TO_SPACE_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1507     fn eq(&self, other: &Self) -> bool {
1508         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.BlockSize == other.BlockSize
1509     }
1510 }
1511 impl ::std::cmp::Eq for DML_DEPTH_TO_SPACE_OPERATOR_DESC {}
1512 unsafe impl ::windows::runtime::Abi for DML_DEPTH_TO_SPACE_OPERATOR_DESC {
1513     type Abi = Self;
1514     type DefaultType = Self;
1515 }
1516 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1517 #[repr(C)]
1518 pub struct DML_DIAGONAL_MATRIX_OPERATOR_DESC {
1519     pub OutputTensor: *mut DML_TENSOR_DESC,
1520     pub Offset: i32,
1521     pub Value: f32,
1522 }
1523 impl DML_DIAGONAL_MATRIX_OPERATOR_DESC {}
1524 impl ::std::default::Default for DML_DIAGONAL_MATRIX_OPERATOR_DESC {
default() -> Self1525     fn default() -> Self {
1526         unsafe { ::std::mem::zeroed() }
1527     }
1528 }
1529 impl ::std::fmt::Debug for DML_DIAGONAL_MATRIX_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1530     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1531         fmt.debug_struct("DML_DIAGONAL_MATRIX_OPERATOR_DESC").field("OutputTensor", &self.OutputTensor).field("Offset", &self.Offset).field("Value", &self.Value).finish()
1532     }
1533 }
1534 impl ::std::cmp::PartialEq for DML_DIAGONAL_MATRIX_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1535     fn eq(&self, other: &Self) -> bool {
1536         self.OutputTensor == other.OutputTensor && self.Offset == other.Offset && self.Value == other.Value
1537     }
1538 }
1539 impl ::std::cmp::Eq for DML_DIAGONAL_MATRIX_OPERATOR_DESC {}
1540 unsafe impl ::windows::runtime::Abi for DML_DIAGONAL_MATRIX_OPERATOR_DESC {
1541     type Abi = Self;
1542     type DefaultType = Self;
1543 }
1544 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1545 #[repr(C)]
1546 pub struct DML_DYNAMIC_QUANTIZE_LINEAR_OPERATOR_DESC {
1547     pub InputTensor: *mut DML_TENSOR_DESC,
1548     pub OutputTensor: *mut DML_TENSOR_DESC,
1549     pub OutputScaleTensor: *mut DML_TENSOR_DESC,
1550     pub OutputZeroPointTensor: *mut DML_TENSOR_DESC,
1551 }
1552 impl DML_DYNAMIC_QUANTIZE_LINEAR_OPERATOR_DESC {}
1553 impl ::std::default::Default for DML_DYNAMIC_QUANTIZE_LINEAR_OPERATOR_DESC {
default() -> Self1554     fn default() -> Self {
1555         unsafe { ::std::mem::zeroed() }
1556     }
1557 }
1558 impl ::std::fmt::Debug for DML_DYNAMIC_QUANTIZE_LINEAR_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1559     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1560         fmt.debug_struct("DML_DYNAMIC_QUANTIZE_LINEAR_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("OutputScaleTensor", &self.OutputScaleTensor).field("OutputZeroPointTensor", &self.OutputZeroPointTensor).finish()
1561     }
1562 }
1563 impl ::std::cmp::PartialEq for DML_DYNAMIC_QUANTIZE_LINEAR_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1564     fn eq(&self, other: &Self) -> bool {
1565         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.OutputScaleTensor == other.OutputScaleTensor && self.OutputZeroPointTensor == other.OutputZeroPointTensor
1566     }
1567 }
1568 impl ::std::cmp::Eq for DML_DYNAMIC_QUANTIZE_LINEAR_OPERATOR_DESC {}
1569 unsafe impl ::windows::runtime::Abi for DML_DYNAMIC_QUANTIZE_LINEAR_OPERATOR_DESC {
1570     type Abi = Self;
1571     type DefaultType = Self;
1572 }
1573 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1574 #[repr(C)]
1575 pub struct DML_ELEMENT_WISE_ABS_OPERATOR_DESC {
1576     pub InputTensor: *mut DML_TENSOR_DESC,
1577     pub OutputTensor: *mut DML_TENSOR_DESC,
1578     pub ScaleBias: *mut DML_SCALE_BIAS,
1579 }
1580 impl DML_ELEMENT_WISE_ABS_OPERATOR_DESC {}
1581 impl ::std::default::Default for DML_ELEMENT_WISE_ABS_OPERATOR_DESC {
default() -> Self1582     fn default() -> Self {
1583         unsafe { ::std::mem::zeroed() }
1584     }
1585 }
1586 impl ::std::fmt::Debug for DML_ELEMENT_WISE_ABS_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1587     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1588         fmt.debug_struct("DML_ELEMENT_WISE_ABS_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).finish()
1589     }
1590 }
1591 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_ABS_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1592     fn eq(&self, other: &Self) -> bool {
1593         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias
1594     }
1595 }
1596 impl ::std::cmp::Eq for DML_ELEMENT_WISE_ABS_OPERATOR_DESC {}
1597 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_ABS_OPERATOR_DESC {
1598     type Abi = Self;
1599     type DefaultType = Self;
1600 }
1601 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1602 #[repr(C)]
1603 pub struct DML_ELEMENT_WISE_ACOSH_OPERATOR_DESC {
1604     pub InputTensor: *mut DML_TENSOR_DESC,
1605     pub OutputTensor: *mut DML_TENSOR_DESC,
1606     pub ScaleBias: *mut DML_SCALE_BIAS,
1607 }
1608 impl DML_ELEMENT_WISE_ACOSH_OPERATOR_DESC {}
1609 impl ::std::default::Default for DML_ELEMENT_WISE_ACOSH_OPERATOR_DESC {
default() -> Self1610     fn default() -> Self {
1611         unsafe { ::std::mem::zeroed() }
1612     }
1613 }
1614 impl ::std::fmt::Debug for DML_ELEMENT_WISE_ACOSH_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1615     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1616         fmt.debug_struct("DML_ELEMENT_WISE_ACOSH_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).finish()
1617     }
1618 }
1619 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_ACOSH_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1620     fn eq(&self, other: &Self) -> bool {
1621         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias
1622     }
1623 }
1624 impl ::std::cmp::Eq for DML_ELEMENT_WISE_ACOSH_OPERATOR_DESC {}
1625 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_ACOSH_OPERATOR_DESC {
1626     type Abi = Self;
1627     type DefaultType = Self;
1628 }
1629 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1630 #[repr(C)]
1631 pub struct DML_ELEMENT_WISE_ACOS_OPERATOR_DESC {
1632     pub InputTensor: *mut DML_TENSOR_DESC,
1633     pub OutputTensor: *mut DML_TENSOR_DESC,
1634     pub ScaleBias: *mut DML_SCALE_BIAS,
1635 }
1636 impl DML_ELEMENT_WISE_ACOS_OPERATOR_DESC {}
1637 impl ::std::default::Default for DML_ELEMENT_WISE_ACOS_OPERATOR_DESC {
default() -> Self1638     fn default() -> Self {
1639         unsafe { ::std::mem::zeroed() }
1640     }
1641 }
1642 impl ::std::fmt::Debug for DML_ELEMENT_WISE_ACOS_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1643     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1644         fmt.debug_struct("DML_ELEMENT_WISE_ACOS_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).finish()
1645     }
1646 }
1647 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_ACOS_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1648     fn eq(&self, other: &Self) -> bool {
1649         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias
1650     }
1651 }
1652 impl ::std::cmp::Eq for DML_ELEMENT_WISE_ACOS_OPERATOR_DESC {}
1653 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_ACOS_OPERATOR_DESC {
1654     type Abi = Self;
1655     type DefaultType = Self;
1656 }
1657 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1658 #[repr(C)]
1659 pub struct DML_ELEMENT_WISE_ADD1_OPERATOR_DESC {
1660     pub ATensor: *mut DML_TENSOR_DESC,
1661     pub BTensor: *mut DML_TENSOR_DESC,
1662     pub OutputTensor: *mut DML_TENSOR_DESC,
1663     pub FusedActivation: *mut DML_OPERATOR_DESC,
1664 }
1665 impl DML_ELEMENT_WISE_ADD1_OPERATOR_DESC {}
1666 impl ::std::default::Default for DML_ELEMENT_WISE_ADD1_OPERATOR_DESC {
default() -> Self1667     fn default() -> Self {
1668         unsafe { ::std::mem::zeroed() }
1669     }
1670 }
1671 impl ::std::fmt::Debug for DML_ELEMENT_WISE_ADD1_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1672     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1673         fmt.debug_struct("DML_ELEMENT_WISE_ADD1_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).field("FusedActivation", &self.FusedActivation).finish()
1674     }
1675 }
1676 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_ADD1_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1677     fn eq(&self, other: &Self) -> bool {
1678         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor && self.FusedActivation == other.FusedActivation
1679     }
1680 }
1681 impl ::std::cmp::Eq for DML_ELEMENT_WISE_ADD1_OPERATOR_DESC {}
1682 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_ADD1_OPERATOR_DESC {
1683     type Abi = Self;
1684     type DefaultType = Self;
1685 }
1686 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1687 #[repr(C)]
1688 pub struct DML_ELEMENT_WISE_ADD_OPERATOR_DESC {
1689     pub ATensor: *mut DML_TENSOR_DESC,
1690     pub BTensor: *mut DML_TENSOR_DESC,
1691     pub OutputTensor: *mut DML_TENSOR_DESC,
1692 }
1693 impl DML_ELEMENT_WISE_ADD_OPERATOR_DESC {}
1694 impl ::std::default::Default for DML_ELEMENT_WISE_ADD_OPERATOR_DESC {
default() -> Self1695     fn default() -> Self {
1696         unsafe { ::std::mem::zeroed() }
1697     }
1698 }
1699 impl ::std::fmt::Debug for DML_ELEMENT_WISE_ADD_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1700     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1701         fmt.debug_struct("DML_ELEMENT_WISE_ADD_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
1702     }
1703 }
1704 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_ADD_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1705     fn eq(&self, other: &Self) -> bool {
1706         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
1707     }
1708 }
1709 impl ::std::cmp::Eq for DML_ELEMENT_WISE_ADD_OPERATOR_DESC {}
1710 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_ADD_OPERATOR_DESC {
1711     type Abi = Self;
1712     type DefaultType = Self;
1713 }
1714 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1715 #[repr(C)]
1716 pub struct DML_ELEMENT_WISE_ASINH_OPERATOR_DESC {
1717     pub InputTensor: *mut DML_TENSOR_DESC,
1718     pub OutputTensor: *mut DML_TENSOR_DESC,
1719     pub ScaleBias: *mut DML_SCALE_BIAS,
1720 }
1721 impl DML_ELEMENT_WISE_ASINH_OPERATOR_DESC {}
1722 impl ::std::default::Default for DML_ELEMENT_WISE_ASINH_OPERATOR_DESC {
default() -> Self1723     fn default() -> Self {
1724         unsafe { ::std::mem::zeroed() }
1725     }
1726 }
1727 impl ::std::fmt::Debug for DML_ELEMENT_WISE_ASINH_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1728     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1729         fmt.debug_struct("DML_ELEMENT_WISE_ASINH_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).finish()
1730     }
1731 }
1732 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_ASINH_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1733     fn eq(&self, other: &Self) -> bool {
1734         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias
1735     }
1736 }
1737 impl ::std::cmp::Eq for DML_ELEMENT_WISE_ASINH_OPERATOR_DESC {}
1738 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_ASINH_OPERATOR_DESC {
1739     type Abi = Self;
1740     type DefaultType = Self;
1741 }
1742 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1743 #[repr(C)]
1744 pub struct DML_ELEMENT_WISE_ASIN_OPERATOR_DESC {
1745     pub InputTensor: *mut DML_TENSOR_DESC,
1746     pub OutputTensor: *mut DML_TENSOR_DESC,
1747     pub ScaleBias: *mut DML_SCALE_BIAS,
1748 }
1749 impl DML_ELEMENT_WISE_ASIN_OPERATOR_DESC {}
1750 impl ::std::default::Default for DML_ELEMENT_WISE_ASIN_OPERATOR_DESC {
default() -> Self1751     fn default() -> Self {
1752         unsafe { ::std::mem::zeroed() }
1753     }
1754 }
1755 impl ::std::fmt::Debug for DML_ELEMENT_WISE_ASIN_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1756     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1757         fmt.debug_struct("DML_ELEMENT_WISE_ASIN_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).finish()
1758     }
1759 }
1760 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_ASIN_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1761     fn eq(&self, other: &Self) -> bool {
1762         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias
1763     }
1764 }
1765 impl ::std::cmp::Eq for DML_ELEMENT_WISE_ASIN_OPERATOR_DESC {}
1766 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_ASIN_OPERATOR_DESC {
1767     type Abi = Self;
1768     type DefaultType = Self;
1769 }
1770 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1771 #[repr(C)]
1772 pub struct DML_ELEMENT_WISE_ATANH_OPERATOR_DESC {
1773     pub InputTensor: *mut DML_TENSOR_DESC,
1774     pub OutputTensor: *mut DML_TENSOR_DESC,
1775     pub ScaleBias: *mut DML_SCALE_BIAS,
1776 }
1777 impl DML_ELEMENT_WISE_ATANH_OPERATOR_DESC {}
1778 impl ::std::default::Default for DML_ELEMENT_WISE_ATANH_OPERATOR_DESC {
default() -> Self1779     fn default() -> Self {
1780         unsafe { ::std::mem::zeroed() }
1781     }
1782 }
1783 impl ::std::fmt::Debug for DML_ELEMENT_WISE_ATANH_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1784     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1785         fmt.debug_struct("DML_ELEMENT_WISE_ATANH_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).finish()
1786     }
1787 }
1788 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_ATANH_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1789     fn eq(&self, other: &Self) -> bool {
1790         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias
1791     }
1792 }
1793 impl ::std::cmp::Eq for DML_ELEMENT_WISE_ATANH_OPERATOR_DESC {}
1794 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_ATANH_OPERATOR_DESC {
1795     type Abi = Self;
1796     type DefaultType = Self;
1797 }
1798 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1799 #[repr(C)]
1800 pub struct DML_ELEMENT_WISE_ATAN_OPERATOR_DESC {
1801     pub InputTensor: *mut DML_TENSOR_DESC,
1802     pub OutputTensor: *mut DML_TENSOR_DESC,
1803     pub ScaleBias: *mut DML_SCALE_BIAS,
1804 }
1805 impl DML_ELEMENT_WISE_ATAN_OPERATOR_DESC {}
1806 impl ::std::default::Default for DML_ELEMENT_WISE_ATAN_OPERATOR_DESC {
default() -> Self1807     fn default() -> Self {
1808         unsafe { ::std::mem::zeroed() }
1809     }
1810 }
1811 impl ::std::fmt::Debug for DML_ELEMENT_WISE_ATAN_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1812     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1813         fmt.debug_struct("DML_ELEMENT_WISE_ATAN_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).finish()
1814     }
1815 }
1816 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_ATAN_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1817     fn eq(&self, other: &Self) -> bool {
1818         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias
1819     }
1820 }
1821 impl ::std::cmp::Eq for DML_ELEMENT_WISE_ATAN_OPERATOR_DESC {}
1822 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_ATAN_OPERATOR_DESC {
1823     type Abi = Self;
1824     type DefaultType = Self;
1825 }
1826 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1827 #[repr(C)]
1828 pub struct DML_ELEMENT_WISE_ATAN_YX_OPERATOR_DESC {
1829     pub ATensor: *mut DML_TENSOR_DESC,
1830     pub BTensor: *mut DML_TENSOR_DESC,
1831     pub OutputTensor: *mut DML_TENSOR_DESC,
1832 }
1833 impl DML_ELEMENT_WISE_ATAN_YX_OPERATOR_DESC {}
1834 impl ::std::default::Default for DML_ELEMENT_WISE_ATAN_YX_OPERATOR_DESC {
default() -> Self1835     fn default() -> Self {
1836         unsafe { ::std::mem::zeroed() }
1837     }
1838 }
1839 impl ::std::fmt::Debug for DML_ELEMENT_WISE_ATAN_YX_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1840     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1841         fmt.debug_struct("DML_ELEMENT_WISE_ATAN_YX_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
1842     }
1843 }
1844 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_ATAN_YX_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1845     fn eq(&self, other: &Self) -> bool {
1846         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
1847     }
1848 }
1849 impl ::std::cmp::Eq for DML_ELEMENT_WISE_ATAN_YX_OPERATOR_DESC {}
1850 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_ATAN_YX_OPERATOR_DESC {
1851     type Abi = Self;
1852     type DefaultType = Self;
1853 }
1854 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1855 #[repr(C)]
1856 pub struct DML_ELEMENT_WISE_BIT_AND_OPERATOR_DESC {
1857     pub ATensor: *mut DML_TENSOR_DESC,
1858     pub BTensor: *mut DML_TENSOR_DESC,
1859     pub OutputTensor: *mut DML_TENSOR_DESC,
1860 }
1861 impl DML_ELEMENT_WISE_BIT_AND_OPERATOR_DESC {}
1862 impl ::std::default::Default for DML_ELEMENT_WISE_BIT_AND_OPERATOR_DESC {
default() -> Self1863     fn default() -> Self {
1864         unsafe { ::std::mem::zeroed() }
1865     }
1866 }
1867 impl ::std::fmt::Debug for DML_ELEMENT_WISE_BIT_AND_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1868     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1869         fmt.debug_struct("DML_ELEMENT_WISE_BIT_AND_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
1870     }
1871 }
1872 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_BIT_AND_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1873     fn eq(&self, other: &Self) -> bool {
1874         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
1875     }
1876 }
1877 impl ::std::cmp::Eq for DML_ELEMENT_WISE_BIT_AND_OPERATOR_DESC {}
1878 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_BIT_AND_OPERATOR_DESC {
1879     type Abi = Self;
1880     type DefaultType = Self;
1881 }
1882 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1883 #[repr(C)]
1884 pub struct DML_ELEMENT_WISE_BIT_COUNT_OPERATOR_DESC {
1885     pub InputTensor: *mut DML_TENSOR_DESC,
1886     pub OutputTensor: *mut DML_TENSOR_DESC,
1887 }
1888 impl DML_ELEMENT_WISE_BIT_COUNT_OPERATOR_DESC {}
1889 impl ::std::default::Default for DML_ELEMENT_WISE_BIT_COUNT_OPERATOR_DESC {
default() -> Self1890     fn default() -> Self {
1891         unsafe { ::std::mem::zeroed() }
1892     }
1893 }
1894 impl ::std::fmt::Debug for DML_ELEMENT_WISE_BIT_COUNT_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1895     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1896         fmt.debug_struct("DML_ELEMENT_WISE_BIT_COUNT_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).finish()
1897     }
1898 }
1899 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_BIT_COUNT_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1900     fn eq(&self, other: &Self) -> bool {
1901         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor
1902     }
1903 }
1904 impl ::std::cmp::Eq for DML_ELEMENT_WISE_BIT_COUNT_OPERATOR_DESC {}
1905 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_BIT_COUNT_OPERATOR_DESC {
1906     type Abi = Self;
1907     type DefaultType = Self;
1908 }
1909 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1910 #[repr(C)]
1911 pub struct DML_ELEMENT_WISE_BIT_NOT_OPERATOR_DESC {
1912     pub InputTensor: *mut DML_TENSOR_DESC,
1913     pub OutputTensor: *mut DML_TENSOR_DESC,
1914 }
1915 impl DML_ELEMENT_WISE_BIT_NOT_OPERATOR_DESC {}
1916 impl ::std::default::Default for DML_ELEMENT_WISE_BIT_NOT_OPERATOR_DESC {
default() -> Self1917     fn default() -> Self {
1918         unsafe { ::std::mem::zeroed() }
1919     }
1920 }
1921 impl ::std::fmt::Debug for DML_ELEMENT_WISE_BIT_NOT_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1922     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1923         fmt.debug_struct("DML_ELEMENT_WISE_BIT_NOT_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).finish()
1924     }
1925 }
1926 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_BIT_NOT_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1927     fn eq(&self, other: &Self) -> bool {
1928         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor
1929     }
1930 }
1931 impl ::std::cmp::Eq for DML_ELEMENT_WISE_BIT_NOT_OPERATOR_DESC {}
1932 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_BIT_NOT_OPERATOR_DESC {
1933     type Abi = Self;
1934     type DefaultType = Self;
1935 }
1936 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1937 #[repr(C)]
1938 pub struct DML_ELEMENT_WISE_BIT_OR_OPERATOR_DESC {
1939     pub ATensor: *mut DML_TENSOR_DESC,
1940     pub BTensor: *mut DML_TENSOR_DESC,
1941     pub OutputTensor: *mut DML_TENSOR_DESC,
1942 }
1943 impl DML_ELEMENT_WISE_BIT_OR_OPERATOR_DESC {}
1944 impl ::std::default::Default for DML_ELEMENT_WISE_BIT_OR_OPERATOR_DESC {
default() -> Self1945     fn default() -> Self {
1946         unsafe { ::std::mem::zeroed() }
1947     }
1948 }
1949 impl ::std::fmt::Debug for DML_ELEMENT_WISE_BIT_OR_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1950     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1951         fmt.debug_struct("DML_ELEMENT_WISE_BIT_OR_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
1952     }
1953 }
1954 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_BIT_OR_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1955     fn eq(&self, other: &Self) -> bool {
1956         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
1957     }
1958 }
1959 impl ::std::cmp::Eq for DML_ELEMENT_WISE_BIT_OR_OPERATOR_DESC {}
1960 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_BIT_OR_OPERATOR_DESC {
1961     type Abi = Self;
1962     type DefaultType = Self;
1963 }
1964 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1965 #[repr(C)]
1966 pub struct DML_ELEMENT_WISE_BIT_SHIFT_LEFT_OPERATOR_DESC {
1967     pub ATensor: *mut DML_TENSOR_DESC,
1968     pub BTensor: *mut DML_TENSOR_DESC,
1969     pub OutputTensor: *mut DML_TENSOR_DESC,
1970 }
1971 impl DML_ELEMENT_WISE_BIT_SHIFT_LEFT_OPERATOR_DESC {}
1972 impl ::std::default::Default for DML_ELEMENT_WISE_BIT_SHIFT_LEFT_OPERATOR_DESC {
default() -> Self1973     fn default() -> Self {
1974         unsafe { ::std::mem::zeroed() }
1975     }
1976 }
1977 impl ::std::fmt::Debug for DML_ELEMENT_WISE_BIT_SHIFT_LEFT_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1978     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1979         fmt.debug_struct("DML_ELEMENT_WISE_BIT_SHIFT_LEFT_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
1980     }
1981 }
1982 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_BIT_SHIFT_LEFT_OPERATOR_DESC {
eq(&self, other: &Self) -> bool1983     fn eq(&self, other: &Self) -> bool {
1984         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
1985     }
1986 }
1987 impl ::std::cmp::Eq for DML_ELEMENT_WISE_BIT_SHIFT_LEFT_OPERATOR_DESC {}
1988 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_BIT_SHIFT_LEFT_OPERATOR_DESC {
1989     type Abi = Self;
1990     type DefaultType = Self;
1991 }
1992 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1993 #[repr(C)]
1994 pub struct DML_ELEMENT_WISE_BIT_SHIFT_RIGHT_OPERATOR_DESC {
1995     pub ATensor: *mut DML_TENSOR_DESC,
1996     pub BTensor: *mut DML_TENSOR_DESC,
1997     pub OutputTensor: *mut DML_TENSOR_DESC,
1998 }
1999 impl DML_ELEMENT_WISE_BIT_SHIFT_RIGHT_OPERATOR_DESC {}
2000 impl ::std::default::Default for DML_ELEMENT_WISE_BIT_SHIFT_RIGHT_OPERATOR_DESC {
default() -> Self2001     fn default() -> Self {
2002         unsafe { ::std::mem::zeroed() }
2003     }
2004 }
2005 impl ::std::fmt::Debug for DML_ELEMENT_WISE_BIT_SHIFT_RIGHT_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2006     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2007         fmt.debug_struct("DML_ELEMENT_WISE_BIT_SHIFT_RIGHT_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
2008     }
2009 }
2010 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_BIT_SHIFT_RIGHT_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2011     fn eq(&self, other: &Self) -> bool {
2012         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
2013     }
2014 }
2015 impl ::std::cmp::Eq for DML_ELEMENT_WISE_BIT_SHIFT_RIGHT_OPERATOR_DESC {}
2016 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_BIT_SHIFT_RIGHT_OPERATOR_DESC {
2017     type Abi = Self;
2018     type DefaultType = Self;
2019 }
2020 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2021 #[repr(C)]
2022 pub struct DML_ELEMENT_WISE_BIT_XOR_OPERATOR_DESC {
2023     pub ATensor: *mut DML_TENSOR_DESC,
2024     pub BTensor: *mut DML_TENSOR_DESC,
2025     pub OutputTensor: *mut DML_TENSOR_DESC,
2026 }
2027 impl DML_ELEMENT_WISE_BIT_XOR_OPERATOR_DESC {}
2028 impl ::std::default::Default for DML_ELEMENT_WISE_BIT_XOR_OPERATOR_DESC {
default() -> Self2029     fn default() -> Self {
2030         unsafe { ::std::mem::zeroed() }
2031     }
2032 }
2033 impl ::std::fmt::Debug for DML_ELEMENT_WISE_BIT_XOR_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2034     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2035         fmt.debug_struct("DML_ELEMENT_WISE_BIT_XOR_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
2036     }
2037 }
2038 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_BIT_XOR_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2039     fn eq(&self, other: &Self) -> bool {
2040         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
2041     }
2042 }
2043 impl ::std::cmp::Eq for DML_ELEMENT_WISE_BIT_XOR_OPERATOR_DESC {}
2044 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_BIT_XOR_OPERATOR_DESC {
2045     type Abi = Self;
2046     type DefaultType = Self;
2047 }
2048 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2049 #[repr(C)]
2050 pub struct DML_ELEMENT_WISE_CEIL_OPERATOR_DESC {
2051     pub InputTensor: *mut DML_TENSOR_DESC,
2052     pub OutputTensor: *mut DML_TENSOR_DESC,
2053     pub ScaleBias: *mut DML_SCALE_BIAS,
2054 }
2055 impl DML_ELEMENT_WISE_CEIL_OPERATOR_DESC {}
2056 impl ::std::default::Default for DML_ELEMENT_WISE_CEIL_OPERATOR_DESC {
default() -> Self2057     fn default() -> Self {
2058         unsafe { ::std::mem::zeroed() }
2059     }
2060 }
2061 impl ::std::fmt::Debug for DML_ELEMENT_WISE_CEIL_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2062     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2063         fmt.debug_struct("DML_ELEMENT_WISE_CEIL_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).finish()
2064     }
2065 }
2066 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_CEIL_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2067     fn eq(&self, other: &Self) -> bool {
2068         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias
2069     }
2070 }
2071 impl ::std::cmp::Eq for DML_ELEMENT_WISE_CEIL_OPERATOR_DESC {}
2072 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_CEIL_OPERATOR_DESC {
2073     type Abi = Self;
2074     type DefaultType = Self;
2075 }
2076 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2077 #[repr(C)]
2078 pub struct DML_ELEMENT_WISE_CLIP_GRAD_OPERATOR_DESC {
2079     pub InputTensor: *mut DML_TENSOR_DESC,
2080     pub InputGradientTensor: *mut DML_TENSOR_DESC,
2081     pub OutputGradientTensor: *mut DML_TENSOR_DESC,
2082     pub Min: f32,
2083     pub Max: f32,
2084 }
2085 impl DML_ELEMENT_WISE_CLIP_GRAD_OPERATOR_DESC {}
2086 impl ::std::default::Default for DML_ELEMENT_WISE_CLIP_GRAD_OPERATOR_DESC {
default() -> Self2087     fn default() -> Self {
2088         unsafe { ::std::mem::zeroed() }
2089     }
2090 }
2091 impl ::std::fmt::Debug for DML_ELEMENT_WISE_CLIP_GRAD_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2092     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2093         fmt.debug_struct("DML_ELEMENT_WISE_CLIP_GRAD_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("InputGradientTensor", &self.InputGradientTensor).field("OutputGradientTensor", &self.OutputGradientTensor).field("Min", &self.Min).field("Max", &self.Max).finish()
2094     }
2095 }
2096 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_CLIP_GRAD_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2097     fn eq(&self, other: &Self) -> bool {
2098         self.InputTensor == other.InputTensor && self.InputGradientTensor == other.InputGradientTensor && self.OutputGradientTensor == other.OutputGradientTensor && self.Min == other.Min && self.Max == other.Max
2099     }
2100 }
2101 impl ::std::cmp::Eq for DML_ELEMENT_WISE_CLIP_GRAD_OPERATOR_DESC {}
2102 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_CLIP_GRAD_OPERATOR_DESC {
2103     type Abi = Self;
2104     type DefaultType = Self;
2105 }
2106 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2107 #[repr(C)]
2108 pub struct DML_ELEMENT_WISE_CLIP_OPERATOR_DESC {
2109     pub InputTensor: *mut DML_TENSOR_DESC,
2110     pub OutputTensor: *mut DML_TENSOR_DESC,
2111     pub ScaleBias: *mut DML_SCALE_BIAS,
2112     pub Min: f32,
2113     pub Max: f32,
2114 }
2115 impl DML_ELEMENT_WISE_CLIP_OPERATOR_DESC {}
2116 impl ::std::default::Default for DML_ELEMENT_WISE_CLIP_OPERATOR_DESC {
default() -> Self2117     fn default() -> Self {
2118         unsafe { ::std::mem::zeroed() }
2119     }
2120 }
2121 impl ::std::fmt::Debug for DML_ELEMENT_WISE_CLIP_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2122     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2123         fmt.debug_struct("DML_ELEMENT_WISE_CLIP_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).field("Min", &self.Min).field("Max", &self.Max).finish()
2124     }
2125 }
2126 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_CLIP_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2127     fn eq(&self, other: &Self) -> bool {
2128         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias && self.Min == other.Min && self.Max == other.Max
2129     }
2130 }
2131 impl ::std::cmp::Eq for DML_ELEMENT_WISE_CLIP_OPERATOR_DESC {}
2132 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_CLIP_OPERATOR_DESC {
2133     type Abi = Self;
2134     type DefaultType = Self;
2135 }
2136 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2137 #[repr(C)]
2138 pub struct DML_ELEMENT_WISE_CONSTANT_POW_OPERATOR_DESC {
2139     pub InputTensor: *mut DML_TENSOR_DESC,
2140     pub OutputTensor: *mut DML_TENSOR_DESC,
2141     pub ScaleBias: *mut DML_SCALE_BIAS,
2142     pub Exponent: f32,
2143 }
2144 impl DML_ELEMENT_WISE_CONSTANT_POW_OPERATOR_DESC {}
2145 impl ::std::default::Default for DML_ELEMENT_WISE_CONSTANT_POW_OPERATOR_DESC {
default() -> Self2146     fn default() -> Self {
2147         unsafe { ::std::mem::zeroed() }
2148     }
2149 }
2150 impl ::std::fmt::Debug for DML_ELEMENT_WISE_CONSTANT_POW_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2151     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2152         fmt.debug_struct("DML_ELEMENT_WISE_CONSTANT_POW_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).field("Exponent", &self.Exponent).finish()
2153     }
2154 }
2155 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_CONSTANT_POW_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2156     fn eq(&self, other: &Self) -> bool {
2157         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias && self.Exponent == other.Exponent
2158     }
2159 }
2160 impl ::std::cmp::Eq for DML_ELEMENT_WISE_CONSTANT_POW_OPERATOR_DESC {}
2161 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_CONSTANT_POW_OPERATOR_DESC {
2162     type Abi = Self;
2163     type DefaultType = Self;
2164 }
2165 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2166 #[repr(C)]
2167 pub struct DML_ELEMENT_WISE_COSH_OPERATOR_DESC {
2168     pub InputTensor: *mut DML_TENSOR_DESC,
2169     pub OutputTensor: *mut DML_TENSOR_DESC,
2170     pub ScaleBias: *mut DML_SCALE_BIAS,
2171 }
2172 impl DML_ELEMENT_WISE_COSH_OPERATOR_DESC {}
2173 impl ::std::default::Default for DML_ELEMENT_WISE_COSH_OPERATOR_DESC {
default() -> Self2174     fn default() -> Self {
2175         unsafe { ::std::mem::zeroed() }
2176     }
2177 }
2178 impl ::std::fmt::Debug for DML_ELEMENT_WISE_COSH_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2179     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2180         fmt.debug_struct("DML_ELEMENT_WISE_COSH_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).finish()
2181     }
2182 }
2183 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_COSH_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2184     fn eq(&self, other: &Self) -> bool {
2185         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias
2186     }
2187 }
2188 impl ::std::cmp::Eq for DML_ELEMENT_WISE_COSH_OPERATOR_DESC {}
2189 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_COSH_OPERATOR_DESC {
2190     type Abi = Self;
2191     type DefaultType = Self;
2192 }
2193 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2194 #[repr(C)]
2195 pub struct DML_ELEMENT_WISE_COS_OPERATOR_DESC {
2196     pub InputTensor: *mut DML_TENSOR_DESC,
2197     pub OutputTensor: *mut DML_TENSOR_DESC,
2198     pub ScaleBias: *mut DML_SCALE_BIAS,
2199 }
2200 impl DML_ELEMENT_WISE_COS_OPERATOR_DESC {}
2201 impl ::std::default::Default for DML_ELEMENT_WISE_COS_OPERATOR_DESC {
default() -> Self2202     fn default() -> Self {
2203         unsafe { ::std::mem::zeroed() }
2204     }
2205 }
2206 impl ::std::fmt::Debug for DML_ELEMENT_WISE_COS_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2207     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2208         fmt.debug_struct("DML_ELEMENT_WISE_COS_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).finish()
2209     }
2210 }
2211 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_COS_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2212     fn eq(&self, other: &Self) -> bool {
2213         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias
2214     }
2215 }
2216 impl ::std::cmp::Eq for DML_ELEMENT_WISE_COS_OPERATOR_DESC {}
2217 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_COS_OPERATOR_DESC {
2218     type Abi = Self;
2219     type DefaultType = Self;
2220 }
2221 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2222 #[repr(C)]
2223 pub struct DML_ELEMENT_WISE_DEQUANTIZE_LINEAR_OPERATOR_DESC {
2224     pub InputTensor: *mut DML_TENSOR_DESC,
2225     pub ScaleTensor: *mut DML_TENSOR_DESC,
2226     pub ZeroPointTensor: *mut DML_TENSOR_DESC,
2227     pub OutputTensor: *mut DML_TENSOR_DESC,
2228 }
2229 impl DML_ELEMENT_WISE_DEQUANTIZE_LINEAR_OPERATOR_DESC {}
2230 impl ::std::default::Default for DML_ELEMENT_WISE_DEQUANTIZE_LINEAR_OPERATOR_DESC {
default() -> Self2231     fn default() -> Self {
2232         unsafe { ::std::mem::zeroed() }
2233     }
2234 }
2235 impl ::std::fmt::Debug for DML_ELEMENT_WISE_DEQUANTIZE_LINEAR_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2236     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2237         fmt.debug_struct("DML_ELEMENT_WISE_DEQUANTIZE_LINEAR_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("ScaleTensor", &self.ScaleTensor).field("ZeroPointTensor", &self.ZeroPointTensor).field("OutputTensor", &self.OutputTensor).finish()
2238     }
2239 }
2240 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_DEQUANTIZE_LINEAR_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2241     fn eq(&self, other: &Self) -> bool {
2242         self.InputTensor == other.InputTensor && self.ScaleTensor == other.ScaleTensor && self.ZeroPointTensor == other.ZeroPointTensor && self.OutputTensor == other.OutputTensor
2243     }
2244 }
2245 impl ::std::cmp::Eq for DML_ELEMENT_WISE_DEQUANTIZE_LINEAR_OPERATOR_DESC {}
2246 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_DEQUANTIZE_LINEAR_OPERATOR_DESC {
2247     type Abi = Self;
2248     type DefaultType = Self;
2249 }
2250 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2251 #[repr(C)]
2252 pub struct DML_ELEMENT_WISE_DIFFERENCE_SQUARE_OPERATOR_DESC {
2253     pub ATensor: *mut DML_TENSOR_DESC,
2254     pub BTensor: *mut DML_TENSOR_DESC,
2255     pub OutputTensor: *mut DML_TENSOR_DESC,
2256 }
2257 impl DML_ELEMENT_WISE_DIFFERENCE_SQUARE_OPERATOR_DESC {}
2258 impl ::std::default::Default for DML_ELEMENT_WISE_DIFFERENCE_SQUARE_OPERATOR_DESC {
default() -> Self2259     fn default() -> Self {
2260         unsafe { ::std::mem::zeroed() }
2261     }
2262 }
2263 impl ::std::fmt::Debug for DML_ELEMENT_WISE_DIFFERENCE_SQUARE_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2264     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2265         fmt.debug_struct("DML_ELEMENT_WISE_DIFFERENCE_SQUARE_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
2266     }
2267 }
2268 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_DIFFERENCE_SQUARE_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2269     fn eq(&self, other: &Self) -> bool {
2270         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
2271     }
2272 }
2273 impl ::std::cmp::Eq for DML_ELEMENT_WISE_DIFFERENCE_SQUARE_OPERATOR_DESC {}
2274 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_DIFFERENCE_SQUARE_OPERATOR_DESC {
2275     type Abi = Self;
2276     type DefaultType = Self;
2277 }
2278 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2279 #[repr(C)]
2280 pub struct DML_ELEMENT_WISE_DIVIDE_OPERATOR_DESC {
2281     pub ATensor: *mut DML_TENSOR_DESC,
2282     pub BTensor: *mut DML_TENSOR_DESC,
2283     pub OutputTensor: *mut DML_TENSOR_DESC,
2284 }
2285 impl DML_ELEMENT_WISE_DIVIDE_OPERATOR_DESC {}
2286 impl ::std::default::Default for DML_ELEMENT_WISE_DIVIDE_OPERATOR_DESC {
default() -> Self2287     fn default() -> Self {
2288         unsafe { ::std::mem::zeroed() }
2289     }
2290 }
2291 impl ::std::fmt::Debug for DML_ELEMENT_WISE_DIVIDE_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2292     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2293         fmt.debug_struct("DML_ELEMENT_WISE_DIVIDE_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
2294     }
2295 }
2296 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_DIVIDE_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2297     fn eq(&self, other: &Self) -> bool {
2298         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
2299     }
2300 }
2301 impl ::std::cmp::Eq for DML_ELEMENT_WISE_DIVIDE_OPERATOR_DESC {}
2302 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_DIVIDE_OPERATOR_DESC {
2303     type Abi = Self;
2304     type DefaultType = Self;
2305 }
2306 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2307 #[repr(C)]
2308 pub struct DML_ELEMENT_WISE_ERF_OPERATOR_DESC {
2309     pub InputTensor: *mut DML_TENSOR_DESC,
2310     pub OutputTensor: *mut DML_TENSOR_DESC,
2311     pub ScaleBias: *mut DML_SCALE_BIAS,
2312 }
2313 impl DML_ELEMENT_WISE_ERF_OPERATOR_DESC {}
2314 impl ::std::default::Default for DML_ELEMENT_WISE_ERF_OPERATOR_DESC {
default() -> Self2315     fn default() -> Self {
2316         unsafe { ::std::mem::zeroed() }
2317     }
2318 }
2319 impl ::std::fmt::Debug for DML_ELEMENT_WISE_ERF_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2320     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2321         fmt.debug_struct("DML_ELEMENT_WISE_ERF_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).finish()
2322     }
2323 }
2324 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_ERF_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2325     fn eq(&self, other: &Self) -> bool {
2326         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias
2327     }
2328 }
2329 impl ::std::cmp::Eq for DML_ELEMENT_WISE_ERF_OPERATOR_DESC {}
2330 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_ERF_OPERATOR_DESC {
2331     type Abi = Self;
2332     type DefaultType = Self;
2333 }
2334 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2335 #[repr(C)]
2336 pub struct DML_ELEMENT_WISE_EXP_OPERATOR_DESC {
2337     pub InputTensor: *mut DML_TENSOR_DESC,
2338     pub OutputTensor: *mut DML_TENSOR_DESC,
2339     pub ScaleBias: *mut DML_SCALE_BIAS,
2340 }
2341 impl DML_ELEMENT_WISE_EXP_OPERATOR_DESC {}
2342 impl ::std::default::Default for DML_ELEMENT_WISE_EXP_OPERATOR_DESC {
default() -> Self2343     fn default() -> Self {
2344         unsafe { ::std::mem::zeroed() }
2345     }
2346 }
2347 impl ::std::fmt::Debug for DML_ELEMENT_WISE_EXP_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2348     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2349         fmt.debug_struct("DML_ELEMENT_WISE_EXP_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).finish()
2350     }
2351 }
2352 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_EXP_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2353     fn eq(&self, other: &Self) -> bool {
2354         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias
2355     }
2356 }
2357 impl ::std::cmp::Eq for DML_ELEMENT_WISE_EXP_OPERATOR_DESC {}
2358 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_EXP_OPERATOR_DESC {
2359     type Abi = Self;
2360     type DefaultType = Self;
2361 }
2362 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2363 #[repr(C)]
2364 pub struct DML_ELEMENT_WISE_FLOOR_OPERATOR_DESC {
2365     pub InputTensor: *mut DML_TENSOR_DESC,
2366     pub OutputTensor: *mut DML_TENSOR_DESC,
2367     pub ScaleBias: *mut DML_SCALE_BIAS,
2368 }
2369 impl DML_ELEMENT_WISE_FLOOR_OPERATOR_DESC {}
2370 impl ::std::default::Default for DML_ELEMENT_WISE_FLOOR_OPERATOR_DESC {
default() -> Self2371     fn default() -> Self {
2372         unsafe { ::std::mem::zeroed() }
2373     }
2374 }
2375 impl ::std::fmt::Debug for DML_ELEMENT_WISE_FLOOR_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2376     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2377         fmt.debug_struct("DML_ELEMENT_WISE_FLOOR_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).finish()
2378     }
2379 }
2380 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_FLOOR_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2381     fn eq(&self, other: &Self) -> bool {
2382         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias
2383     }
2384 }
2385 impl ::std::cmp::Eq for DML_ELEMENT_WISE_FLOOR_OPERATOR_DESC {}
2386 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_FLOOR_OPERATOR_DESC {
2387     type Abi = Self;
2388     type DefaultType = Self;
2389 }
2390 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2391 #[repr(C)]
2392 pub struct DML_ELEMENT_WISE_IDENTITY_OPERATOR_DESC {
2393     pub InputTensor: *mut DML_TENSOR_DESC,
2394     pub OutputTensor: *mut DML_TENSOR_DESC,
2395     pub ScaleBias: *mut DML_SCALE_BIAS,
2396 }
2397 impl DML_ELEMENT_WISE_IDENTITY_OPERATOR_DESC {}
2398 impl ::std::default::Default for DML_ELEMENT_WISE_IDENTITY_OPERATOR_DESC {
default() -> Self2399     fn default() -> Self {
2400         unsafe { ::std::mem::zeroed() }
2401     }
2402 }
2403 impl ::std::fmt::Debug for DML_ELEMENT_WISE_IDENTITY_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2404     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2405         fmt.debug_struct("DML_ELEMENT_WISE_IDENTITY_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).finish()
2406     }
2407 }
2408 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_IDENTITY_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2409     fn eq(&self, other: &Self) -> bool {
2410         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias
2411     }
2412 }
2413 impl ::std::cmp::Eq for DML_ELEMENT_WISE_IDENTITY_OPERATOR_DESC {}
2414 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_IDENTITY_OPERATOR_DESC {
2415     type Abi = Self;
2416     type DefaultType = Self;
2417 }
2418 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2419 #[repr(C)]
2420 pub struct DML_ELEMENT_WISE_IF_OPERATOR_DESC {
2421     pub ConditionTensor: *mut DML_TENSOR_DESC,
2422     pub ATensor: *mut DML_TENSOR_DESC,
2423     pub BTensor: *mut DML_TENSOR_DESC,
2424     pub OutputTensor: *mut DML_TENSOR_DESC,
2425 }
2426 impl DML_ELEMENT_WISE_IF_OPERATOR_DESC {}
2427 impl ::std::default::Default for DML_ELEMENT_WISE_IF_OPERATOR_DESC {
default() -> Self2428     fn default() -> Self {
2429         unsafe { ::std::mem::zeroed() }
2430     }
2431 }
2432 impl ::std::fmt::Debug for DML_ELEMENT_WISE_IF_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2433     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2434         fmt.debug_struct("DML_ELEMENT_WISE_IF_OPERATOR_DESC").field("ConditionTensor", &self.ConditionTensor).field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
2435     }
2436 }
2437 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_IF_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2438     fn eq(&self, other: &Self) -> bool {
2439         self.ConditionTensor == other.ConditionTensor && self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
2440     }
2441 }
2442 impl ::std::cmp::Eq for DML_ELEMENT_WISE_IF_OPERATOR_DESC {}
2443 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_IF_OPERATOR_DESC {
2444     type Abi = Self;
2445     type DefaultType = Self;
2446 }
2447 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2448 #[repr(C)]
2449 pub struct DML_ELEMENT_WISE_IS_INFINITY_OPERATOR_DESC {
2450     pub InputTensor: *mut DML_TENSOR_DESC,
2451     pub OutputTensor: *mut DML_TENSOR_DESC,
2452     pub InfinityMode: DML_IS_INFINITY_MODE,
2453 }
2454 impl DML_ELEMENT_WISE_IS_INFINITY_OPERATOR_DESC {}
2455 impl ::std::default::Default for DML_ELEMENT_WISE_IS_INFINITY_OPERATOR_DESC {
default() -> Self2456     fn default() -> Self {
2457         unsafe { ::std::mem::zeroed() }
2458     }
2459 }
2460 impl ::std::fmt::Debug for DML_ELEMENT_WISE_IS_INFINITY_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2461     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2462         fmt.debug_struct("DML_ELEMENT_WISE_IS_INFINITY_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("InfinityMode", &self.InfinityMode).finish()
2463     }
2464 }
2465 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_IS_INFINITY_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2466     fn eq(&self, other: &Self) -> bool {
2467         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.InfinityMode == other.InfinityMode
2468     }
2469 }
2470 impl ::std::cmp::Eq for DML_ELEMENT_WISE_IS_INFINITY_OPERATOR_DESC {}
2471 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_IS_INFINITY_OPERATOR_DESC {
2472     type Abi = Self;
2473     type DefaultType = Self;
2474 }
2475 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2476 #[repr(C)]
2477 pub struct DML_ELEMENT_WISE_IS_NAN_OPERATOR_DESC {
2478     pub InputTensor: *mut DML_TENSOR_DESC,
2479     pub OutputTensor: *mut DML_TENSOR_DESC,
2480 }
2481 impl DML_ELEMENT_WISE_IS_NAN_OPERATOR_DESC {}
2482 impl ::std::default::Default for DML_ELEMENT_WISE_IS_NAN_OPERATOR_DESC {
default() -> Self2483     fn default() -> Self {
2484         unsafe { ::std::mem::zeroed() }
2485     }
2486 }
2487 impl ::std::fmt::Debug for DML_ELEMENT_WISE_IS_NAN_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2488     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2489         fmt.debug_struct("DML_ELEMENT_WISE_IS_NAN_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).finish()
2490     }
2491 }
2492 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_IS_NAN_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2493     fn eq(&self, other: &Self) -> bool {
2494         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor
2495     }
2496 }
2497 impl ::std::cmp::Eq for DML_ELEMENT_WISE_IS_NAN_OPERATOR_DESC {}
2498 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_IS_NAN_OPERATOR_DESC {
2499     type Abi = Self;
2500     type DefaultType = Self;
2501 }
2502 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2503 #[repr(C)]
2504 pub struct DML_ELEMENT_WISE_LOGICAL_AND_OPERATOR_DESC {
2505     pub ATensor: *mut DML_TENSOR_DESC,
2506     pub BTensor: *mut DML_TENSOR_DESC,
2507     pub OutputTensor: *mut DML_TENSOR_DESC,
2508 }
2509 impl DML_ELEMENT_WISE_LOGICAL_AND_OPERATOR_DESC {}
2510 impl ::std::default::Default for DML_ELEMENT_WISE_LOGICAL_AND_OPERATOR_DESC {
default() -> Self2511     fn default() -> Self {
2512         unsafe { ::std::mem::zeroed() }
2513     }
2514 }
2515 impl ::std::fmt::Debug for DML_ELEMENT_WISE_LOGICAL_AND_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2516     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2517         fmt.debug_struct("DML_ELEMENT_WISE_LOGICAL_AND_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
2518     }
2519 }
2520 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_LOGICAL_AND_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2521     fn eq(&self, other: &Self) -> bool {
2522         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
2523     }
2524 }
2525 impl ::std::cmp::Eq for DML_ELEMENT_WISE_LOGICAL_AND_OPERATOR_DESC {}
2526 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_LOGICAL_AND_OPERATOR_DESC {
2527     type Abi = Self;
2528     type DefaultType = Self;
2529 }
2530 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2531 #[repr(C)]
2532 pub struct DML_ELEMENT_WISE_LOGICAL_EQUALS_OPERATOR_DESC {
2533     pub ATensor: *mut DML_TENSOR_DESC,
2534     pub BTensor: *mut DML_TENSOR_DESC,
2535     pub OutputTensor: *mut DML_TENSOR_DESC,
2536 }
2537 impl DML_ELEMENT_WISE_LOGICAL_EQUALS_OPERATOR_DESC {}
2538 impl ::std::default::Default for DML_ELEMENT_WISE_LOGICAL_EQUALS_OPERATOR_DESC {
default() -> Self2539     fn default() -> Self {
2540         unsafe { ::std::mem::zeroed() }
2541     }
2542 }
2543 impl ::std::fmt::Debug for DML_ELEMENT_WISE_LOGICAL_EQUALS_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2544     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2545         fmt.debug_struct("DML_ELEMENT_WISE_LOGICAL_EQUALS_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
2546     }
2547 }
2548 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_LOGICAL_EQUALS_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2549     fn eq(&self, other: &Self) -> bool {
2550         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
2551     }
2552 }
2553 impl ::std::cmp::Eq for DML_ELEMENT_WISE_LOGICAL_EQUALS_OPERATOR_DESC {}
2554 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_LOGICAL_EQUALS_OPERATOR_DESC {
2555     type Abi = Self;
2556     type DefaultType = Self;
2557 }
2558 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2559 #[repr(C)]
2560 pub struct DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OPERATOR_DESC {
2561     pub ATensor: *mut DML_TENSOR_DESC,
2562     pub BTensor: *mut DML_TENSOR_DESC,
2563     pub OutputTensor: *mut DML_TENSOR_DESC,
2564 }
2565 impl DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OPERATOR_DESC {}
2566 impl ::std::default::Default for DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OPERATOR_DESC {
default() -> Self2567     fn default() -> Self {
2568         unsafe { ::std::mem::zeroed() }
2569     }
2570 }
2571 impl ::std::fmt::Debug for DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2572     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2573         fmt.debug_struct("DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
2574     }
2575 }
2576 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2577     fn eq(&self, other: &Self) -> bool {
2578         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
2579     }
2580 }
2581 impl ::std::cmp::Eq for DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OPERATOR_DESC {}
2582 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OPERATOR_DESC {
2583     type Abi = Self;
2584     type DefaultType = Self;
2585 }
2586 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2587 #[repr(C)]
2588 pub struct DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OR_EQUAL_OPERATOR_DESC {
2589     pub ATensor: *mut DML_TENSOR_DESC,
2590     pub BTensor: *mut DML_TENSOR_DESC,
2591     pub OutputTensor: *mut DML_TENSOR_DESC,
2592 }
2593 impl DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OR_EQUAL_OPERATOR_DESC {}
2594 impl ::std::default::Default for DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OR_EQUAL_OPERATOR_DESC {
default() -> Self2595     fn default() -> Self {
2596         unsafe { ::std::mem::zeroed() }
2597     }
2598 }
2599 impl ::std::fmt::Debug for DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OR_EQUAL_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2600     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2601         fmt.debug_struct("DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OR_EQUAL_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
2602     }
2603 }
2604 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OR_EQUAL_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2605     fn eq(&self, other: &Self) -> bool {
2606         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
2607     }
2608 }
2609 impl ::std::cmp::Eq for DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OR_EQUAL_OPERATOR_DESC {}
2610 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_LOGICAL_GREATER_THAN_OR_EQUAL_OPERATOR_DESC {
2611     type Abi = Self;
2612     type DefaultType = Self;
2613 }
2614 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2615 #[repr(C)]
2616 pub struct DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OPERATOR_DESC {
2617     pub ATensor: *mut DML_TENSOR_DESC,
2618     pub BTensor: *mut DML_TENSOR_DESC,
2619     pub OutputTensor: *mut DML_TENSOR_DESC,
2620 }
2621 impl DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OPERATOR_DESC {}
2622 impl ::std::default::Default for DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OPERATOR_DESC {
default() -> Self2623     fn default() -> Self {
2624         unsafe { ::std::mem::zeroed() }
2625     }
2626 }
2627 impl ::std::fmt::Debug for DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2628     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2629         fmt.debug_struct("DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
2630     }
2631 }
2632 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2633     fn eq(&self, other: &Self) -> bool {
2634         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
2635     }
2636 }
2637 impl ::std::cmp::Eq for DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OPERATOR_DESC {}
2638 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OPERATOR_DESC {
2639     type Abi = Self;
2640     type DefaultType = Self;
2641 }
2642 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2643 #[repr(C)]
2644 pub struct DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OR_EQUAL_OPERATOR_DESC {
2645     pub ATensor: *mut DML_TENSOR_DESC,
2646     pub BTensor: *mut DML_TENSOR_DESC,
2647     pub OutputTensor: *mut DML_TENSOR_DESC,
2648 }
2649 impl DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OR_EQUAL_OPERATOR_DESC {}
2650 impl ::std::default::Default for DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OR_EQUAL_OPERATOR_DESC {
default() -> Self2651     fn default() -> Self {
2652         unsafe { ::std::mem::zeroed() }
2653     }
2654 }
2655 impl ::std::fmt::Debug for DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OR_EQUAL_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2656     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2657         fmt.debug_struct("DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OR_EQUAL_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
2658     }
2659 }
2660 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OR_EQUAL_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2661     fn eq(&self, other: &Self) -> bool {
2662         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
2663     }
2664 }
2665 impl ::std::cmp::Eq for DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OR_EQUAL_OPERATOR_DESC {}
2666 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_LOGICAL_LESS_THAN_OR_EQUAL_OPERATOR_DESC {
2667     type Abi = Self;
2668     type DefaultType = Self;
2669 }
2670 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2671 #[repr(C)]
2672 pub struct DML_ELEMENT_WISE_LOGICAL_NOT_OPERATOR_DESC {
2673     pub InputTensor: *mut DML_TENSOR_DESC,
2674     pub OutputTensor: *mut DML_TENSOR_DESC,
2675 }
2676 impl DML_ELEMENT_WISE_LOGICAL_NOT_OPERATOR_DESC {}
2677 impl ::std::default::Default for DML_ELEMENT_WISE_LOGICAL_NOT_OPERATOR_DESC {
default() -> Self2678     fn default() -> Self {
2679         unsafe { ::std::mem::zeroed() }
2680     }
2681 }
2682 impl ::std::fmt::Debug for DML_ELEMENT_WISE_LOGICAL_NOT_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2683     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2684         fmt.debug_struct("DML_ELEMENT_WISE_LOGICAL_NOT_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).finish()
2685     }
2686 }
2687 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_LOGICAL_NOT_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2688     fn eq(&self, other: &Self) -> bool {
2689         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor
2690     }
2691 }
2692 impl ::std::cmp::Eq for DML_ELEMENT_WISE_LOGICAL_NOT_OPERATOR_DESC {}
2693 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_LOGICAL_NOT_OPERATOR_DESC {
2694     type Abi = Self;
2695     type DefaultType = Self;
2696 }
2697 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2698 #[repr(C)]
2699 pub struct DML_ELEMENT_WISE_LOGICAL_OR_OPERATOR_DESC {
2700     pub ATensor: *mut DML_TENSOR_DESC,
2701     pub BTensor: *mut DML_TENSOR_DESC,
2702     pub OutputTensor: *mut DML_TENSOR_DESC,
2703 }
2704 impl DML_ELEMENT_WISE_LOGICAL_OR_OPERATOR_DESC {}
2705 impl ::std::default::Default for DML_ELEMENT_WISE_LOGICAL_OR_OPERATOR_DESC {
default() -> Self2706     fn default() -> Self {
2707         unsafe { ::std::mem::zeroed() }
2708     }
2709 }
2710 impl ::std::fmt::Debug for DML_ELEMENT_WISE_LOGICAL_OR_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2711     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2712         fmt.debug_struct("DML_ELEMENT_WISE_LOGICAL_OR_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
2713     }
2714 }
2715 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_LOGICAL_OR_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2716     fn eq(&self, other: &Self) -> bool {
2717         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
2718     }
2719 }
2720 impl ::std::cmp::Eq for DML_ELEMENT_WISE_LOGICAL_OR_OPERATOR_DESC {}
2721 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_LOGICAL_OR_OPERATOR_DESC {
2722     type Abi = Self;
2723     type DefaultType = Self;
2724 }
2725 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2726 #[repr(C)]
2727 pub struct DML_ELEMENT_WISE_LOGICAL_XOR_OPERATOR_DESC {
2728     pub ATensor: *mut DML_TENSOR_DESC,
2729     pub BTensor: *mut DML_TENSOR_DESC,
2730     pub OutputTensor: *mut DML_TENSOR_DESC,
2731 }
2732 impl DML_ELEMENT_WISE_LOGICAL_XOR_OPERATOR_DESC {}
2733 impl ::std::default::Default for DML_ELEMENT_WISE_LOGICAL_XOR_OPERATOR_DESC {
default() -> Self2734     fn default() -> Self {
2735         unsafe { ::std::mem::zeroed() }
2736     }
2737 }
2738 impl ::std::fmt::Debug for DML_ELEMENT_WISE_LOGICAL_XOR_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2739     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2740         fmt.debug_struct("DML_ELEMENT_WISE_LOGICAL_XOR_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
2741     }
2742 }
2743 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_LOGICAL_XOR_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2744     fn eq(&self, other: &Self) -> bool {
2745         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
2746     }
2747 }
2748 impl ::std::cmp::Eq for DML_ELEMENT_WISE_LOGICAL_XOR_OPERATOR_DESC {}
2749 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_LOGICAL_XOR_OPERATOR_DESC {
2750     type Abi = Self;
2751     type DefaultType = Self;
2752 }
2753 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2754 #[repr(C)]
2755 pub struct DML_ELEMENT_WISE_LOG_OPERATOR_DESC {
2756     pub InputTensor: *mut DML_TENSOR_DESC,
2757     pub OutputTensor: *mut DML_TENSOR_DESC,
2758     pub ScaleBias: *mut DML_SCALE_BIAS,
2759 }
2760 impl DML_ELEMENT_WISE_LOG_OPERATOR_DESC {}
2761 impl ::std::default::Default for DML_ELEMENT_WISE_LOG_OPERATOR_DESC {
default() -> Self2762     fn default() -> Self {
2763         unsafe { ::std::mem::zeroed() }
2764     }
2765 }
2766 impl ::std::fmt::Debug for DML_ELEMENT_WISE_LOG_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2767     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2768         fmt.debug_struct("DML_ELEMENT_WISE_LOG_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).finish()
2769     }
2770 }
2771 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_LOG_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2772     fn eq(&self, other: &Self) -> bool {
2773         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias
2774     }
2775 }
2776 impl ::std::cmp::Eq for DML_ELEMENT_WISE_LOG_OPERATOR_DESC {}
2777 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_LOG_OPERATOR_DESC {
2778     type Abi = Self;
2779     type DefaultType = Self;
2780 }
2781 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2782 #[repr(C)]
2783 pub struct DML_ELEMENT_WISE_MAX_OPERATOR_DESC {
2784     pub ATensor: *mut DML_TENSOR_DESC,
2785     pub BTensor: *mut DML_TENSOR_DESC,
2786     pub OutputTensor: *mut DML_TENSOR_DESC,
2787 }
2788 impl DML_ELEMENT_WISE_MAX_OPERATOR_DESC {}
2789 impl ::std::default::Default for DML_ELEMENT_WISE_MAX_OPERATOR_DESC {
default() -> Self2790     fn default() -> Self {
2791         unsafe { ::std::mem::zeroed() }
2792     }
2793 }
2794 impl ::std::fmt::Debug for DML_ELEMENT_WISE_MAX_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2795     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2796         fmt.debug_struct("DML_ELEMENT_WISE_MAX_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
2797     }
2798 }
2799 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_MAX_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2800     fn eq(&self, other: &Self) -> bool {
2801         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
2802     }
2803 }
2804 impl ::std::cmp::Eq for DML_ELEMENT_WISE_MAX_OPERATOR_DESC {}
2805 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_MAX_OPERATOR_DESC {
2806     type Abi = Self;
2807     type DefaultType = Self;
2808 }
2809 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2810 #[repr(C)]
2811 pub struct DML_ELEMENT_WISE_MEAN_OPERATOR_DESC {
2812     pub ATensor: *mut DML_TENSOR_DESC,
2813     pub BTensor: *mut DML_TENSOR_DESC,
2814     pub OutputTensor: *mut DML_TENSOR_DESC,
2815 }
2816 impl DML_ELEMENT_WISE_MEAN_OPERATOR_DESC {}
2817 impl ::std::default::Default for DML_ELEMENT_WISE_MEAN_OPERATOR_DESC {
default() -> Self2818     fn default() -> Self {
2819         unsafe { ::std::mem::zeroed() }
2820     }
2821 }
2822 impl ::std::fmt::Debug for DML_ELEMENT_WISE_MEAN_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2823     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2824         fmt.debug_struct("DML_ELEMENT_WISE_MEAN_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
2825     }
2826 }
2827 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_MEAN_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2828     fn eq(&self, other: &Self) -> bool {
2829         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
2830     }
2831 }
2832 impl ::std::cmp::Eq for DML_ELEMENT_WISE_MEAN_OPERATOR_DESC {}
2833 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_MEAN_OPERATOR_DESC {
2834     type Abi = Self;
2835     type DefaultType = Self;
2836 }
2837 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2838 #[repr(C)]
2839 pub struct DML_ELEMENT_WISE_MIN_OPERATOR_DESC {
2840     pub ATensor: *mut DML_TENSOR_DESC,
2841     pub BTensor: *mut DML_TENSOR_DESC,
2842     pub OutputTensor: *mut DML_TENSOR_DESC,
2843 }
2844 impl DML_ELEMENT_WISE_MIN_OPERATOR_DESC {}
2845 impl ::std::default::Default for DML_ELEMENT_WISE_MIN_OPERATOR_DESC {
default() -> Self2846     fn default() -> Self {
2847         unsafe { ::std::mem::zeroed() }
2848     }
2849 }
2850 impl ::std::fmt::Debug for DML_ELEMENT_WISE_MIN_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2851     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2852         fmt.debug_struct("DML_ELEMENT_WISE_MIN_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
2853     }
2854 }
2855 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_MIN_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2856     fn eq(&self, other: &Self) -> bool {
2857         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
2858     }
2859 }
2860 impl ::std::cmp::Eq for DML_ELEMENT_WISE_MIN_OPERATOR_DESC {}
2861 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_MIN_OPERATOR_DESC {
2862     type Abi = Self;
2863     type DefaultType = Self;
2864 }
2865 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2866 #[repr(C)]
2867 pub struct DML_ELEMENT_WISE_MODULUS_FLOOR_OPERATOR_DESC {
2868     pub ATensor: *mut DML_TENSOR_DESC,
2869     pub BTensor: *mut DML_TENSOR_DESC,
2870     pub OutputTensor: *mut DML_TENSOR_DESC,
2871 }
2872 impl DML_ELEMENT_WISE_MODULUS_FLOOR_OPERATOR_DESC {}
2873 impl ::std::default::Default for DML_ELEMENT_WISE_MODULUS_FLOOR_OPERATOR_DESC {
default() -> Self2874     fn default() -> Self {
2875         unsafe { ::std::mem::zeroed() }
2876     }
2877 }
2878 impl ::std::fmt::Debug for DML_ELEMENT_WISE_MODULUS_FLOOR_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2879     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2880         fmt.debug_struct("DML_ELEMENT_WISE_MODULUS_FLOOR_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
2881     }
2882 }
2883 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_MODULUS_FLOOR_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2884     fn eq(&self, other: &Self) -> bool {
2885         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
2886     }
2887 }
2888 impl ::std::cmp::Eq for DML_ELEMENT_WISE_MODULUS_FLOOR_OPERATOR_DESC {}
2889 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_MODULUS_FLOOR_OPERATOR_DESC {
2890     type Abi = Self;
2891     type DefaultType = Self;
2892 }
2893 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2894 #[repr(C)]
2895 pub struct DML_ELEMENT_WISE_MODULUS_TRUNCATE_OPERATOR_DESC {
2896     pub ATensor: *mut DML_TENSOR_DESC,
2897     pub BTensor: *mut DML_TENSOR_DESC,
2898     pub OutputTensor: *mut DML_TENSOR_DESC,
2899 }
2900 impl DML_ELEMENT_WISE_MODULUS_TRUNCATE_OPERATOR_DESC {}
2901 impl ::std::default::Default for DML_ELEMENT_WISE_MODULUS_TRUNCATE_OPERATOR_DESC {
default() -> Self2902     fn default() -> Self {
2903         unsafe { ::std::mem::zeroed() }
2904     }
2905 }
2906 impl ::std::fmt::Debug for DML_ELEMENT_WISE_MODULUS_TRUNCATE_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2907     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2908         fmt.debug_struct("DML_ELEMENT_WISE_MODULUS_TRUNCATE_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
2909     }
2910 }
2911 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_MODULUS_TRUNCATE_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2912     fn eq(&self, other: &Self) -> bool {
2913         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
2914     }
2915 }
2916 impl ::std::cmp::Eq for DML_ELEMENT_WISE_MODULUS_TRUNCATE_OPERATOR_DESC {}
2917 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_MODULUS_TRUNCATE_OPERATOR_DESC {
2918     type Abi = Self;
2919     type DefaultType = Self;
2920 }
2921 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2922 #[repr(C)]
2923 pub struct DML_ELEMENT_WISE_MULTIPLY_OPERATOR_DESC {
2924     pub ATensor: *mut DML_TENSOR_DESC,
2925     pub BTensor: *mut DML_TENSOR_DESC,
2926     pub OutputTensor: *mut DML_TENSOR_DESC,
2927 }
2928 impl DML_ELEMENT_WISE_MULTIPLY_OPERATOR_DESC {}
2929 impl ::std::default::Default for DML_ELEMENT_WISE_MULTIPLY_OPERATOR_DESC {
default() -> Self2930     fn default() -> Self {
2931         unsafe { ::std::mem::zeroed() }
2932     }
2933 }
2934 impl ::std::fmt::Debug for DML_ELEMENT_WISE_MULTIPLY_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2935     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2936         fmt.debug_struct("DML_ELEMENT_WISE_MULTIPLY_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
2937     }
2938 }
2939 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_MULTIPLY_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2940     fn eq(&self, other: &Self) -> bool {
2941         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
2942     }
2943 }
2944 impl ::std::cmp::Eq for DML_ELEMENT_WISE_MULTIPLY_OPERATOR_DESC {}
2945 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_MULTIPLY_OPERATOR_DESC {
2946     type Abi = Self;
2947     type DefaultType = Self;
2948 }
2949 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2950 #[repr(C)]
2951 pub struct DML_ELEMENT_WISE_POW_OPERATOR_DESC {
2952     pub InputTensor: *mut DML_TENSOR_DESC,
2953     pub ExponentTensor: *mut DML_TENSOR_DESC,
2954     pub OutputTensor: *mut DML_TENSOR_DESC,
2955     pub ScaleBias: *mut DML_SCALE_BIAS,
2956 }
2957 impl DML_ELEMENT_WISE_POW_OPERATOR_DESC {}
2958 impl ::std::default::Default for DML_ELEMENT_WISE_POW_OPERATOR_DESC {
default() -> Self2959     fn default() -> Self {
2960         unsafe { ::std::mem::zeroed() }
2961     }
2962 }
2963 impl ::std::fmt::Debug for DML_ELEMENT_WISE_POW_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2964     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2965         fmt.debug_struct("DML_ELEMENT_WISE_POW_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("ExponentTensor", &self.ExponentTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).finish()
2966     }
2967 }
2968 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_POW_OPERATOR_DESC {
eq(&self, other: &Self) -> bool2969     fn eq(&self, other: &Self) -> bool {
2970         self.InputTensor == other.InputTensor && self.ExponentTensor == other.ExponentTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias
2971     }
2972 }
2973 impl ::std::cmp::Eq for DML_ELEMENT_WISE_POW_OPERATOR_DESC {}
2974 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_POW_OPERATOR_DESC {
2975     type Abi = Self;
2976     type DefaultType = Self;
2977 }
2978 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
2979 #[repr(C)]
2980 pub struct DML_ELEMENT_WISE_QUANTIZED_LINEAR_ADD_OPERATOR_DESC {
2981     pub ATensor: *mut DML_TENSOR_DESC,
2982     pub AScaleTensor: *mut DML_TENSOR_DESC,
2983     pub AZeroPointTensor: *mut DML_TENSOR_DESC,
2984     pub BTensor: *mut DML_TENSOR_DESC,
2985     pub BScaleTensor: *mut DML_TENSOR_DESC,
2986     pub BZeroPointTensor: *mut DML_TENSOR_DESC,
2987     pub OutputScaleTensor: *mut DML_TENSOR_DESC,
2988     pub OutputZeroPointTensor: *mut DML_TENSOR_DESC,
2989     pub OutputTensor: *mut DML_TENSOR_DESC,
2990 }
2991 impl DML_ELEMENT_WISE_QUANTIZED_LINEAR_ADD_OPERATOR_DESC {}
2992 impl ::std::default::Default for DML_ELEMENT_WISE_QUANTIZED_LINEAR_ADD_OPERATOR_DESC {
default() -> Self2993     fn default() -> Self {
2994         unsafe { ::std::mem::zeroed() }
2995     }
2996 }
2997 impl ::std::fmt::Debug for DML_ELEMENT_WISE_QUANTIZED_LINEAR_ADD_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result2998     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2999         fmt.debug_struct("DML_ELEMENT_WISE_QUANTIZED_LINEAR_ADD_OPERATOR_DESC")
3000             .field("ATensor", &self.ATensor)
3001             .field("AScaleTensor", &self.AScaleTensor)
3002             .field("AZeroPointTensor", &self.AZeroPointTensor)
3003             .field("BTensor", &self.BTensor)
3004             .field("BScaleTensor", &self.BScaleTensor)
3005             .field("BZeroPointTensor", &self.BZeroPointTensor)
3006             .field("OutputScaleTensor", &self.OutputScaleTensor)
3007             .field("OutputZeroPointTensor", &self.OutputZeroPointTensor)
3008             .field("OutputTensor", &self.OutputTensor)
3009             .finish()
3010     }
3011 }
3012 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_QUANTIZED_LINEAR_ADD_OPERATOR_DESC {
eq(&self, other: &Self) -> bool3013     fn eq(&self, other: &Self) -> bool {
3014         self.ATensor == other.ATensor && self.AScaleTensor == other.AScaleTensor && self.AZeroPointTensor == other.AZeroPointTensor && self.BTensor == other.BTensor && self.BScaleTensor == other.BScaleTensor && self.BZeroPointTensor == other.BZeroPointTensor && self.OutputScaleTensor == other.OutputScaleTensor && self.OutputZeroPointTensor == other.OutputZeroPointTensor && self.OutputTensor == other.OutputTensor
3015     }
3016 }
3017 impl ::std::cmp::Eq for DML_ELEMENT_WISE_QUANTIZED_LINEAR_ADD_OPERATOR_DESC {}
3018 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_QUANTIZED_LINEAR_ADD_OPERATOR_DESC {
3019     type Abi = Self;
3020     type DefaultType = Self;
3021 }
3022 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3023 #[repr(C)]
3024 pub struct DML_ELEMENT_WISE_QUANTIZE_LINEAR_OPERATOR_DESC {
3025     pub InputTensor: *mut DML_TENSOR_DESC,
3026     pub ScaleTensor: *mut DML_TENSOR_DESC,
3027     pub ZeroPointTensor: *mut DML_TENSOR_DESC,
3028     pub OutputTensor: *mut DML_TENSOR_DESC,
3029 }
3030 impl DML_ELEMENT_WISE_QUANTIZE_LINEAR_OPERATOR_DESC {}
3031 impl ::std::default::Default for DML_ELEMENT_WISE_QUANTIZE_LINEAR_OPERATOR_DESC {
default() -> Self3032     fn default() -> Self {
3033         unsafe { ::std::mem::zeroed() }
3034     }
3035 }
3036 impl ::std::fmt::Debug for DML_ELEMENT_WISE_QUANTIZE_LINEAR_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3037     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3038         fmt.debug_struct("DML_ELEMENT_WISE_QUANTIZE_LINEAR_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("ScaleTensor", &self.ScaleTensor).field("ZeroPointTensor", &self.ZeroPointTensor).field("OutputTensor", &self.OutputTensor).finish()
3039     }
3040 }
3041 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_QUANTIZE_LINEAR_OPERATOR_DESC {
eq(&self, other: &Self) -> bool3042     fn eq(&self, other: &Self) -> bool {
3043         self.InputTensor == other.InputTensor && self.ScaleTensor == other.ScaleTensor && self.ZeroPointTensor == other.ZeroPointTensor && self.OutputTensor == other.OutputTensor
3044     }
3045 }
3046 impl ::std::cmp::Eq for DML_ELEMENT_WISE_QUANTIZE_LINEAR_OPERATOR_DESC {}
3047 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_QUANTIZE_LINEAR_OPERATOR_DESC {
3048     type Abi = Self;
3049     type DefaultType = Self;
3050 }
3051 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3052 #[repr(C)]
3053 pub struct DML_ELEMENT_WISE_RECIP_OPERATOR_DESC {
3054     pub InputTensor: *mut DML_TENSOR_DESC,
3055     pub OutputTensor: *mut DML_TENSOR_DESC,
3056     pub ScaleBias: *mut DML_SCALE_BIAS,
3057 }
3058 impl DML_ELEMENT_WISE_RECIP_OPERATOR_DESC {}
3059 impl ::std::default::Default for DML_ELEMENT_WISE_RECIP_OPERATOR_DESC {
default() -> Self3060     fn default() -> Self {
3061         unsafe { ::std::mem::zeroed() }
3062     }
3063 }
3064 impl ::std::fmt::Debug for DML_ELEMENT_WISE_RECIP_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3065     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3066         fmt.debug_struct("DML_ELEMENT_WISE_RECIP_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).finish()
3067     }
3068 }
3069 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_RECIP_OPERATOR_DESC {
eq(&self, other: &Self) -> bool3070     fn eq(&self, other: &Self) -> bool {
3071         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias
3072     }
3073 }
3074 impl ::std::cmp::Eq for DML_ELEMENT_WISE_RECIP_OPERATOR_DESC {}
3075 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_RECIP_OPERATOR_DESC {
3076     type Abi = Self;
3077     type DefaultType = Self;
3078 }
3079 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3080 #[repr(C)]
3081 pub struct DML_ELEMENT_WISE_ROUND_OPERATOR_DESC {
3082     pub InputTensor: *mut DML_TENSOR_DESC,
3083     pub OutputTensor: *mut DML_TENSOR_DESC,
3084     pub RoundingMode: DML_ROUNDING_MODE,
3085 }
3086 impl DML_ELEMENT_WISE_ROUND_OPERATOR_DESC {}
3087 impl ::std::default::Default for DML_ELEMENT_WISE_ROUND_OPERATOR_DESC {
default() -> Self3088     fn default() -> Self {
3089         unsafe { ::std::mem::zeroed() }
3090     }
3091 }
3092 impl ::std::fmt::Debug for DML_ELEMENT_WISE_ROUND_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3093     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3094         fmt.debug_struct("DML_ELEMENT_WISE_ROUND_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("RoundingMode", &self.RoundingMode).finish()
3095     }
3096 }
3097 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_ROUND_OPERATOR_DESC {
eq(&self, other: &Self) -> bool3098     fn eq(&self, other: &Self) -> bool {
3099         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.RoundingMode == other.RoundingMode
3100     }
3101 }
3102 impl ::std::cmp::Eq for DML_ELEMENT_WISE_ROUND_OPERATOR_DESC {}
3103 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_ROUND_OPERATOR_DESC {
3104     type Abi = Self;
3105     type DefaultType = Self;
3106 }
3107 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3108 #[repr(C)]
3109 pub struct DML_ELEMENT_WISE_SIGN_OPERATOR_DESC {
3110     pub InputTensor: *mut DML_TENSOR_DESC,
3111     pub OutputTensor: *mut DML_TENSOR_DESC,
3112 }
3113 impl DML_ELEMENT_WISE_SIGN_OPERATOR_DESC {}
3114 impl ::std::default::Default for DML_ELEMENT_WISE_SIGN_OPERATOR_DESC {
default() -> Self3115     fn default() -> Self {
3116         unsafe { ::std::mem::zeroed() }
3117     }
3118 }
3119 impl ::std::fmt::Debug for DML_ELEMENT_WISE_SIGN_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3120     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3121         fmt.debug_struct("DML_ELEMENT_WISE_SIGN_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).finish()
3122     }
3123 }
3124 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_SIGN_OPERATOR_DESC {
eq(&self, other: &Self) -> bool3125     fn eq(&self, other: &Self) -> bool {
3126         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor
3127     }
3128 }
3129 impl ::std::cmp::Eq for DML_ELEMENT_WISE_SIGN_OPERATOR_DESC {}
3130 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_SIGN_OPERATOR_DESC {
3131     type Abi = Self;
3132     type DefaultType = Self;
3133 }
3134 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3135 #[repr(C)]
3136 pub struct DML_ELEMENT_WISE_SINH_OPERATOR_DESC {
3137     pub InputTensor: *mut DML_TENSOR_DESC,
3138     pub OutputTensor: *mut DML_TENSOR_DESC,
3139     pub ScaleBias: *mut DML_SCALE_BIAS,
3140 }
3141 impl DML_ELEMENT_WISE_SINH_OPERATOR_DESC {}
3142 impl ::std::default::Default for DML_ELEMENT_WISE_SINH_OPERATOR_DESC {
default() -> Self3143     fn default() -> Self {
3144         unsafe { ::std::mem::zeroed() }
3145     }
3146 }
3147 impl ::std::fmt::Debug for DML_ELEMENT_WISE_SINH_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3148     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3149         fmt.debug_struct("DML_ELEMENT_WISE_SINH_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).finish()
3150     }
3151 }
3152 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_SINH_OPERATOR_DESC {
eq(&self, other: &Self) -> bool3153     fn eq(&self, other: &Self) -> bool {
3154         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias
3155     }
3156 }
3157 impl ::std::cmp::Eq for DML_ELEMENT_WISE_SINH_OPERATOR_DESC {}
3158 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_SINH_OPERATOR_DESC {
3159     type Abi = Self;
3160     type DefaultType = Self;
3161 }
3162 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3163 #[repr(C)]
3164 pub struct DML_ELEMENT_WISE_SIN_OPERATOR_DESC {
3165     pub InputTensor: *mut DML_TENSOR_DESC,
3166     pub OutputTensor: *mut DML_TENSOR_DESC,
3167     pub ScaleBias: *mut DML_SCALE_BIAS,
3168 }
3169 impl DML_ELEMENT_WISE_SIN_OPERATOR_DESC {}
3170 impl ::std::default::Default for DML_ELEMENT_WISE_SIN_OPERATOR_DESC {
default() -> Self3171     fn default() -> Self {
3172         unsafe { ::std::mem::zeroed() }
3173     }
3174 }
3175 impl ::std::fmt::Debug for DML_ELEMENT_WISE_SIN_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3176     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3177         fmt.debug_struct("DML_ELEMENT_WISE_SIN_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).finish()
3178     }
3179 }
3180 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_SIN_OPERATOR_DESC {
eq(&self, other: &Self) -> bool3181     fn eq(&self, other: &Self) -> bool {
3182         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias
3183     }
3184 }
3185 impl ::std::cmp::Eq for DML_ELEMENT_WISE_SIN_OPERATOR_DESC {}
3186 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_SIN_OPERATOR_DESC {
3187     type Abi = Self;
3188     type DefaultType = Self;
3189 }
3190 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3191 #[repr(C)]
3192 pub struct DML_ELEMENT_WISE_SQRT_OPERATOR_DESC {
3193     pub InputTensor: *mut DML_TENSOR_DESC,
3194     pub OutputTensor: *mut DML_TENSOR_DESC,
3195     pub ScaleBias: *mut DML_SCALE_BIAS,
3196 }
3197 impl DML_ELEMENT_WISE_SQRT_OPERATOR_DESC {}
3198 impl ::std::default::Default for DML_ELEMENT_WISE_SQRT_OPERATOR_DESC {
default() -> Self3199     fn default() -> Self {
3200         unsafe { ::std::mem::zeroed() }
3201     }
3202 }
3203 impl ::std::fmt::Debug for DML_ELEMENT_WISE_SQRT_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3204     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3205         fmt.debug_struct("DML_ELEMENT_WISE_SQRT_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).finish()
3206     }
3207 }
3208 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_SQRT_OPERATOR_DESC {
eq(&self, other: &Self) -> bool3209     fn eq(&self, other: &Self) -> bool {
3210         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias
3211     }
3212 }
3213 impl ::std::cmp::Eq for DML_ELEMENT_WISE_SQRT_OPERATOR_DESC {}
3214 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_SQRT_OPERATOR_DESC {
3215     type Abi = Self;
3216     type DefaultType = Self;
3217 }
3218 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3219 #[repr(C)]
3220 pub struct DML_ELEMENT_WISE_SUBTRACT_OPERATOR_DESC {
3221     pub ATensor: *mut DML_TENSOR_DESC,
3222     pub BTensor: *mut DML_TENSOR_DESC,
3223     pub OutputTensor: *mut DML_TENSOR_DESC,
3224 }
3225 impl DML_ELEMENT_WISE_SUBTRACT_OPERATOR_DESC {}
3226 impl ::std::default::Default for DML_ELEMENT_WISE_SUBTRACT_OPERATOR_DESC {
default() -> Self3227     fn default() -> Self {
3228         unsafe { ::std::mem::zeroed() }
3229     }
3230 }
3231 impl ::std::fmt::Debug for DML_ELEMENT_WISE_SUBTRACT_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3232     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3233         fmt.debug_struct("DML_ELEMENT_WISE_SUBTRACT_OPERATOR_DESC").field("ATensor", &self.ATensor).field("BTensor", &self.BTensor).field("OutputTensor", &self.OutputTensor).finish()
3234     }
3235 }
3236 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_SUBTRACT_OPERATOR_DESC {
eq(&self, other: &Self) -> bool3237     fn eq(&self, other: &Self) -> bool {
3238         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.OutputTensor == other.OutputTensor
3239     }
3240 }
3241 impl ::std::cmp::Eq for DML_ELEMENT_WISE_SUBTRACT_OPERATOR_DESC {}
3242 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_SUBTRACT_OPERATOR_DESC {
3243     type Abi = Self;
3244     type DefaultType = Self;
3245 }
3246 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3247 #[repr(C)]
3248 pub struct DML_ELEMENT_WISE_TANH_OPERATOR_DESC {
3249     pub InputTensor: *mut DML_TENSOR_DESC,
3250     pub OutputTensor: *mut DML_TENSOR_DESC,
3251     pub ScaleBias: *mut DML_SCALE_BIAS,
3252 }
3253 impl DML_ELEMENT_WISE_TANH_OPERATOR_DESC {}
3254 impl ::std::default::Default for DML_ELEMENT_WISE_TANH_OPERATOR_DESC {
default() -> Self3255     fn default() -> Self {
3256         unsafe { ::std::mem::zeroed() }
3257     }
3258 }
3259 impl ::std::fmt::Debug for DML_ELEMENT_WISE_TANH_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3260     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3261         fmt.debug_struct("DML_ELEMENT_WISE_TANH_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).finish()
3262     }
3263 }
3264 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_TANH_OPERATOR_DESC {
eq(&self, other: &Self) -> bool3265     fn eq(&self, other: &Self) -> bool {
3266         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias
3267     }
3268 }
3269 impl ::std::cmp::Eq for DML_ELEMENT_WISE_TANH_OPERATOR_DESC {}
3270 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_TANH_OPERATOR_DESC {
3271     type Abi = Self;
3272     type DefaultType = Self;
3273 }
3274 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3275 #[repr(C)]
3276 pub struct DML_ELEMENT_WISE_TAN_OPERATOR_DESC {
3277     pub InputTensor: *mut DML_TENSOR_DESC,
3278     pub OutputTensor: *mut DML_TENSOR_DESC,
3279     pub ScaleBias: *mut DML_SCALE_BIAS,
3280 }
3281 impl DML_ELEMENT_WISE_TAN_OPERATOR_DESC {}
3282 impl ::std::default::Default for DML_ELEMENT_WISE_TAN_OPERATOR_DESC {
default() -> Self3283     fn default() -> Self {
3284         unsafe { ::std::mem::zeroed() }
3285     }
3286 }
3287 impl ::std::fmt::Debug for DML_ELEMENT_WISE_TAN_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3288     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3289         fmt.debug_struct("DML_ELEMENT_WISE_TAN_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).finish()
3290     }
3291 }
3292 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_TAN_OPERATOR_DESC {
eq(&self, other: &Self) -> bool3293     fn eq(&self, other: &Self) -> bool {
3294         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias
3295     }
3296 }
3297 impl ::std::cmp::Eq for DML_ELEMENT_WISE_TAN_OPERATOR_DESC {}
3298 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_TAN_OPERATOR_DESC {
3299     type Abi = Self;
3300     type DefaultType = Self;
3301 }
3302 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3303 #[repr(C)]
3304 pub struct DML_ELEMENT_WISE_THRESHOLD_OPERATOR_DESC {
3305     pub InputTensor: *mut DML_TENSOR_DESC,
3306     pub OutputTensor: *mut DML_TENSOR_DESC,
3307     pub ScaleBias: *mut DML_SCALE_BIAS,
3308     pub Min: f32,
3309 }
3310 impl DML_ELEMENT_WISE_THRESHOLD_OPERATOR_DESC {}
3311 impl ::std::default::Default for DML_ELEMENT_WISE_THRESHOLD_OPERATOR_DESC {
default() -> Self3312     fn default() -> Self {
3313         unsafe { ::std::mem::zeroed() }
3314     }
3315 }
3316 impl ::std::fmt::Debug for DML_ELEMENT_WISE_THRESHOLD_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3317     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3318         fmt.debug_struct("DML_ELEMENT_WISE_THRESHOLD_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleBias", &self.ScaleBias).field("Min", &self.Min).finish()
3319     }
3320 }
3321 impl ::std::cmp::PartialEq for DML_ELEMENT_WISE_THRESHOLD_OPERATOR_DESC {
eq(&self, other: &Self) -> bool3322     fn eq(&self, other: &Self) -> bool {
3323         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleBias == other.ScaleBias && self.Min == other.Min
3324     }
3325 }
3326 impl ::std::cmp::Eq for DML_ELEMENT_WISE_THRESHOLD_OPERATOR_DESC {}
3327 unsafe impl ::windows::runtime::Abi for DML_ELEMENT_WISE_THRESHOLD_OPERATOR_DESC {
3328     type Abi = Self;
3329     type DefaultType = Self;
3330 }
3331 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3332 #[repr(transparent)]
3333 pub struct DML_EXECUTION_FLAGS(pub u32);
3334 pub const DML_EXECUTION_FLAG_NONE: DML_EXECUTION_FLAGS = DML_EXECUTION_FLAGS(0u32);
3335 pub const DML_EXECUTION_FLAG_ALLOW_HALF_PRECISION_COMPUTATION: DML_EXECUTION_FLAGS = DML_EXECUTION_FLAGS(1u32);
3336 pub const DML_EXECUTION_FLAG_DISABLE_META_COMMANDS: DML_EXECUTION_FLAGS = DML_EXECUTION_FLAGS(2u32);
3337 pub const DML_EXECUTION_FLAG_DESCRIPTORS_VOLATILE: DML_EXECUTION_FLAGS = DML_EXECUTION_FLAGS(4u32);
3338 impl ::std::convert::From<u32> for DML_EXECUTION_FLAGS {
from(value: u32) -> Self3339     fn from(value: u32) -> Self {
3340         Self(value)
3341     }
3342 }
3343 unsafe impl ::windows::runtime::Abi for DML_EXECUTION_FLAGS {
3344     type Abi = Self;
3345     type DefaultType = Self;
3346 }
3347 impl ::std::ops::BitOr for DML_EXECUTION_FLAGS {
3348     type Output = Self;
bitor(self, rhs: Self) -> Self3349     fn bitor(self, rhs: Self) -> Self {
3350         Self(self.0 | rhs.0)
3351     }
3352 }
3353 impl ::std::ops::BitAnd for DML_EXECUTION_FLAGS {
3354     type Output = Self;
bitand(self, rhs: Self) -> Self3355     fn bitand(self, rhs: Self) -> Self {
3356         Self(self.0 & rhs.0)
3357     }
3358 }
3359 impl ::std::ops::BitOrAssign for DML_EXECUTION_FLAGS {
bitor_assign(&mut self, rhs: Self)3360     fn bitor_assign(&mut self, rhs: Self) {
3361         self.0.bitor_assign(rhs.0)
3362     }
3363 }
3364 impl ::std::ops::BitAndAssign for DML_EXECUTION_FLAGS {
bitand_assign(&mut self, rhs: Self)3365     fn bitand_assign(&mut self, rhs: Self) {
3366         self.0.bitand_assign(rhs.0)
3367     }
3368 }
3369 impl ::std::ops::Not for DML_EXECUTION_FLAGS {
3370     type Output = Self;
not(self) -> Self3371     fn not(self) -> Self {
3372         Self(self.0.not())
3373     }
3374 }
3375 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3376 #[repr(transparent)]
3377 pub struct DML_FEATURE(pub i32);
3378 pub const DML_FEATURE_TENSOR_DATA_TYPE_SUPPORT: DML_FEATURE = DML_FEATURE(0i32);
3379 pub const DML_FEATURE_FEATURE_LEVELS: DML_FEATURE = DML_FEATURE(1i32);
3380 impl ::std::convert::From<i32> for DML_FEATURE {
from(value: i32) -> Self3381     fn from(value: i32) -> Self {
3382         Self(value)
3383     }
3384 }
3385 unsafe impl ::windows::runtime::Abi for DML_FEATURE {
3386     type Abi = Self;
3387     type DefaultType = Self;
3388 }
3389 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3390 #[repr(C)]
3391 pub struct DML_FEATURE_DATA_FEATURE_LEVELS {
3392     pub MaxSupportedFeatureLevel: DML_FEATURE_LEVEL,
3393 }
3394 impl DML_FEATURE_DATA_FEATURE_LEVELS {}
3395 impl ::std::default::Default for DML_FEATURE_DATA_FEATURE_LEVELS {
default() -> Self3396     fn default() -> Self {
3397         unsafe { ::std::mem::zeroed() }
3398     }
3399 }
3400 impl ::std::fmt::Debug for DML_FEATURE_DATA_FEATURE_LEVELS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3401     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3402         fmt.debug_struct("DML_FEATURE_DATA_FEATURE_LEVELS").field("MaxSupportedFeatureLevel", &self.MaxSupportedFeatureLevel).finish()
3403     }
3404 }
3405 impl ::std::cmp::PartialEq for DML_FEATURE_DATA_FEATURE_LEVELS {
eq(&self, other: &Self) -> bool3406     fn eq(&self, other: &Self) -> bool {
3407         self.MaxSupportedFeatureLevel == other.MaxSupportedFeatureLevel
3408     }
3409 }
3410 impl ::std::cmp::Eq for DML_FEATURE_DATA_FEATURE_LEVELS {}
3411 unsafe impl ::windows::runtime::Abi for DML_FEATURE_DATA_FEATURE_LEVELS {
3412     type Abi = Self;
3413     type DefaultType = Self;
3414 }
3415 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3416 #[repr(C)]
3417 #[cfg(feature = "Win32_Foundation")]
3418 pub struct DML_FEATURE_DATA_TENSOR_DATA_TYPE_SUPPORT {
3419     pub IsSupported: super::super::super::Foundation::BOOL,
3420 }
3421 #[cfg(feature = "Win32_Foundation")]
3422 impl DML_FEATURE_DATA_TENSOR_DATA_TYPE_SUPPORT {}
3423 #[cfg(feature = "Win32_Foundation")]
3424 impl ::std::default::Default for DML_FEATURE_DATA_TENSOR_DATA_TYPE_SUPPORT {
default() -> Self3425     fn default() -> Self {
3426         unsafe { ::std::mem::zeroed() }
3427     }
3428 }
3429 #[cfg(feature = "Win32_Foundation")]
3430 impl ::std::fmt::Debug for DML_FEATURE_DATA_TENSOR_DATA_TYPE_SUPPORT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3431     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3432         fmt.debug_struct("DML_FEATURE_DATA_TENSOR_DATA_TYPE_SUPPORT").field("IsSupported", &self.IsSupported).finish()
3433     }
3434 }
3435 #[cfg(feature = "Win32_Foundation")]
3436 impl ::std::cmp::PartialEq for DML_FEATURE_DATA_TENSOR_DATA_TYPE_SUPPORT {
eq(&self, other: &Self) -> bool3437     fn eq(&self, other: &Self) -> bool {
3438         self.IsSupported == other.IsSupported
3439     }
3440 }
3441 #[cfg(feature = "Win32_Foundation")]
3442 impl ::std::cmp::Eq for DML_FEATURE_DATA_TENSOR_DATA_TYPE_SUPPORT {}
3443 #[cfg(feature = "Win32_Foundation")]
3444 unsafe impl ::windows::runtime::Abi for DML_FEATURE_DATA_TENSOR_DATA_TYPE_SUPPORT {
3445     type Abi = Self;
3446     type DefaultType = Self;
3447 }
3448 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3449 #[repr(transparent)]
3450 pub struct DML_FEATURE_LEVEL(pub i32);
3451 pub const DML_FEATURE_LEVEL_1_0: DML_FEATURE_LEVEL = DML_FEATURE_LEVEL(4096i32);
3452 pub const DML_FEATURE_LEVEL_2_0: DML_FEATURE_LEVEL = DML_FEATURE_LEVEL(8192i32);
3453 pub const DML_FEATURE_LEVEL_2_1: DML_FEATURE_LEVEL = DML_FEATURE_LEVEL(8448i32);
3454 pub const DML_FEATURE_LEVEL_3_0: DML_FEATURE_LEVEL = DML_FEATURE_LEVEL(12288i32);
3455 pub const DML_FEATURE_LEVEL_3_1: DML_FEATURE_LEVEL = DML_FEATURE_LEVEL(12544i32);
3456 pub const DML_FEATURE_LEVEL_4_0: DML_FEATURE_LEVEL = DML_FEATURE_LEVEL(16384i32);
3457 impl ::std::convert::From<i32> for DML_FEATURE_LEVEL {
from(value: i32) -> Self3458     fn from(value: i32) -> Self {
3459         Self(value)
3460     }
3461 }
3462 unsafe impl ::windows::runtime::Abi for DML_FEATURE_LEVEL {
3463     type Abi = Self;
3464     type DefaultType = Self;
3465 }
3466 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3467 #[repr(C)]
3468 pub struct DML_FEATURE_QUERY_FEATURE_LEVELS {
3469     pub RequestedFeatureLevelCount: u32,
3470     pub RequestedFeatureLevels: *mut DML_FEATURE_LEVEL,
3471 }
3472 impl DML_FEATURE_QUERY_FEATURE_LEVELS {}
3473 impl ::std::default::Default for DML_FEATURE_QUERY_FEATURE_LEVELS {
default() -> Self3474     fn default() -> Self {
3475         unsafe { ::std::mem::zeroed() }
3476     }
3477 }
3478 impl ::std::fmt::Debug for DML_FEATURE_QUERY_FEATURE_LEVELS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3479     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3480         fmt.debug_struct("DML_FEATURE_QUERY_FEATURE_LEVELS").field("RequestedFeatureLevelCount", &self.RequestedFeatureLevelCount).field("RequestedFeatureLevels", &self.RequestedFeatureLevels).finish()
3481     }
3482 }
3483 impl ::std::cmp::PartialEq for DML_FEATURE_QUERY_FEATURE_LEVELS {
eq(&self, other: &Self) -> bool3484     fn eq(&self, other: &Self) -> bool {
3485         self.RequestedFeatureLevelCount == other.RequestedFeatureLevelCount && self.RequestedFeatureLevels == other.RequestedFeatureLevels
3486     }
3487 }
3488 impl ::std::cmp::Eq for DML_FEATURE_QUERY_FEATURE_LEVELS {}
3489 unsafe impl ::windows::runtime::Abi for DML_FEATURE_QUERY_FEATURE_LEVELS {
3490     type Abi = Self;
3491     type DefaultType = Self;
3492 }
3493 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3494 #[repr(C)]
3495 pub struct DML_FEATURE_QUERY_TENSOR_DATA_TYPE_SUPPORT {
3496     pub DataType: DML_TENSOR_DATA_TYPE,
3497 }
3498 impl DML_FEATURE_QUERY_TENSOR_DATA_TYPE_SUPPORT {}
3499 impl ::std::default::Default for DML_FEATURE_QUERY_TENSOR_DATA_TYPE_SUPPORT {
default() -> Self3500     fn default() -> Self {
3501         unsafe { ::std::mem::zeroed() }
3502     }
3503 }
3504 impl ::std::fmt::Debug for DML_FEATURE_QUERY_TENSOR_DATA_TYPE_SUPPORT {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3505     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3506         fmt.debug_struct("DML_FEATURE_QUERY_TENSOR_DATA_TYPE_SUPPORT").field("DataType", &self.DataType).finish()
3507     }
3508 }
3509 impl ::std::cmp::PartialEq for DML_FEATURE_QUERY_TENSOR_DATA_TYPE_SUPPORT {
eq(&self, other: &Self) -> bool3510     fn eq(&self, other: &Self) -> bool {
3511         self.DataType == other.DataType
3512     }
3513 }
3514 impl ::std::cmp::Eq for DML_FEATURE_QUERY_TENSOR_DATA_TYPE_SUPPORT {}
3515 unsafe impl ::windows::runtime::Abi for DML_FEATURE_QUERY_TENSOR_DATA_TYPE_SUPPORT {
3516     type Abi = Self;
3517     type DefaultType = Self;
3518 }
3519 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3520 #[repr(C)]
3521 pub struct DML_FILL_VALUE_CONSTANT_OPERATOR_DESC {
3522     pub OutputTensor: *mut DML_TENSOR_DESC,
3523     pub ValueDataType: DML_TENSOR_DATA_TYPE,
3524     pub Value: DML_SCALAR_UNION,
3525 }
3526 impl DML_FILL_VALUE_CONSTANT_OPERATOR_DESC {}
3527 impl ::std::default::Default for DML_FILL_VALUE_CONSTANT_OPERATOR_DESC {
default() -> Self3528     fn default() -> Self {
3529         unsafe { ::std::mem::zeroed() }
3530     }
3531 }
3532 impl ::std::cmp::PartialEq for DML_FILL_VALUE_CONSTANT_OPERATOR_DESC {
eq(&self, _other: &Self) -> bool3533     fn eq(&self, _other: &Self) -> bool {
3534         unimplemented!()
3535     }
3536 }
3537 impl ::std::cmp::Eq for DML_FILL_VALUE_CONSTANT_OPERATOR_DESC {}
3538 unsafe impl ::windows::runtime::Abi for DML_FILL_VALUE_CONSTANT_OPERATOR_DESC {
3539     type Abi = Self;
3540     type DefaultType = Self;
3541 }
3542 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3543 #[repr(C)]
3544 pub struct DML_FILL_VALUE_SEQUENCE_OPERATOR_DESC {
3545     pub OutputTensor: *mut DML_TENSOR_DESC,
3546     pub ValueDataType: DML_TENSOR_DATA_TYPE,
3547     pub ValueStart: DML_SCALAR_UNION,
3548     pub ValueDelta: DML_SCALAR_UNION,
3549 }
3550 impl DML_FILL_VALUE_SEQUENCE_OPERATOR_DESC {}
3551 impl ::std::default::Default for DML_FILL_VALUE_SEQUENCE_OPERATOR_DESC {
default() -> Self3552     fn default() -> Self {
3553         unsafe { ::std::mem::zeroed() }
3554     }
3555 }
3556 impl ::std::cmp::PartialEq for DML_FILL_VALUE_SEQUENCE_OPERATOR_DESC {
eq(&self, _other: &Self) -> bool3557     fn eq(&self, _other: &Self) -> bool {
3558         unimplemented!()
3559     }
3560 }
3561 impl ::std::cmp::Eq for DML_FILL_VALUE_SEQUENCE_OPERATOR_DESC {}
3562 unsafe impl ::windows::runtime::Abi for DML_FILL_VALUE_SEQUENCE_OPERATOR_DESC {
3563     type Abi = Self;
3564     type DefaultType = Self;
3565 }
3566 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3567 #[repr(C)]
3568 pub struct DML_GATHER_ELEMENTS_OPERATOR_DESC {
3569     pub InputTensor: *mut DML_TENSOR_DESC,
3570     pub IndicesTensor: *mut DML_TENSOR_DESC,
3571     pub OutputTensor: *mut DML_TENSOR_DESC,
3572     pub Axis: u32,
3573 }
3574 impl DML_GATHER_ELEMENTS_OPERATOR_DESC {}
3575 impl ::std::default::Default for DML_GATHER_ELEMENTS_OPERATOR_DESC {
default() -> Self3576     fn default() -> Self {
3577         unsafe { ::std::mem::zeroed() }
3578     }
3579 }
3580 impl ::std::fmt::Debug for DML_GATHER_ELEMENTS_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3581     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3582         fmt.debug_struct("DML_GATHER_ELEMENTS_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("IndicesTensor", &self.IndicesTensor).field("OutputTensor", &self.OutputTensor).field("Axis", &self.Axis).finish()
3583     }
3584 }
3585 impl ::std::cmp::PartialEq for DML_GATHER_ELEMENTS_OPERATOR_DESC {
eq(&self, other: &Self) -> bool3586     fn eq(&self, other: &Self) -> bool {
3587         self.InputTensor == other.InputTensor && self.IndicesTensor == other.IndicesTensor && self.OutputTensor == other.OutputTensor && self.Axis == other.Axis
3588     }
3589 }
3590 impl ::std::cmp::Eq for DML_GATHER_ELEMENTS_OPERATOR_DESC {}
3591 unsafe impl ::windows::runtime::Abi for DML_GATHER_ELEMENTS_OPERATOR_DESC {
3592     type Abi = Self;
3593     type DefaultType = Self;
3594 }
3595 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3596 #[repr(C)]
3597 pub struct DML_GATHER_ND1_OPERATOR_DESC {
3598     pub InputTensor: *mut DML_TENSOR_DESC,
3599     pub IndicesTensor: *mut DML_TENSOR_DESC,
3600     pub OutputTensor: *mut DML_TENSOR_DESC,
3601     pub InputDimensionCount: u32,
3602     pub IndicesDimensionCount: u32,
3603     pub BatchDimensionCount: u32,
3604 }
3605 impl DML_GATHER_ND1_OPERATOR_DESC {}
3606 impl ::std::default::Default for DML_GATHER_ND1_OPERATOR_DESC {
default() -> Self3607     fn default() -> Self {
3608         unsafe { ::std::mem::zeroed() }
3609     }
3610 }
3611 impl ::std::fmt::Debug for DML_GATHER_ND1_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3612     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3613         fmt.debug_struct("DML_GATHER_ND1_OPERATOR_DESC")
3614             .field("InputTensor", &self.InputTensor)
3615             .field("IndicesTensor", &self.IndicesTensor)
3616             .field("OutputTensor", &self.OutputTensor)
3617             .field("InputDimensionCount", &self.InputDimensionCount)
3618             .field("IndicesDimensionCount", &self.IndicesDimensionCount)
3619             .field("BatchDimensionCount", &self.BatchDimensionCount)
3620             .finish()
3621     }
3622 }
3623 impl ::std::cmp::PartialEq for DML_GATHER_ND1_OPERATOR_DESC {
eq(&self, other: &Self) -> bool3624     fn eq(&self, other: &Self) -> bool {
3625         self.InputTensor == other.InputTensor && self.IndicesTensor == other.IndicesTensor && self.OutputTensor == other.OutputTensor && self.InputDimensionCount == other.InputDimensionCount && self.IndicesDimensionCount == other.IndicesDimensionCount && self.BatchDimensionCount == other.BatchDimensionCount
3626     }
3627 }
3628 impl ::std::cmp::Eq for DML_GATHER_ND1_OPERATOR_DESC {}
3629 unsafe impl ::windows::runtime::Abi for DML_GATHER_ND1_OPERATOR_DESC {
3630     type Abi = Self;
3631     type DefaultType = Self;
3632 }
3633 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3634 #[repr(C)]
3635 pub struct DML_GATHER_ND_OPERATOR_DESC {
3636     pub InputTensor: *mut DML_TENSOR_DESC,
3637     pub IndicesTensor: *mut DML_TENSOR_DESC,
3638     pub OutputTensor: *mut DML_TENSOR_DESC,
3639     pub InputDimensionCount: u32,
3640     pub IndicesDimensionCount: u32,
3641 }
3642 impl DML_GATHER_ND_OPERATOR_DESC {}
3643 impl ::std::default::Default for DML_GATHER_ND_OPERATOR_DESC {
default() -> Self3644     fn default() -> Self {
3645         unsafe { ::std::mem::zeroed() }
3646     }
3647 }
3648 impl ::std::fmt::Debug for DML_GATHER_ND_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3649     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3650         fmt.debug_struct("DML_GATHER_ND_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("IndicesTensor", &self.IndicesTensor).field("OutputTensor", &self.OutputTensor).field("InputDimensionCount", &self.InputDimensionCount).field("IndicesDimensionCount", &self.IndicesDimensionCount).finish()
3651     }
3652 }
3653 impl ::std::cmp::PartialEq for DML_GATHER_ND_OPERATOR_DESC {
eq(&self, other: &Self) -> bool3654     fn eq(&self, other: &Self) -> bool {
3655         self.InputTensor == other.InputTensor && self.IndicesTensor == other.IndicesTensor && self.OutputTensor == other.OutputTensor && self.InputDimensionCount == other.InputDimensionCount && self.IndicesDimensionCount == other.IndicesDimensionCount
3656     }
3657 }
3658 impl ::std::cmp::Eq for DML_GATHER_ND_OPERATOR_DESC {}
3659 unsafe impl ::windows::runtime::Abi for DML_GATHER_ND_OPERATOR_DESC {
3660     type Abi = Self;
3661     type DefaultType = Self;
3662 }
3663 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3664 #[repr(C)]
3665 pub struct DML_GATHER_OPERATOR_DESC {
3666     pub InputTensor: *mut DML_TENSOR_DESC,
3667     pub IndicesTensor: *mut DML_TENSOR_DESC,
3668     pub OutputTensor: *mut DML_TENSOR_DESC,
3669     pub Axis: u32,
3670     pub IndexDimensions: u32,
3671 }
3672 impl DML_GATHER_OPERATOR_DESC {}
3673 impl ::std::default::Default for DML_GATHER_OPERATOR_DESC {
default() -> Self3674     fn default() -> Self {
3675         unsafe { ::std::mem::zeroed() }
3676     }
3677 }
3678 impl ::std::fmt::Debug for DML_GATHER_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3679     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3680         fmt.debug_struct("DML_GATHER_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("IndicesTensor", &self.IndicesTensor).field("OutputTensor", &self.OutputTensor).field("Axis", &self.Axis).field("IndexDimensions", &self.IndexDimensions).finish()
3681     }
3682 }
3683 impl ::std::cmp::PartialEq for DML_GATHER_OPERATOR_DESC {
eq(&self, other: &Self) -> bool3684     fn eq(&self, other: &Self) -> bool {
3685         self.InputTensor == other.InputTensor && self.IndicesTensor == other.IndicesTensor && self.OutputTensor == other.OutputTensor && self.Axis == other.Axis && self.IndexDimensions == other.IndexDimensions
3686     }
3687 }
3688 impl ::std::cmp::Eq for DML_GATHER_OPERATOR_DESC {}
3689 unsafe impl ::windows::runtime::Abi for DML_GATHER_OPERATOR_DESC {
3690     type Abi = Self;
3691     type DefaultType = Self;
3692 }
3693 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3694 #[repr(C)]
3695 pub struct DML_GEMM_OPERATOR_DESC {
3696     pub ATensor: *mut DML_TENSOR_DESC,
3697     pub BTensor: *mut DML_TENSOR_DESC,
3698     pub CTensor: *mut DML_TENSOR_DESC,
3699     pub OutputTensor: *mut DML_TENSOR_DESC,
3700     pub TransA: DML_MATRIX_TRANSFORM,
3701     pub TransB: DML_MATRIX_TRANSFORM,
3702     pub Alpha: f32,
3703     pub Beta: f32,
3704     pub FusedActivation: *mut DML_OPERATOR_DESC,
3705 }
3706 impl DML_GEMM_OPERATOR_DESC {}
3707 impl ::std::default::Default for DML_GEMM_OPERATOR_DESC {
default() -> Self3708     fn default() -> Self {
3709         unsafe { ::std::mem::zeroed() }
3710     }
3711 }
3712 impl ::std::fmt::Debug for DML_GEMM_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3713     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3714         fmt.debug_struct("DML_GEMM_OPERATOR_DESC")
3715             .field("ATensor", &self.ATensor)
3716             .field("BTensor", &self.BTensor)
3717             .field("CTensor", &self.CTensor)
3718             .field("OutputTensor", &self.OutputTensor)
3719             .field("TransA", &self.TransA)
3720             .field("TransB", &self.TransB)
3721             .field("Alpha", &self.Alpha)
3722             .field("Beta", &self.Beta)
3723             .field("FusedActivation", &self.FusedActivation)
3724             .finish()
3725     }
3726 }
3727 impl ::std::cmp::PartialEq for DML_GEMM_OPERATOR_DESC {
eq(&self, other: &Self) -> bool3728     fn eq(&self, other: &Self) -> bool {
3729         self.ATensor == other.ATensor && self.BTensor == other.BTensor && self.CTensor == other.CTensor && self.OutputTensor == other.OutputTensor && self.TransA == other.TransA && self.TransB == other.TransB && self.Alpha == other.Alpha && self.Beta == other.Beta && self.FusedActivation == other.FusedActivation
3730     }
3731 }
3732 impl ::std::cmp::Eq for DML_GEMM_OPERATOR_DESC {}
3733 unsafe impl ::windows::runtime::Abi for DML_GEMM_OPERATOR_DESC {
3734     type Abi = Self;
3735     type DefaultType = Self;
3736 }
3737 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3738 #[repr(C)]
3739 pub struct DML_GRAPH_DESC {
3740     pub InputCount: u32,
3741     pub OutputCount: u32,
3742     pub NodeCount: u32,
3743     pub Nodes: *mut DML_GRAPH_NODE_DESC,
3744     pub InputEdgeCount: u32,
3745     pub InputEdges: *mut DML_GRAPH_EDGE_DESC,
3746     pub OutputEdgeCount: u32,
3747     pub OutputEdges: *mut DML_GRAPH_EDGE_DESC,
3748     pub IntermediateEdgeCount: u32,
3749     pub IntermediateEdges: *mut DML_GRAPH_EDGE_DESC,
3750 }
3751 impl DML_GRAPH_DESC {}
3752 impl ::std::default::Default for DML_GRAPH_DESC {
default() -> Self3753     fn default() -> Self {
3754         unsafe { ::std::mem::zeroed() }
3755     }
3756 }
3757 impl ::std::fmt::Debug for DML_GRAPH_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3758     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3759         fmt.debug_struct("DML_GRAPH_DESC")
3760             .field("InputCount", &self.InputCount)
3761             .field("OutputCount", &self.OutputCount)
3762             .field("NodeCount", &self.NodeCount)
3763             .field("Nodes", &self.Nodes)
3764             .field("InputEdgeCount", &self.InputEdgeCount)
3765             .field("InputEdges", &self.InputEdges)
3766             .field("OutputEdgeCount", &self.OutputEdgeCount)
3767             .field("OutputEdges", &self.OutputEdges)
3768             .field("IntermediateEdgeCount", &self.IntermediateEdgeCount)
3769             .field("IntermediateEdges", &self.IntermediateEdges)
3770             .finish()
3771     }
3772 }
3773 impl ::std::cmp::PartialEq for DML_GRAPH_DESC {
eq(&self, other: &Self) -> bool3774     fn eq(&self, other: &Self) -> bool {
3775         self.InputCount == other.InputCount && self.OutputCount == other.OutputCount && self.NodeCount == other.NodeCount && self.Nodes == other.Nodes && self.InputEdgeCount == other.InputEdgeCount && self.InputEdges == other.InputEdges && self.OutputEdgeCount == other.OutputEdgeCount && self.OutputEdges == other.OutputEdges && self.IntermediateEdgeCount == other.IntermediateEdgeCount && self.IntermediateEdges == other.IntermediateEdges
3776     }
3777 }
3778 impl ::std::cmp::Eq for DML_GRAPH_DESC {}
3779 unsafe impl ::windows::runtime::Abi for DML_GRAPH_DESC {
3780     type Abi = Self;
3781     type DefaultType = Self;
3782 }
3783 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3784 #[repr(C)]
3785 pub struct DML_GRAPH_EDGE_DESC {
3786     pub Type: DML_GRAPH_EDGE_TYPE,
3787     pub Desc: *mut ::std::ffi::c_void,
3788 }
3789 impl DML_GRAPH_EDGE_DESC {}
3790 impl ::std::default::Default for DML_GRAPH_EDGE_DESC {
default() -> Self3791     fn default() -> Self {
3792         unsafe { ::std::mem::zeroed() }
3793     }
3794 }
3795 impl ::std::fmt::Debug for DML_GRAPH_EDGE_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3796     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3797         fmt.debug_struct("DML_GRAPH_EDGE_DESC").field("Type", &self.Type).field("Desc", &self.Desc).finish()
3798     }
3799 }
3800 impl ::std::cmp::PartialEq for DML_GRAPH_EDGE_DESC {
eq(&self, other: &Self) -> bool3801     fn eq(&self, other: &Self) -> bool {
3802         self.Type == other.Type && self.Desc == other.Desc
3803     }
3804 }
3805 impl ::std::cmp::Eq for DML_GRAPH_EDGE_DESC {}
3806 unsafe impl ::windows::runtime::Abi for DML_GRAPH_EDGE_DESC {
3807     type Abi = Self;
3808     type DefaultType = Self;
3809 }
3810 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3811 #[repr(transparent)]
3812 pub struct DML_GRAPH_EDGE_TYPE(pub i32);
3813 pub const DML_GRAPH_EDGE_TYPE_INVALID: DML_GRAPH_EDGE_TYPE = DML_GRAPH_EDGE_TYPE(0i32);
3814 pub const DML_GRAPH_EDGE_TYPE_INPUT: DML_GRAPH_EDGE_TYPE = DML_GRAPH_EDGE_TYPE(1i32);
3815 pub const DML_GRAPH_EDGE_TYPE_OUTPUT: DML_GRAPH_EDGE_TYPE = DML_GRAPH_EDGE_TYPE(2i32);
3816 pub const DML_GRAPH_EDGE_TYPE_INTERMEDIATE: DML_GRAPH_EDGE_TYPE = DML_GRAPH_EDGE_TYPE(3i32);
3817 impl ::std::convert::From<i32> for DML_GRAPH_EDGE_TYPE {
from(value: i32) -> Self3818     fn from(value: i32) -> Self {
3819         Self(value)
3820     }
3821 }
3822 unsafe impl ::windows::runtime::Abi for DML_GRAPH_EDGE_TYPE {
3823     type Abi = Self;
3824     type DefaultType = Self;
3825 }
3826 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3827 #[repr(C)]
3828 pub struct DML_GRAPH_NODE_DESC {
3829     pub Type: DML_GRAPH_NODE_TYPE,
3830     pub Desc: *mut ::std::ffi::c_void,
3831 }
3832 impl DML_GRAPH_NODE_DESC {}
3833 impl ::std::default::Default for DML_GRAPH_NODE_DESC {
default() -> Self3834     fn default() -> Self {
3835         unsafe { ::std::mem::zeroed() }
3836     }
3837 }
3838 impl ::std::fmt::Debug for DML_GRAPH_NODE_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3839     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3840         fmt.debug_struct("DML_GRAPH_NODE_DESC").field("Type", &self.Type).field("Desc", &self.Desc).finish()
3841     }
3842 }
3843 impl ::std::cmp::PartialEq for DML_GRAPH_NODE_DESC {
eq(&self, other: &Self) -> bool3844     fn eq(&self, other: &Self) -> bool {
3845         self.Type == other.Type && self.Desc == other.Desc
3846     }
3847 }
3848 impl ::std::cmp::Eq for DML_GRAPH_NODE_DESC {}
3849 unsafe impl ::windows::runtime::Abi for DML_GRAPH_NODE_DESC {
3850     type Abi = Self;
3851     type DefaultType = Self;
3852 }
3853 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
3854 #[repr(transparent)]
3855 pub struct DML_GRAPH_NODE_TYPE(pub i32);
3856 pub const DML_GRAPH_NODE_TYPE_INVALID: DML_GRAPH_NODE_TYPE = DML_GRAPH_NODE_TYPE(0i32);
3857 pub const DML_GRAPH_NODE_TYPE_OPERATOR: DML_GRAPH_NODE_TYPE = DML_GRAPH_NODE_TYPE(1i32);
3858 impl ::std::convert::From<i32> for DML_GRAPH_NODE_TYPE {
from(value: i32) -> Self3859     fn from(value: i32) -> Self {
3860         Self(value)
3861     }
3862 }
3863 unsafe impl ::windows::runtime::Abi for DML_GRAPH_NODE_TYPE {
3864     type Abi = Self;
3865     type DefaultType = Self;
3866 }
3867 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3868 #[repr(C)]
3869 #[cfg(feature = "Win32_Foundation")]
3870 pub struct DML_GRU_OPERATOR_DESC {
3871     pub InputTensor: *mut DML_TENSOR_DESC,
3872     pub WeightTensor: *mut DML_TENSOR_DESC,
3873     pub RecurrenceTensor: *mut DML_TENSOR_DESC,
3874     pub BiasTensor: *mut DML_TENSOR_DESC,
3875     pub HiddenInitTensor: *mut DML_TENSOR_DESC,
3876     pub SequenceLengthsTensor: *mut DML_TENSOR_DESC,
3877     pub OutputSequenceTensor: *mut DML_TENSOR_DESC,
3878     pub OutputSingleTensor: *mut DML_TENSOR_DESC,
3879     pub ActivationDescCount: u32,
3880     pub ActivationDescs: *mut DML_OPERATOR_DESC,
3881     pub Direction: DML_RECURRENT_NETWORK_DIRECTION,
3882     pub LinearBeforeReset: super::super::super::Foundation::BOOL,
3883 }
3884 #[cfg(feature = "Win32_Foundation")]
3885 impl DML_GRU_OPERATOR_DESC {}
3886 #[cfg(feature = "Win32_Foundation")]
3887 impl ::std::default::Default for DML_GRU_OPERATOR_DESC {
default() -> Self3888     fn default() -> Self {
3889         unsafe { ::std::mem::zeroed() }
3890     }
3891 }
3892 #[cfg(feature = "Win32_Foundation")]
3893 impl ::std::fmt::Debug for DML_GRU_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3894     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3895         fmt.debug_struct("DML_GRU_OPERATOR_DESC")
3896             .field("InputTensor", &self.InputTensor)
3897             .field("WeightTensor", &self.WeightTensor)
3898             .field("RecurrenceTensor", &self.RecurrenceTensor)
3899             .field("BiasTensor", &self.BiasTensor)
3900             .field("HiddenInitTensor", &self.HiddenInitTensor)
3901             .field("SequenceLengthsTensor", &self.SequenceLengthsTensor)
3902             .field("OutputSequenceTensor", &self.OutputSequenceTensor)
3903             .field("OutputSingleTensor", &self.OutputSingleTensor)
3904             .field("ActivationDescCount", &self.ActivationDescCount)
3905             .field("ActivationDescs", &self.ActivationDescs)
3906             .field("Direction", &self.Direction)
3907             .field("LinearBeforeReset", &self.LinearBeforeReset)
3908             .finish()
3909     }
3910 }
3911 #[cfg(feature = "Win32_Foundation")]
3912 impl ::std::cmp::PartialEq for DML_GRU_OPERATOR_DESC {
eq(&self, other: &Self) -> bool3913     fn eq(&self, other: &Self) -> bool {
3914         self.InputTensor == other.InputTensor
3915             && self.WeightTensor == other.WeightTensor
3916             && self.RecurrenceTensor == other.RecurrenceTensor
3917             && self.BiasTensor == other.BiasTensor
3918             && self.HiddenInitTensor == other.HiddenInitTensor
3919             && self.SequenceLengthsTensor == other.SequenceLengthsTensor
3920             && self.OutputSequenceTensor == other.OutputSequenceTensor
3921             && self.OutputSingleTensor == other.OutputSingleTensor
3922             && self.ActivationDescCount == other.ActivationDescCount
3923             && self.ActivationDescs == other.ActivationDescs
3924             && self.Direction == other.Direction
3925             && self.LinearBeforeReset == other.LinearBeforeReset
3926     }
3927 }
3928 #[cfg(feature = "Win32_Foundation")]
3929 impl ::std::cmp::Eq for DML_GRU_OPERATOR_DESC {}
3930 #[cfg(feature = "Win32_Foundation")]
3931 unsafe impl ::windows::runtime::Abi for DML_GRU_OPERATOR_DESC {
3932     type Abi = Self;
3933     type DefaultType = Self;
3934 }
3935 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3936 #[repr(C)]
3937 #[cfg(feature = "Win32_Foundation")]
3938 pub struct DML_INPUT_GRAPH_EDGE_DESC {
3939     pub GraphInputIndex: u32,
3940     pub ToNodeIndex: u32,
3941     pub ToNodeInputIndex: u32,
3942     pub Name: super::super::super::Foundation::PSTR,
3943 }
3944 #[cfg(feature = "Win32_Foundation")]
3945 impl DML_INPUT_GRAPH_EDGE_DESC {}
3946 #[cfg(feature = "Win32_Foundation")]
3947 impl ::std::default::Default for DML_INPUT_GRAPH_EDGE_DESC {
default() -> Self3948     fn default() -> Self {
3949         unsafe { ::std::mem::zeroed() }
3950     }
3951 }
3952 #[cfg(feature = "Win32_Foundation")]
3953 impl ::std::fmt::Debug for DML_INPUT_GRAPH_EDGE_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3954     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3955         fmt.debug_struct("DML_INPUT_GRAPH_EDGE_DESC").field("GraphInputIndex", &self.GraphInputIndex).field("ToNodeIndex", &self.ToNodeIndex).field("ToNodeInputIndex", &self.ToNodeInputIndex).field("Name", &self.Name).finish()
3956     }
3957 }
3958 #[cfg(feature = "Win32_Foundation")]
3959 impl ::std::cmp::PartialEq for DML_INPUT_GRAPH_EDGE_DESC {
eq(&self, other: &Self) -> bool3960     fn eq(&self, other: &Self) -> bool {
3961         self.GraphInputIndex == other.GraphInputIndex && self.ToNodeIndex == other.ToNodeIndex && self.ToNodeInputIndex == other.ToNodeInputIndex && self.Name == other.Name
3962     }
3963 }
3964 #[cfg(feature = "Win32_Foundation")]
3965 impl ::std::cmp::Eq for DML_INPUT_GRAPH_EDGE_DESC {}
3966 #[cfg(feature = "Win32_Foundation")]
3967 unsafe impl ::windows::runtime::Abi for DML_INPUT_GRAPH_EDGE_DESC {
3968     type Abi = Self;
3969     type DefaultType = Self;
3970 }
3971 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
3972 #[repr(C)]
3973 #[cfg(feature = "Win32_Foundation")]
3974 pub struct DML_INTERMEDIATE_GRAPH_EDGE_DESC {
3975     pub FromNodeIndex: u32,
3976     pub FromNodeOutputIndex: u32,
3977     pub ToNodeIndex: u32,
3978     pub ToNodeInputIndex: u32,
3979     pub Name: super::super::super::Foundation::PSTR,
3980 }
3981 #[cfg(feature = "Win32_Foundation")]
3982 impl DML_INTERMEDIATE_GRAPH_EDGE_DESC {}
3983 #[cfg(feature = "Win32_Foundation")]
3984 impl ::std::default::Default for DML_INTERMEDIATE_GRAPH_EDGE_DESC {
default() -> Self3985     fn default() -> Self {
3986         unsafe { ::std::mem::zeroed() }
3987     }
3988 }
3989 #[cfg(feature = "Win32_Foundation")]
3990 impl ::std::fmt::Debug for DML_INTERMEDIATE_GRAPH_EDGE_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result3991     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3992         fmt.debug_struct("DML_INTERMEDIATE_GRAPH_EDGE_DESC").field("FromNodeIndex", &self.FromNodeIndex).field("FromNodeOutputIndex", &self.FromNodeOutputIndex).field("ToNodeIndex", &self.ToNodeIndex).field("ToNodeInputIndex", &self.ToNodeInputIndex).field("Name", &self.Name).finish()
3993     }
3994 }
3995 #[cfg(feature = "Win32_Foundation")]
3996 impl ::std::cmp::PartialEq for DML_INTERMEDIATE_GRAPH_EDGE_DESC {
eq(&self, other: &Self) -> bool3997     fn eq(&self, other: &Self) -> bool {
3998         self.FromNodeIndex == other.FromNodeIndex && self.FromNodeOutputIndex == other.FromNodeOutputIndex && self.ToNodeIndex == other.ToNodeIndex && self.ToNodeInputIndex == other.ToNodeInputIndex && self.Name == other.Name
3999     }
4000 }
4001 #[cfg(feature = "Win32_Foundation")]
4002 impl ::std::cmp::Eq for DML_INTERMEDIATE_GRAPH_EDGE_DESC {}
4003 #[cfg(feature = "Win32_Foundation")]
4004 unsafe impl ::windows::runtime::Abi for DML_INTERMEDIATE_GRAPH_EDGE_DESC {
4005     type Abi = Self;
4006     type DefaultType = Self;
4007 }
4008 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4009 #[repr(transparent)]
4010 pub struct DML_INTERPOLATION_MODE(pub i32);
4011 pub const DML_INTERPOLATION_MODE_NEAREST_NEIGHBOR: DML_INTERPOLATION_MODE = DML_INTERPOLATION_MODE(0i32);
4012 pub const DML_INTERPOLATION_MODE_LINEAR: DML_INTERPOLATION_MODE = DML_INTERPOLATION_MODE(1i32);
4013 impl ::std::convert::From<i32> for DML_INTERPOLATION_MODE {
from(value: i32) -> Self4014     fn from(value: i32) -> Self {
4015         Self(value)
4016     }
4017 }
4018 unsafe impl ::windows::runtime::Abi for DML_INTERPOLATION_MODE {
4019     type Abi = Self;
4020     type DefaultType = Self;
4021 }
4022 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4023 #[repr(transparent)]
4024 pub struct DML_IS_INFINITY_MODE(pub i32);
4025 pub const DML_IS_INFINITY_MODE_EITHER: DML_IS_INFINITY_MODE = DML_IS_INFINITY_MODE(0i32);
4026 pub const DML_IS_INFINITY_MODE_POSITIVE: DML_IS_INFINITY_MODE = DML_IS_INFINITY_MODE(1i32);
4027 pub const DML_IS_INFINITY_MODE_NEGATIVE: DML_IS_INFINITY_MODE = DML_IS_INFINITY_MODE(2i32);
4028 impl ::std::convert::From<i32> for DML_IS_INFINITY_MODE {
from(value: i32) -> Self4029     fn from(value: i32) -> Self {
4030         Self(value)
4031     }
4032 }
4033 unsafe impl ::windows::runtime::Abi for DML_IS_INFINITY_MODE {
4034     type Abi = Self;
4035     type DefaultType = Self;
4036 }
4037 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4038 #[repr(C)]
4039 pub struct DML_JOIN_OPERATOR_DESC {
4040     pub InputCount: u32,
4041     pub InputTensors: *mut DML_TENSOR_DESC,
4042     pub OutputTensor: *mut DML_TENSOR_DESC,
4043     pub Axis: u32,
4044 }
4045 impl DML_JOIN_OPERATOR_DESC {}
4046 impl ::std::default::Default for DML_JOIN_OPERATOR_DESC {
default() -> Self4047     fn default() -> Self {
4048         unsafe { ::std::mem::zeroed() }
4049     }
4050 }
4051 impl ::std::fmt::Debug for DML_JOIN_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4052     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4053         fmt.debug_struct("DML_JOIN_OPERATOR_DESC").field("InputCount", &self.InputCount).field("InputTensors", &self.InputTensors).field("OutputTensor", &self.OutputTensor).field("Axis", &self.Axis).finish()
4054     }
4055 }
4056 impl ::std::cmp::PartialEq for DML_JOIN_OPERATOR_DESC {
eq(&self, other: &Self) -> bool4057     fn eq(&self, other: &Self) -> bool {
4058         self.InputCount == other.InputCount && self.InputTensors == other.InputTensors && self.OutputTensor == other.OutputTensor && self.Axis == other.Axis
4059     }
4060 }
4061 impl ::std::cmp::Eq for DML_JOIN_OPERATOR_DESC {}
4062 unsafe impl ::windows::runtime::Abi for DML_JOIN_OPERATOR_DESC {
4063     type Abi = Self;
4064     type DefaultType = Self;
4065 }
4066 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4067 #[repr(C)]
4068 #[cfg(feature = "Win32_Foundation")]
4069 pub struct DML_LOCAL_RESPONSE_NORMALIZATION_GRAD_OPERATOR_DESC {
4070     pub InputTensor: *mut DML_TENSOR_DESC,
4071     pub InputGradientTensor: *mut DML_TENSOR_DESC,
4072     pub OutputGradientTensor: *mut DML_TENSOR_DESC,
4073     pub CrossChannel: super::super::super::Foundation::BOOL,
4074     pub LocalSize: u32,
4075     pub Alpha: f32,
4076     pub Beta: f32,
4077     pub Bias: f32,
4078 }
4079 #[cfg(feature = "Win32_Foundation")]
4080 impl DML_LOCAL_RESPONSE_NORMALIZATION_GRAD_OPERATOR_DESC {}
4081 #[cfg(feature = "Win32_Foundation")]
4082 impl ::std::default::Default for DML_LOCAL_RESPONSE_NORMALIZATION_GRAD_OPERATOR_DESC {
default() -> Self4083     fn default() -> Self {
4084         unsafe { ::std::mem::zeroed() }
4085     }
4086 }
4087 #[cfg(feature = "Win32_Foundation")]
4088 impl ::std::fmt::Debug for DML_LOCAL_RESPONSE_NORMALIZATION_GRAD_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4089     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4090         fmt.debug_struct("DML_LOCAL_RESPONSE_NORMALIZATION_GRAD_OPERATOR_DESC")
4091             .field("InputTensor", &self.InputTensor)
4092             .field("InputGradientTensor", &self.InputGradientTensor)
4093             .field("OutputGradientTensor", &self.OutputGradientTensor)
4094             .field("CrossChannel", &self.CrossChannel)
4095             .field("LocalSize", &self.LocalSize)
4096             .field("Alpha", &self.Alpha)
4097             .field("Beta", &self.Beta)
4098             .field("Bias", &self.Bias)
4099             .finish()
4100     }
4101 }
4102 #[cfg(feature = "Win32_Foundation")]
4103 impl ::std::cmp::PartialEq for DML_LOCAL_RESPONSE_NORMALIZATION_GRAD_OPERATOR_DESC {
eq(&self, other: &Self) -> bool4104     fn eq(&self, other: &Self) -> bool {
4105         self.InputTensor == other.InputTensor && self.InputGradientTensor == other.InputGradientTensor && self.OutputGradientTensor == other.OutputGradientTensor && self.CrossChannel == other.CrossChannel && self.LocalSize == other.LocalSize && self.Alpha == other.Alpha && self.Beta == other.Beta && self.Bias == other.Bias
4106     }
4107 }
4108 #[cfg(feature = "Win32_Foundation")]
4109 impl ::std::cmp::Eq for DML_LOCAL_RESPONSE_NORMALIZATION_GRAD_OPERATOR_DESC {}
4110 #[cfg(feature = "Win32_Foundation")]
4111 unsafe impl ::windows::runtime::Abi for DML_LOCAL_RESPONSE_NORMALIZATION_GRAD_OPERATOR_DESC {
4112     type Abi = Self;
4113     type DefaultType = Self;
4114 }
4115 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4116 #[repr(C)]
4117 #[cfg(feature = "Win32_Foundation")]
4118 pub struct DML_LOCAL_RESPONSE_NORMALIZATION_OPERATOR_DESC {
4119     pub InputTensor: *mut DML_TENSOR_DESC,
4120     pub OutputTensor: *mut DML_TENSOR_DESC,
4121     pub CrossChannel: super::super::super::Foundation::BOOL,
4122     pub LocalSize: u32,
4123     pub Alpha: f32,
4124     pub Beta: f32,
4125     pub Bias: f32,
4126 }
4127 #[cfg(feature = "Win32_Foundation")]
4128 impl DML_LOCAL_RESPONSE_NORMALIZATION_OPERATOR_DESC {}
4129 #[cfg(feature = "Win32_Foundation")]
4130 impl ::std::default::Default for DML_LOCAL_RESPONSE_NORMALIZATION_OPERATOR_DESC {
default() -> Self4131     fn default() -> Self {
4132         unsafe { ::std::mem::zeroed() }
4133     }
4134 }
4135 #[cfg(feature = "Win32_Foundation")]
4136 impl ::std::fmt::Debug for DML_LOCAL_RESPONSE_NORMALIZATION_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4137     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4138         fmt.debug_struct("DML_LOCAL_RESPONSE_NORMALIZATION_OPERATOR_DESC")
4139             .field("InputTensor", &self.InputTensor)
4140             .field("OutputTensor", &self.OutputTensor)
4141             .field("CrossChannel", &self.CrossChannel)
4142             .field("LocalSize", &self.LocalSize)
4143             .field("Alpha", &self.Alpha)
4144             .field("Beta", &self.Beta)
4145             .field("Bias", &self.Bias)
4146             .finish()
4147     }
4148 }
4149 #[cfg(feature = "Win32_Foundation")]
4150 impl ::std::cmp::PartialEq for DML_LOCAL_RESPONSE_NORMALIZATION_OPERATOR_DESC {
eq(&self, other: &Self) -> bool4151     fn eq(&self, other: &Self) -> bool {
4152         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.CrossChannel == other.CrossChannel && self.LocalSize == other.LocalSize && self.Alpha == other.Alpha && self.Beta == other.Beta && self.Bias == other.Bias
4153     }
4154 }
4155 #[cfg(feature = "Win32_Foundation")]
4156 impl ::std::cmp::Eq for DML_LOCAL_RESPONSE_NORMALIZATION_OPERATOR_DESC {}
4157 #[cfg(feature = "Win32_Foundation")]
4158 unsafe impl ::windows::runtime::Abi for DML_LOCAL_RESPONSE_NORMALIZATION_OPERATOR_DESC {
4159     type Abi = Self;
4160     type DefaultType = Self;
4161 }
4162 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4163 #[repr(C)]
4164 pub struct DML_LP_NORMALIZATION_OPERATOR_DESC {
4165     pub InputTensor: *mut DML_TENSOR_DESC,
4166     pub OutputTensor: *mut DML_TENSOR_DESC,
4167     pub Axis: u32,
4168     pub Epsilon: f32,
4169     pub P: u32,
4170 }
4171 impl DML_LP_NORMALIZATION_OPERATOR_DESC {}
4172 impl ::std::default::Default for DML_LP_NORMALIZATION_OPERATOR_DESC {
default() -> Self4173     fn default() -> Self {
4174         unsafe { ::std::mem::zeroed() }
4175     }
4176 }
4177 impl ::std::fmt::Debug for DML_LP_NORMALIZATION_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4178     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4179         fmt.debug_struct("DML_LP_NORMALIZATION_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("Axis", &self.Axis).field("Epsilon", &self.Epsilon).field("P", &self.P).finish()
4180     }
4181 }
4182 impl ::std::cmp::PartialEq for DML_LP_NORMALIZATION_OPERATOR_DESC {
eq(&self, other: &Self) -> bool4183     fn eq(&self, other: &Self) -> bool {
4184         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.Axis == other.Axis && self.Epsilon == other.Epsilon && self.P == other.P
4185     }
4186 }
4187 impl ::std::cmp::Eq for DML_LP_NORMALIZATION_OPERATOR_DESC {}
4188 unsafe impl ::windows::runtime::Abi for DML_LP_NORMALIZATION_OPERATOR_DESC {
4189     type Abi = Self;
4190     type DefaultType = Self;
4191 }
4192 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4193 #[repr(C)]
4194 pub struct DML_LP_POOLING_OPERATOR_DESC {
4195     pub InputTensor: *mut DML_TENSOR_DESC,
4196     pub OutputTensor: *mut DML_TENSOR_DESC,
4197     pub DimensionCount: u32,
4198     pub Strides: *mut u32,
4199     pub WindowSize: *mut u32,
4200     pub StartPadding: *mut u32,
4201     pub EndPadding: *mut u32,
4202     pub P: u32,
4203 }
4204 impl DML_LP_POOLING_OPERATOR_DESC {}
4205 impl ::std::default::Default for DML_LP_POOLING_OPERATOR_DESC {
default() -> Self4206     fn default() -> Self {
4207         unsafe { ::std::mem::zeroed() }
4208     }
4209 }
4210 impl ::std::fmt::Debug for DML_LP_POOLING_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4211     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4212         fmt.debug_struct("DML_LP_POOLING_OPERATOR_DESC")
4213             .field("InputTensor", &self.InputTensor)
4214             .field("OutputTensor", &self.OutputTensor)
4215             .field("DimensionCount", &self.DimensionCount)
4216             .field("Strides", &self.Strides)
4217             .field("WindowSize", &self.WindowSize)
4218             .field("StartPadding", &self.StartPadding)
4219             .field("EndPadding", &self.EndPadding)
4220             .field("P", &self.P)
4221             .finish()
4222     }
4223 }
4224 impl ::std::cmp::PartialEq for DML_LP_POOLING_OPERATOR_DESC {
eq(&self, other: &Self) -> bool4225     fn eq(&self, other: &Self) -> bool {
4226         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.DimensionCount == other.DimensionCount && self.Strides == other.Strides && self.WindowSize == other.WindowSize && self.StartPadding == other.StartPadding && self.EndPadding == other.EndPadding && self.P == other.P
4227     }
4228 }
4229 impl ::std::cmp::Eq for DML_LP_POOLING_OPERATOR_DESC {}
4230 unsafe impl ::windows::runtime::Abi for DML_LP_POOLING_OPERATOR_DESC {
4231     type Abi = Self;
4232     type DefaultType = Self;
4233 }
4234 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4235 #[repr(C)]
4236 #[cfg(feature = "Win32_Foundation")]
4237 pub struct DML_LSTM_OPERATOR_DESC {
4238     pub InputTensor: *mut DML_TENSOR_DESC,
4239     pub WeightTensor: *mut DML_TENSOR_DESC,
4240     pub RecurrenceTensor: *mut DML_TENSOR_DESC,
4241     pub BiasTensor: *mut DML_TENSOR_DESC,
4242     pub HiddenInitTensor: *mut DML_TENSOR_DESC,
4243     pub CellMemInitTensor: *mut DML_TENSOR_DESC,
4244     pub SequenceLengthsTensor: *mut DML_TENSOR_DESC,
4245     pub PeepholeTensor: *mut DML_TENSOR_DESC,
4246     pub OutputSequenceTensor: *mut DML_TENSOR_DESC,
4247     pub OutputSingleTensor: *mut DML_TENSOR_DESC,
4248     pub OutputCellSingleTensor: *mut DML_TENSOR_DESC,
4249     pub ActivationDescCount: u32,
4250     pub ActivationDescs: *mut DML_OPERATOR_DESC,
4251     pub Direction: DML_RECURRENT_NETWORK_DIRECTION,
4252     pub ClipThreshold: f32,
4253     pub UseClipThreshold: super::super::super::Foundation::BOOL,
4254     pub CoupleInputForget: super::super::super::Foundation::BOOL,
4255 }
4256 #[cfg(feature = "Win32_Foundation")]
4257 impl DML_LSTM_OPERATOR_DESC {}
4258 #[cfg(feature = "Win32_Foundation")]
4259 impl ::std::default::Default for DML_LSTM_OPERATOR_DESC {
default() -> Self4260     fn default() -> Self {
4261         unsafe { ::std::mem::zeroed() }
4262     }
4263 }
4264 #[cfg(feature = "Win32_Foundation")]
4265 impl ::std::fmt::Debug for DML_LSTM_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4266     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4267         fmt.debug_struct("DML_LSTM_OPERATOR_DESC")
4268             .field("InputTensor", &self.InputTensor)
4269             .field("WeightTensor", &self.WeightTensor)
4270             .field("RecurrenceTensor", &self.RecurrenceTensor)
4271             .field("BiasTensor", &self.BiasTensor)
4272             .field("HiddenInitTensor", &self.HiddenInitTensor)
4273             .field("CellMemInitTensor", &self.CellMemInitTensor)
4274             .field("SequenceLengthsTensor", &self.SequenceLengthsTensor)
4275             .field("PeepholeTensor", &self.PeepholeTensor)
4276             .field("OutputSequenceTensor", &self.OutputSequenceTensor)
4277             .field("OutputSingleTensor", &self.OutputSingleTensor)
4278             .field("OutputCellSingleTensor", &self.OutputCellSingleTensor)
4279             .field("ActivationDescCount", &self.ActivationDescCount)
4280             .field("ActivationDescs", &self.ActivationDescs)
4281             .field("Direction", &self.Direction)
4282             .field("ClipThreshold", &self.ClipThreshold)
4283             .field("UseClipThreshold", &self.UseClipThreshold)
4284             .field("CoupleInputForget", &self.CoupleInputForget)
4285             .finish()
4286     }
4287 }
4288 #[cfg(feature = "Win32_Foundation")]
4289 impl ::std::cmp::PartialEq for DML_LSTM_OPERATOR_DESC {
eq(&self, other: &Self) -> bool4290     fn eq(&self, other: &Self) -> bool {
4291         self.InputTensor == other.InputTensor
4292             && self.WeightTensor == other.WeightTensor
4293             && self.RecurrenceTensor == other.RecurrenceTensor
4294             && self.BiasTensor == other.BiasTensor
4295             && self.HiddenInitTensor == other.HiddenInitTensor
4296             && self.CellMemInitTensor == other.CellMemInitTensor
4297             && self.SequenceLengthsTensor == other.SequenceLengthsTensor
4298             && self.PeepholeTensor == other.PeepholeTensor
4299             && self.OutputSequenceTensor == other.OutputSequenceTensor
4300             && self.OutputSingleTensor == other.OutputSingleTensor
4301             && self.OutputCellSingleTensor == other.OutputCellSingleTensor
4302             && self.ActivationDescCount == other.ActivationDescCount
4303             && self.ActivationDescs == other.ActivationDescs
4304             && self.Direction == other.Direction
4305             && self.ClipThreshold == other.ClipThreshold
4306             && self.UseClipThreshold == other.UseClipThreshold
4307             && self.CoupleInputForget == other.CoupleInputForget
4308     }
4309 }
4310 #[cfg(feature = "Win32_Foundation")]
4311 impl ::std::cmp::Eq for DML_LSTM_OPERATOR_DESC {}
4312 #[cfg(feature = "Win32_Foundation")]
4313 unsafe impl ::windows::runtime::Abi for DML_LSTM_OPERATOR_DESC {
4314     type Abi = Self;
4315     type DefaultType = Self;
4316 }
4317 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4318 #[repr(C)]
4319 pub struct DML_MATRIX_MULTIPLY_INTEGER_OPERATOR_DESC {
4320     pub ATensor: *mut DML_TENSOR_DESC,
4321     pub AZeroPointTensor: *mut DML_TENSOR_DESC,
4322     pub BTensor: *mut DML_TENSOR_DESC,
4323     pub BZeroPointTensor: *mut DML_TENSOR_DESC,
4324     pub OutputTensor: *mut DML_TENSOR_DESC,
4325 }
4326 impl DML_MATRIX_MULTIPLY_INTEGER_OPERATOR_DESC {}
4327 impl ::std::default::Default for DML_MATRIX_MULTIPLY_INTEGER_OPERATOR_DESC {
default() -> Self4328     fn default() -> Self {
4329         unsafe { ::std::mem::zeroed() }
4330     }
4331 }
4332 impl ::std::fmt::Debug for DML_MATRIX_MULTIPLY_INTEGER_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4333     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4334         fmt.debug_struct("DML_MATRIX_MULTIPLY_INTEGER_OPERATOR_DESC").field("ATensor", &self.ATensor).field("AZeroPointTensor", &self.AZeroPointTensor).field("BTensor", &self.BTensor).field("BZeroPointTensor", &self.BZeroPointTensor).field("OutputTensor", &self.OutputTensor).finish()
4335     }
4336 }
4337 impl ::std::cmp::PartialEq for DML_MATRIX_MULTIPLY_INTEGER_OPERATOR_DESC {
eq(&self, other: &Self) -> bool4338     fn eq(&self, other: &Self) -> bool {
4339         self.ATensor == other.ATensor && self.AZeroPointTensor == other.AZeroPointTensor && self.BTensor == other.BTensor && self.BZeroPointTensor == other.BZeroPointTensor && self.OutputTensor == other.OutputTensor
4340     }
4341 }
4342 impl ::std::cmp::Eq for DML_MATRIX_MULTIPLY_INTEGER_OPERATOR_DESC {}
4343 unsafe impl ::windows::runtime::Abi for DML_MATRIX_MULTIPLY_INTEGER_OPERATOR_DESC {
4344     type Abi = Self;
4345     type DefaultType = Self;
4346 }
4347 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4348 #[repr(transparent)]
4349 pub struct DML_MATRIX_TRANSFORM(pub i32);
4350 pub const DML_MATRIX_TRANSFORM_NONE: DML_MATRIX_TRANSFORM = DML_MATRIX_TRANSFORM(0i32);
4351 pub const DML_MATRIX_TRANSFORM_TRANSPOSE: DML_MATRIX_TRANSFORM = DML_MATRIX_TRANSFORM(1i32);
4352 impl ::std::convert::From<i32> for DML_MATRIX_TRANSFORM {
from(value: i32) -> Self4353     fn from(value: i32) -> Self {
4354         Self(value)
4355     }
4356 }
4357 unsafe impl ::windows::runtime::Abi for DML_MATRIX_TRANSFORM {
4358     type Abi = Self;
4359     type DefaultType = Self;
4360 }
4361 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4362 #[repr(C)]
4363 pub struct DML_MAX_POOLING1_OPERATOR_DESC {
4364     pub InputTensor: *mut DML_TENSOR_DESC,
4365     pub OutputTensor: *mut DML_TENSOR_DESC,
4366     pub OutputIndicesTensor: *mut DML_TENSOR_DESC,
4367     pub DimensionCount: u32,
4368     pub Strides: *mut u32,
4369     pub WindowSize: *mut u32,
4370     pub StartPadding: *mut u32,
4371     pub EndPadding: *mut u32,
4372 }
4373 impl DML_MAX_POOLING1_OPERATOR_DESC {}
4374 impl ::std::default::Default for DML_MAX_POOLING1_OPERATOR_DESC {
default() -> Self4375     fn default() -> Self {
4376         unsafe { ::std::mem::zeroed() }
4377     }
4378 }
4379 impl ::std::fmt::Debug for DML_MAX_POOLING1_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4380     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4381         fmt.debug_struct("DML_MAX_POOLING1_OPERATOR_DESC")
4382             .field("InputTensor", &self.InputTensor)
4383             .field("OutputTensor", &self.OutputTensor)
4384             .field("OutputIndicesTensor", &self.OutputIndicesTensor)
4385             .field("DimensionCount", &self.DimensionCount)
4386             .field("Strides", &self.Strides)
4387             .field("WindowSize", &self.WindowSize)
4388             .field("StartPadding", &self.StartPadding)
4389             .field("EndPadding", &self.EndPadding)
4390             .finish()
4391     }
4392 }
4393 impl ::std::cmp::PartialEq for DML_MAX_POOLING1_OPERATOR_DESC {
eq(&self, other: &Self) -> bool4394     fn eq(&self, other: &Self) -> bool {
4395         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.OutputIndicesTensor == other.OutputIndicesTensor && self.DimensionCount == other.DimensionCount && self.Strides == other.Strides && self.WindowSize == other.WindowSize && self.StartPadding == other.StartPadding && self.EndPadding == other.EndPadding
4396     }
4397 }
4398 impl ::std::cmp::Eq for DML_MAX_POOLING1_OPERATOR_DESC {}
4399 unsafe impl ::windows::runtime::Abi for DML_MAX_POOLING1_OPERATOR_DESC {
4400     type Abi = Self;
4401     type DefaultType = Self;
4402 }
4403 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4404 #[repr(C)]
4405 pub struct DML_MAX_POOLING2_OPERATOR_DESC {
4406     pub InputTensor: *mut DML_TENSOR_DESC,
4407     pub OutputTensor: *mut DML_TENSOR_DESC,
4408     pub OutputIndicesTensor: *mut DML_TENSOR_DESC,
4409     pub DimensionCount: u32,
4410     pub Strides: *mut u32,
4411     pub WindowSize: *mut u32,
4412     pub StartPadding: *mut u32,
4413     pub EndPadding: *mut u32,
4414     pub Dilations: *mut u32,
4415 }
4416 impl DML_MAX_POOLING2_OPERATOR_DESC {}
4417 impl ::std::default::Default for DML_MAX_POOLING2_OPERATOR_DESC {
default() -> Self4418     fn default() -> Self {
4419         unsafe { ::std::mem::zeroed() }
4420     }
4421 }
4422 impl ::std::fmt::Debug for DML_MAX_POOLING2_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4423     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4424         fmt.debug_struct("DML_MAX_POOLING2_OPERATOR_DESC")
4425             .field("InputTensor", &self.InputTensor)
4426             .field("OutputTensor", &self.OutputTensor)
4427             .field("OutputIndicesTensor", &self.OutputIndicesTensor)
4428             .field("DimensionCount", &self.DimensionCount)
4429             .field("Strides", &self.Strides)
4430             .field("WindowSize", &self.WindowSize)
4431             .field("StartPadding", &self.StartPadding)
4432             .field("EndPadding", &self.EndPadding)
4433             .field("Dilations", &self.Dilations)
4434             .finish()
4435     }
4436 }
4437 impl ::std::cmp::PartialEq for DML_MAX_POOLING2_OPERATOR_DESC {
eq(&self, other: &Self) -> bool4438     fn eq(&self, other: &Self) -> bool {
4439         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.OutputIndicesTensor == other.OutputIndicesTensor && self.DimensionCount == other.DimensionCount && self.Strides == other.Strides && self.WindowSize == other.WindowSize && self.StartPadding == other.StartPadding && self.EndPadding == other.EndPadding && self.Dilations == other.Dilations
4440     }
4441 }
4442 impl ::std::cmp::Eq for DML_MAX_POOLING2_OPERATOR_DESC {}
4443 unsafe impl ::windows::runtime::Abi for DML_MAX_POOLING2_OPERATOR_DESC {
4444     type Abi = Self;
4445     type DefaultType = Self;
4446 }
4447 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4448 #[repr(C)]
4449 pub struct DML_MAX_POOLING_GRAD_OPERATOR_DESC {
4450     pub InputTensor: *mut DML_TENSOR_DESC,
4451     pub InputGradientTensor: *mut DML_TENSOR_DESC,
4452     pub OutputGradientTensor: *mut DML_TENSOR_DESC,
4453     pub DimensionCount: u32,
4454     pub Strides: *mut u32,
4455     pub WindowSize: *mut u32,
4456     pub StartPadding: *mut u32,
4457     pub EndPadding: *mut u32,
4458     pub Dilations: *mut u32,
4459 }
4460 impl DML_MAX_POOLING_GRAD_OPERATOR_DESC {}
4461 impl ::std::default::Default for DML_MAX_POOLING_GRAD_OPERATOR_DESC {
default() -> Self4462     fn default() -> Self {
4463         unsafe { ::std::mem::zeroed() }
4464     }
4465 }
4466 impl ::std::fmt::Debug for DML_MAX_POOLING_GRAD_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4467     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4468         fmt.debug_struct("DML_MAX_POOLING_GRAD_OPERATOR_DESC")
4469             .field("InputTensor", &self.InputTensor)
4470             .field("InputGradientTensor", &self.InputGradientTensor)
4471             .field("OutputGradientTensor", &self.OutputGradientTensor)
4472             .field("DimensionCount", &self.DimensionCount)
4473             .field("Strides", &self.Strides)
4474             .field("WindowSize", &self.WindowSize)
4475             .field("StartPadding", &self.StartPadding)
4476             .field("EndPadding", &self.EndPadding)
4477             .field("Dilations", &self.Dilations)
4478             .finish()
4479     }
4480 }
4481 impl ::std::cmp::PartialEq for DML_MAX_POOLING_GRAD_OPERATOR_DESC {
eq(&self, other: &Self) -> bool4482     fn eq(&self, other: &Self) -> bool {
4483         self.InputTensor == other.InputTensor && self.InputGradientTensor == other.InputGradientTensor && self.OutputGradientTensor == other.OutputGradientTensor && self.DimensionCount == other.DimensionCount && self.Strides == other.Strides && self.WindowSize == other.WindowSize && self.StartPadding == other.StartPadding && self.EndPadding == other.EndPadding && self.Dilations == other.Dilations
4484     }
4485 }
4486 impl ::std::cmp::Eq for DML_MAX_POOLING_GRAD_OPERATOR_DESC {}
4487 unsafe impl ::windows::runtime::Abi for DML_MAX_POOLING_GRAD_OPERATOR_DESC {
4488     type Abi = Self;
4489     type DefaultType = Self;
4490 }
4491 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4492 #[repr(C)]
4493 pub struct DML_MAX_POOLING_OPERATOR_DESC {
4494     pub InputTensor: *mut DML_TENSOR_DESC,
4495     pub OutputTensor: *mut DML_TENSOR_DESC,
4496     pub DimensionCount: u32,
4497     pub Strides: *mut u32,
4498     pub WindowSize: *mut u32,
4499     pub StartPadding: *mut u32,
4500     pub EndPadding: *mut u32,
4501 }
4502 impl DML_MAX_POOLING_OPERATOR_DESC {}
4503 impl ::std::default::Default for DML_MAX_POOLING_OPERATOR_DESC {
default() -> Self4504     fn default() -> Self {
4505         unsafe { ::std::mem::zeroed() }
4506     }
4507 }
4508 impl ::std::fmt::Debug for DML_MAX_POOLING_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4509     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4510         fmt.debug_struct("DML_MAX_POOLING_OPERATOR_DESC")
4511             .field("InputTensor", &self.InputTensor)
4512             .field("OutputTensor", &self.OutputTensor)
4513             .field("DimensionCount", &self.DimensionCount)
4514             .field("Strides", &self.Strides)
4515             .field("WindowSize", &self.WindowSize)
4516             .field("StartPadding", &self.StartPadding)
4517             .field("EndPadding", &self.EndPadding)
4518             .finish()
4519     }
4520 }
4521 impl ::std::cmp::PartialEq for DML_MAX_POOLING_OPERATOR_DESC {
eq(&self, other: &Self) -> bool4522     fn eq(&self, other: &Self) -> bool {
4523         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.DimensionCount == other.DimensionCount && self.Strides == other.Strides && self.WindowSize == other.WindowSize && self.StartPadding == other.StartPadding && self.EndPadding == other.EndPadding
4524     }
4525 }
4526 impl ::std::cmp::Eq for DML_MAX_POOLING_OPERATOR_DESC {}
4527 unsafe impl ::windows::runtime::Abi for DML_MAX_POOLING_OPERATOR_DESC {
4528     type Abi = Self;
4529     type DefaultType = Self;
4530 }
4531 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4532 #[repr(C)]
4533 pub struct DML_MAX_UNPOOLING_OPERATOR_DESC {
4534     pub InputTensor: *mut DML_TENSOR_DESC,
4535     pub IndicesTensor: *mut DML_TENSOR_DESC,
4536     pub OutputTensor: *mut DML_TENSOR_DESC,
4537 }
4538 impl DML_MAX_UNPOOLING_OPERATOR_DESC {}
4539 impl ::std::default::Default for DML_MAX_UNPOOLING_OPERATOR_DESC {
default() -> Self4540     fn default() -> Self {
4541         unsafe { ::std::mem::zeroed() }
4542     }
4543 }
4544 impl ::std::fmt::Debug for DML_MAX_UNPOOLING_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4545     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4546         fmt.debug_struct("DML_MAX_UNPOOLING_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("IndicesTensor", &self.IndicesTensor).field("OutputTensor", &self.OutputTensor).finish()
4547     }
4548 }
4549 impl ::std::cmp::PartialEq for DML_MAX_UNPOOLING_OPERATOR_DESC {
eq(&self, other: &Self) -> bool4550     fn eq(&self, other: &Self) -> bool {
4551         self.InputTensor == other.InputTensor && self.IndicesTensor == other.IndicesTensor && self.OutputTensor == other.OutputTensor
4552     }
4553 }
4554 impl ::std::cmp::Eq for DML_MAX_UNPOOLING_OPERATOR_DESC {}
4555 unsafe impl ::windows::runtime::Abi for DML_MAX_UNPOOLING_OPERATOR_DESC {
4556     type Abi = Self;
4557     type DefaultType = Self;
4558 }
4559 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4560 #[repr(C)]
4561 #[cfg(feature = "Win32_Foundation")]
4562 pub struct DML_MEAN_VARIANCE_NORMALIZATION1_OPERATOR_DESC {
4563     pub InputTensor: *mut DML_TENSOR_DESC,
4564     pub ScaleTensor: *mut DML_TENSOR_DESC,
4565     pub BiasTensor: *mut DML_TENSOR_DESC,
4566     pub OutputTensor: *mut DML_TENSOR_DESC,
4567     pub AxisCount: u32,
4568     pub Axes: *mut u32,
4569     pub NormalizeVariance: super::super::super::Foundation::BOOL,
4570     pub Epsilon: f32,
4571     pub FusedActivation: *mut DML_OPERATOR_DESC,
4572 }
4573 #[cfg(feature = "Win32_Foundation")]
4574 impl DML_MEAN_VARIANCE_NORMALIZATION1_OPERATOR_DESC {}
4575 #[cfg(feature = "Win32_Foundation")]
4576 impl ::std::default::Default for DML_MEAN_VARIANCE_NORMALIZATION1_OPERATOR_DESC {
default() -> Self4577     fn default() -> Self {
4578         unsafe { ::std::mem::zeroed() }
4579     }
4580 }
4581 #[cfg(feature = "Win32_Foundation")]
4582 impl ::std::fmt::Debug for DML_MEAN_VARIANCE_NORMALIZATION1_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4583     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4584         fmt.debug_struct("DML_MEAN_VARIANCE_NORMALIZATION1_OPERATOR_DESC")
4585             .field("InputTensor", &self.InputTensor)
4586             .field("ScaleTensor", &self.ScaleTensor)
4587             .field("BiasTensor", &self.BiasTensor)
4588             .field("OutputTensor", &self.OutputTensor)
4589             .field("AxisCount", &self.AxisCount)
4590             .field("Axes", &self.Axes)
4591             .field("NormalizeVariance", &self.NormalizeVariance)
4592             .field("Epsilon", &self.Epsilon)
4593             .field("FusedActivation", &self.FusedActivation)
4594             .finish()
4595     }
4596 }
4597 #[cfg(feature = "Win32_Foundation")]
4598 impl ::std::cmp::PartialEq for DML_MEAN_VARIANCE_NORMALIZATION1_OPERATOR_DESC {
eq(&self, other: &Self) -> bool4599     fn eq(&self, other: &Self) -> bool {
4600         self.InputTensor == other.InputTensor && self.ScaleTensor == other.ScaleTensor && self.BiasTensor == other.BiasTensor && self.OutputTensor == other.OutputTensor && self.AxisCount == other.AxisCount && self.Axes == other.Axes && self.NormalizeVariance == other.NormalizeVariance && self.Epsilon == other.Epsilon && self.FusedActivation == other.FusedActivation
4601     }
4602 }
4603 #[cfg(feature = "Win32_Foundation")]
4604 impl ::std::cmp::Eq for DML_MEAN_VARIANCE_NORMALIZATION1_OPERATOR_DESC {}
4605 #[cfg(feature = "Win32_Foundation")]
4606 unsafe impl ::windows::runtime::Abi for DML_MEAN_VARIANCE_NORMALIZATION1_OPERATOR_DESC {
4607     type Abi = Self;
4608     type DefaultType = Self;
4609 }
4610 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4611 #[repr(C)]
4612 #[cfg(feature = "Win32_Foundation")]
4613 pub struct DML_MEAN_VARIANCE_NORMALIZATION_OPERATOR_DESC {
4614     pub InputTensor: *mut DML_TENSOR_DESC,
4615     pub ScaleTensor: *mut DML_TENSOR_DESC,
4616     pub BiasTensor: *mut DML_TENSOR_DESC,
4617     pub OutputTensor: *mut DML_TENSOR_DESC,
4618     pub CrossChannel: super::super::super::Foundation::BOOL,
4619     pub NormalizeVariance: super::super::super::Foundation::BOOL,
4620     pub Epsilon: f32,
4621     pub FusedActivation: *mut DML_OPERATOR_DESC,
4622 }
4623 #[cfg(feature = "Win32_Foundation")]
4624 impl DML_MEAN_VARIANCE_NORMALIZATION_OPERATOR_DESC {}
4625 #[cfg(feature = "Win32_Foundation")]
4626 impl ::std::default::Default for DML_MEAN_VARIANCE_NORMALIZATION_OPERATOR_DESC {
default() -> Self4627     fn default() -> Self {
4628         unsafe { ::std::mem::zeroed() }
4629     }
4630 }
4631 #[cfg(feature = "Win32_Foundation")]
4632 impl ::std::fmt::Debug for DML_MEAN_VARIANCE_NORMALIZATION_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4633     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4634         fmt.debug_struct("DML_MEAN_VARIANCE_NORMALIZATION_OPERATOR_DESC")
4635             .field("InputTensor", &self.InputTensor)
4636             .field("ScaleTensor", &self.ScaleTensor)
4637             .field("BiasTensor", &self.BiasTensor)
4638             .field("OutputTensor", &self.OutputTensor)
4639             .field("CrossChannel", &self.CrossChannel)
4640             .field("NormalizeVariance", &self.NormalizeVariance)
4641             .field("Epsilon", &self.Epsilon)
4642             .field("FusedActivation", &self.FusedActivation)
4643             .finish()
4644     }
4645 }
4646 #[cfg(feature = "Win32_Foundation")]
4647 impl ::std::cmp::PartialEq for DML_MEAN_VARIANCE_NORMALIZATION_OPERATOR_DESC {
eq(&self, other: &Self) -> bool4648     fn eq(&self, other: &Self) -> bool {
4649         self.InputTensor == other.InputTensor && self.ScaleTensor == other.ScaleTensor && self.BiasTensor == other.BiasTensor && self.OutputTensor == other.OutputTensor && self.CrossChannel == other.CrossChannel && self.NormalizeVariance == other.NormalizeVariance && self.Epsilon == other.Epsilon && self.FusedActivation == other.FusedActivation
4650     }
4651 }
4652 #[cfg(feature = "Win32_Foundation")]
4653 impl ::std::cmp::Eq for DML_MEAN_VARIANCE_NORMALIZATION_OPERATOR_DESC {}
4654 #[cfg(feature = "Win32_Foundation")]
4655 unsafe impl ::windows::runtime::Abi for DML_MEAN_VARIANCE_NORMALIZATION_OPERATOR_DESC {
4656     type Abi = Self;
4657     type DefaultType = Self;
4658 }
4659 pub const DML_MINIMUM_BUFFER_TENSOR_ALIGNMENT: u32 = 16u32;
4660 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4661 #[repr(C)]
4662 pub struct DML_NONZERO_COORDINATES_OPERATOR_DESC {
4663     pub InputTensor: *mut DML_TENSOR_DESC,
4664     pub OutputCountTensor: *mut DML_TENSOR_DESC,
4665     pub OutputCoordinatesTensor: *mut DML_TENSOR_DESC,
4666 }
4667 impl DML_NONZERO_COORDINATES_OPERATOR_DESC {}
4668 impl ::std::default::Default for DML_NONZERO_COORDINATES_OPERATOR_DESC {
default() -> Self4669     fn default() -> Self {
4670         unsafe { ::std::mem::zeroed() }
4671     }
4672 }
4673 impl ::std::fmt::Debug for DML_NONZERO_COORDINATES_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4674     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4675         fmt.debug_struct("DML_NONZERO_COORDINATES_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputCountTensor", &self.OutputCountTensor).field("OutputCoordinatesTensor", &self.OutputCoordinatesTensor).finish()
4676     }
4677 }
4678 impl ::std::cmp::PartialEq for DML_NONZERO_COORDINATES_OPERATOR_DESC {
eq(&self, other: &Self) -> bool4679     fn eq(&self, other: &Self) -> bool {
4680         self.InputTensor == other.InputTensor && self.OutputCountTensor == other.OutputCountTensor && self.OutputCoordinatesTensor == other.OutputCoordinatesTensor
4681     }
4682 }
4683 impl ::std::cmp::Eq for DML_NONZERO_COORDINATES_OPERATOR_DESC {}
4684 unsafe impl ::windows::runtime::Abi for DML_NONZERO_COORDINATES_OPERATOR_DESC {
4685     type Abi = Self;
4686     type DefaultType = Self;
4687 }
4688 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4689 #[repr(C)]
4690 pub struct DML_ONE_HOT_OPERATOR_DESC {
4691     pub IndicesTensor: *mut DML_TENSOR_DESC,
4692     pub ValuesTensor: *mut DML_TENSOR_DESC,
4693     pub OutputTensor: *mut DML_TENSOR_DESC,
4694     pub Axis: u32,
4695 }
4696 impl DML_ONE_HOT_OPERATOR_DESC {}
4697 impl ::std::default::Default for DML_ONE_HOT_OPERATOR_DESC {
default() -> Self4698     fn default() -> Self {
4699         unsafe { ::std::mem::zeroed() }
4700     }
4701 }
4702 impl ::std::fmt::Debug for DML_ONE_HOT_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4703     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4704         fmt.debug_struct("DML_ONE_HOT_OPERATOR_DESC").field("IndicesTensor", &self.IndicesTensor).field("ValuesTensor", &self.ValuesTensor).field("OutputTensor", &self.OutputTensor).field("Axis", &self.Axis).finish()
4705     }
4706 }
4707 impl ::std::cmp::PartialEq for DML_ONE_HOT_OPERATOR_DESC {
eq(&self, other: &Self) -> bool4708     fn eq(&self, other: &Self) -> bool {
4709         self.IndicesTensor == other.IndicesTensor && self.ValuesTensor == other.ValuesTensor && self.OutputTensor == other.OutputTensor && self.Axis == other.Axis
4710     }
4711 }
4712 impl ::std::cmp::Eq for DML_ONE_HOT_OPERATOR_DESC {}
4713 unsafe impl ::windows::runtime::Abi for DML_ONE_HOT_OPERATOR_DESC {
4714     type Abi = Self;
4715     type DefaultType = Self;
4716 }
4717 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4718 #[repr(C)]
4719 pub struct DML_OPERATOR_DESC {
4720     pub Type: DML_OPERATOR_TYPE,
4721     pub Desc: *mut ::std::ffi::c_void,
4722 }
4723 impl DML_OPERATOR_DESC {}
4724 impl ::std::default::Default for DML_OPERATOR_DESC {
default() -> Self4725     fn default() -> Self {
4726         unsafe { ::std::mem::zeroed() }
4727     }
4728 }
4729 impl ::std::fmt::Debug for DML_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4730     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4731         fmt.debug_struct("DML_OPERATOR_DESC").field("Type", &self.Type).field("Desc", &self.Desc).finish()
4732     }
4733 }
4734 impl ::std::cmp::PartialEq for DML_OPERATOR_DESC {
eq(&self, other: &Self) -> bool4735     fn eq(&self, other: &Self) -> bool {
4736         self.Type == other.Type && self.Desc == other.Desc
4737     }
4738 }
4739 impl ::std::cmp::Eq for DML_OPERATOR_DESC {}
4740 unsafe impl ::windows::runtime::Abi for DML_OPERATOR_DESC {
4741     type Abi = Self;
4742     type DefaultType = Self;
4743 }
4744 #[derive(:: std :: clone :: Clone)]
4745 #[repr(C)]
4746 #[cfg(feature = "Win32_Foundation")]
4747 pub struct DML_OPERATOR_GRAPH_NODE_DESC {
4748     pub Operator: ::std::option::Option<IDMLOperator>,
4749     pub Name: super::super::super::Foundation::PSTR,
4750 }
4751 #[cfg(feature = "Win32_Foundation")]
4752 impl DML_OPERATOR_GRAPH_NODE_DESC {}
4753 #[cfg(feature = "Win32_Foundation")]
4754 impl ::std::default::Default for DML_OPERATOR_GRAPH_NODE_DESC {
default() -> Self4755     fn default() -> Self {
4756         unsafe { ::std::mem::zeroed() }
4757     }
4758 }
4759 #[cfg(feature = "Win32_Foundation")]
4760 impl ::std::fmt::Debug for DML_OPERATOR_GRAPH_NODE_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4761     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4762         fmt.debug_struct("DML_OPERATOR_GRAPH_NODE_DESC").field("Operator", &self.Operator).field("Name", &self.Name).finish()
4763     }
4764 }
4765 #[cfg(feature = "Win32_Foundation")]
4766 impl ::std::cmp::PartialEq for DML_OPERATOR_GRAPH_NODE_DESC {
eq(&self, other: &Self) -> bool4767     fn eq(&self, other: &Self) -> bool {
4768         self.Operator == other.Operator && self.Name == other.Name
4769     }
4770 }
4771 #[cfg(feature = "Win32_Foundation")]
4772 impl ::std::cmp::Eq for DML_OPERATOR_GRAPH_NODE_DESC {}
4773 #[cfg(feature = "Win32_Foundation")]
4774 unsafe impl ::windows::runtime::Abi for DML_OPERATOR_GRAPH_NODE_DESC {
4775     type Abi = ::std::mem::ManuallyDrop<Self>;
4776     type DefaultType = Self;
4777 }
4778 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4779 #[repr(transparent)]
4780 pub struct DML_OPERATOR_TYPE(pub i32);
4781 pub const DML_OPERATOR_INVALID: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(0i32);
4782 pub const DML_OPERATOR_ELEMENT_WISE_IDENTITY: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(1i32);
4783 pub const DML_OPERATOR_ELEMENT_WISE_ABS: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(2i32);
4784 pub const DML_OPERATOR_ELEMENT_WISE_ACOS: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(3i32);
4785 pub const DML_OPERATOR_ELEMENT_WISE_ADD: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(4i32);
4786 pub const DML_OPERATOR_ELEMENT_WISE_ASIN: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(5i32);
4787 pub const DML_OPERATOR_ELEMENT_WISE_ATAN: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(6i32);
4788 pub const DML_OPERATOR_ELEMENT_WISE_CEIL: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(7i32);
4789 pub const DML_OPERATOR_ELEMENT_WISE_CLIP: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(8i32);
4790 pub const DML_OPERATOR_ELEMENT_WISE_COS: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(9i32);
4791 pub const DML_OPERATOR_ELEMENT_WISE_DIVIDE: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(10i32);
4792 pub const DML_OPERATOR_ELEMENT_WISE_EXP: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(11i32);
4793 pub const DML_OPERATOR_ELEMENT_WISE_FLOOR: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(12i32);
4794 pub const DML_OPERATOR_ELEMENT_WISE_LOG: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(13i32);
4795 pub const DML_OPERATOR_ELEMENT_WISE_LOGICAL_AND: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(14i32);
4796 pub const DML_OPERATOR_ELEMENT_WISE_LOGICAL_EQUALS: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(15i32);
4797 pub const DML_OPERATOR_ELEMENT_WISE_LOGICAL_GREATER_THAN: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(16i32);
4798 pub const DML_OPERATOR_ELEMENT_WISE_LOGICAL_LESS_THAN: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(17i32);
4799 pub const DML_OPERATOR_ELEMENT_WISE_LOGICAL_NOT: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(18i32);
4800 pub const DML_OPERATOR_ELEMENT_WISE_LOGICAL_OR: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(19i32);
4801 pub const DML_OPERATOR_ELEMENT_WISE_LOGICAL_XOR: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(20i32);
4802 pub const DML_OPERATOR_ELEMENT_WISE_MAX: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(21i32);
4803 pub const DML_OPERATOR_ELEMENT_WISE_MEAN: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(22i32);
4804 pub const DML_OPERATOR_ELEMENT_WISE_MIN: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(23i32);
4805 pub const DML_OPERATOR_ELEMENT_WISE_MULTIPLY: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(24i32);
4806 pub const DML_OPERATOR_ELEMENT_WISE_POW: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(25i32);
4807 pub const DML_OPERATOR_ELEMENT_WISE_CONSTANT_POW: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(26i32);
4808 pub const DML_OPERATOR_ELEMENT_WISE_RECIP: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(27i32);
4809 pub const DML_OPERATOR_ELEMENT_WISE_SIN: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(28i32);
4810 pub const DML_OPERATOR_ELEMENT_WISE_SQRT: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(29i32);
4811 pub const DML_OPERATOR_ELEMENT_WISE_SUBTRACT: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(30i32);
4812 pub const DML_OPERATOR_ELEMENT_WISE_TAN: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(31i32);
4813 pub const DML_OPERATOR_ELEMENT_WISE_THRESHOLD: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(32i32);
4814 pub const DML_OPERATOR_ELEMENT_WISE_QUANTIZE_LINEAR: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(33i32);
4815 pub const DML_OPERATOR_ELEMENT_WISE_DEQUANTIZE_LINEAR: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(34i32);
4816 pub const DML_OPERATOR_ACTIVATION_ELU: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(35i32);
4817 pub const DML_OPERATOR_ACTIVATION_HARDMAX: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(36i32);
4818 pub const DML_OPERATOR_ACTIVATION_HARD_SIGMOID: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(37i32);
4819 pub const DML_OPERATOR_ACTIVATION_IDENTITY: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(38i32);
4820 pub const DML_OPERATOR_ACTIVATION_LEAKY_RELU: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(39i32);
4821 pub const DML_OPERATOR_ACTIVATION_LINEAR: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(40i32);
4822 pub const DML_OPERATOR_ACTIVATION_LOG_SOFTMAX: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(41i32);
4823 pub const DML_OPERATOR_ACTIVATION_PARAMETERIZED_RELU: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(42i32);
4824 pub const DML_OPERATOR_ACTIVATION_PARAMETRIC_SOFTPLUS: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(43i32);
4825 pub const DML_OPERATOR_ACTIVATION_RELU: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(44i32);
4826 pub const DML_OPERATOR_ACTIVATION_SCALED_ELU: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(45i32);
4827 pub const DML_OPERATOR_ACTIVATION_SCALED_TANH: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(46i32);
4828 pub const DML_OPERATOR_ACTIVATION_SIGMOID: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(47i32);
4829 pub const DML_OPERATOR_ACTIVATION_SOFTMAX: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(48i32);
4830 pub const DML_OPERATOR_ACTIVATION_SOFTPLUS: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(49i32);
4831 pub const DML_OPERATOR_ACTIVATION_SOFTSIGN: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(50i32);
4832 pub const DML_OPERATOR_ACTIVATION_TANH: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(51i32);
4833 pub const DML_OPERATOR_ACTIVATION_THRESHOLDED_RELU: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(52i32);
4834 pub const DML_OPERATOR_CONVOLUTION: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(53i32);
4835 pub const DML_OPERATOR_GEMM: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(54i32);
4836 pub const DML_OPERATOR_REDUCE: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(55i32);
4837 pub const DML_OPERATOR_AVERAGE_POOLING: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(56i32);
4838 pub const DML_OPERATOR_LP_POOLING: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(57i32);
4839 pub const DML_OPERATOR_MAX_POOLING: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(58i32);
4840 pub const DML_OPERATOR_ROI_POOLING: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(59i32);
4841 pub const DML_OPERATOR_SLICE: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(60i32);
4842 pub const DML_OPERATOR_CAST: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(61i32);
4843 pub const DML_OPERATOR_SPLIT: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(62i32);
4844 pub const DML_OPERATOR_JOIN: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(63i32);
4845 pub const DML_OPERATOR_PADDING: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(64i32);
4846 pub const DML_OPERATOR_VALUE_SCALE_2D: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(65i32);
4847 pub const DML_OPERATOR_UPSAMPLE_2D: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(66i32);
4848 pub const DML_OPERATOR_GATHER: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(67i32);
4849 pub const DML_OPERATOR_SPACE_TO_DEPTH: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(68i32);
4850 pub const DML_OPERATOR_DEPTH_TO_SPACE: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(69i32);
4851 pub const DML_OPERATOR_TILE: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(70i32);
4852 pub const DML_OPERATOR_TOP_K: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(71i32);
4853 pub const DML_OPERATOR_BATCH_NORMALIZATION: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(72i32);
4854 pub const DML_OPERATOR_MEAN_VARIANCE_NORMALIZATION: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(73i32);
4855 pub const DML_OPERATOR_LOCAL_RESPONSE_NORMALIZATION: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(74i32);
4856 pub const DML_OPERATOR_LP_NORMALIZATION: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(75i32);
4857 pub const DML_OPERATOR_RNN: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(76i32);
4858 pub const DML_OPERATOR_LSTM: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(77i32);
4859 pub const DML_OPERATOR_GRU: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(78i32);
4860 pub const DML_OPERATOR_ELEMENT_WISE_SIGN: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(79i32);
4861 pub const DML_OPERATOR_ELEMENT_WISE_IS_NAN: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(80i32);
4862 pub const DML_OPERATOR_ELEMENT_WISE_ERF: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(81i32);
4863 pub const DML_OPERATOR_ELEMENT_WISE_SINH: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(82i32);
4864 pub const DML_OPERATOR_ELEMENT_WISE_COSH: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(83i32);
4865 pub const DML_OPERATOR_ELEMENT_WISE_TANH: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(84i32);
4866 pub const DML_OPERATOR_ELEMENT_WISE_ASINH: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(85i32);
4867 pub const DML_OPERATOR_ELEMENT_WISE_ACOSH: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(86i32);
4868 pub const DML_OPERATOR_ELEMENT_WISE_ATANH: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(87i32);
4869 pub const DML_OPERATOR_ELEMENT_WISE_IF: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(88i32);
4870 pub const DML_OPERATOR_ELEMENT_WISE_ADD1: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(89i32);
4871 pub const DML_OPERATOR_ACTIVATION_SHRINK: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(90i32);
4872 pub const DML_OPERATOR_MAX_POOLING1: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(91i32);
4873 pub const DML_OPERATOR_MAX_UNPOOLING: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(92i32);
4874 pub const DML_OPERATOR_DIAGONAL_MATRIX: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(93i32);
4875 pub const DML_OPERATOR_SCATTER_ELEMENTS: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(94i32);
4876 pub const DML_OPERATOR_SCATTER: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(94i32);
4877 pub const DML_OPERATOR_ONE_HOT: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(95i32);
4878 pub const DML_OPERATOR_RESAMPLE: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(96i32);
4879 pub const DML_OPERATOR_ELEMENT_WISE_BIT_SHIFT_LEFT: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(97i32);
4880 pub const DML_OPERATOR_ELEMENT_WISE_BIT_SHIFT_RIGHT: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(98i32);
4881 pub const DML_OPERATOR_ELEMENT_WISE_ROUND: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(99i32);
4882 pub const DML_OPERATOR_ELEMENT_WISE_IS_INFINITY: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(100i32);
4883 pub const DML_OPERATOR_ELEMENT_WISE_MODULUS_TRUNCATE: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(101i32);
4884 pub const DML_OPERATOR_ELEMENT_WISE_MODULUS_FLOOR: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(102i32);
4885 pub const DML_OPERATOR_FILL_VALUE_CONSTANT: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(103i32);
4886 pub const DML_OPERATOR_FILL_VALUE_SEQUENCE: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(104i32);
4887 pub const DML_OPERATOR_CUMULATIVE_SUMMATION: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(105i32);
4888 pub const DML_OPERATOR_REVERSE_SUBSEQUENCES: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(106i32);
4889 pub const DML_OPERATOR_GATHER_ELEMENTS: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(107i32);
4890 pub const DML_OPERATOR_GATHER_ND: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(108i32);
4891 pub const DML_OPERATOR_SCATTER_ND: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(109i32);
4892 pub const DML_OPERATOR_MAX_POOLING2: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(110i32);
4893 pub const DML_OPERATOR_SLICE1: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(111i32);
4894 pub const DML_OPERATOR_TOP_K1: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(112i32);
4895 pub const DML_OPERATOR_DEPTH_TO_SPACE1: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(113i32);
4896 pub const DML_OPERATOR_SPACE_TO_DEPTH1: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(114i32);
4897 pub const DML_OPERATOR_MEAN_VARIANCE_NORMALIZATION1: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(115i32);
4898 pub const DML_OPERATOR_RESAMPLE1: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(116i32);
4899 pub const DML_OPERATOR_MATRIX_MULTIPLY_INTEGER: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(117i32);
4900 pub const DML_OPERATOR_QUANTIZED_LINEAR_MATRIX_MULTIPLY: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(118i32);
4901 pub const DML_OPERATOR_CONVOLUTION_INTEGER: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(119i32);
4902 pub const DML_OPERATOR_QUANTIZED_LINEAR_CONVOLUTION: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(120i32);
4903 pub const DML_OPERATOR_ELEMENT_WISE_BIT_AND: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(121i32);
4904 pub const DML_OPERATOR_ELEMENT_WISE_BIT_OR: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(122i32);
4905 pub const DML_OPERATOR_ELEMENT_WISE_BIT_XOR: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(123i32);
4906 pub const DML_OPERATOR_ELEMENT_WISE_BIT_NOT: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(124i32);
4907 pub const DML_OPERATOR_ELEMENT_WISE_BIT_COUNT: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(125i32);
4908 pub const DML_OPERATOR_ELEMENT_WISE_LOGICAL_GREATER_THAN_OR_EQUAL: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(126i32);
4909 pub const DML_OPERATOR_ELEMENT_WISE_LOGICAL_LESS_THAN_OR_EQUAL: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(127i32);
4910 pub const DML_OPERATOR_ACTIVATION_CELU: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(128i32);
4911 pub const DML_OPERATOR_ACTIVATION_RELU_GRAD: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(129i32);
4912 pub const DML_OPERATOR_AVERAGE_POOLING_GRAD: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(130i32);
4913 pub const DML_OPERATOR_MAX_POOLING_GRAD: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(131i32);
4914 pub const DML_OPERATOR_RANDOM_GENERATOR: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(132i32);
4915 pub const DML_OPERATOR_NONZERO_COORDINATES: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(133i32);
4916 pub const DML_OPERATOR_RESAMPLE_GRAD: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(134i32);
4917 pub const DML_OPERATOR_SLICE_GRAD: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(135i32);
4918 pub const DML_OPERATOR_ADAM_OPTIMIZER: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(136i32);
4919 pub const DML_OPERATOR_ARGMIN: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(137i32);
4920 pub const DML_OPERATOR_ARGMAX: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(138i32);
4921 pub const DML_OPERATOR_ROI_ALIGN: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(139i32);
4922 pub const DML_OPERATOR_GATHER_ND1: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(140i32);
4923 pub const DML_OPERATOR_ELEMENT_WISE_ATAN_YX: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(141i32);
4924 pub const DML_OPERATOR_ELEMENT_WISE_CLIP_GRAD: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(142i32);
4925 pub const DML_OPERATOR_ELEMENT_WISE_DIFFERENCE_SQUARE: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(143i32);
4926 pub const DML_OPERATOR_LOCAL_RESPONSE_NORMALIZATION_GRAD: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(144i32);
4927 pub const DML_OPERATOR_CUMULATIVE_PRODUCT: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(145i32);
4928 pub const DML_OPERATOR_BATCH_NORMALIZATION_GRAD: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(146i32);
4929 pub const DML_OPERATOR_ELEMENT_WISE_QUANTIZED_LINEAR_ADD: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(147i32);
4930 pub const DML_OPERATOR_DYNAMIC_QUANTIZE_LINEAR: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(148i32);
4931 pub const DML_OPERATOR_ROI_ALIGN1: DML_OPERATOR_TYPE = DML_OPERATOR_TYPE(149i32);
4932 impl ::std::convert::From<i32> for DML_OPERATOR_TYPE {
from(value: i32) -> Self4933     fn from(value: i32) -> Self {
4934         Self(value)
4935     }
4936 }
4937 unsafe impl ::windows::runtime::Abi for DML_OPERATOR_TYPE {
4938     type Abi = Self;
4939     type DefaultType = Self;
4940 }
4941 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4942 #[repr(C)]
4943 #[cfg(feature = "Win32_Foundation")]
4944 pub struct DML_OUTPUT_GRAPH_EDGE_DESC {
4945     pub FromNodeIndex: u32,
4946     pub FromNodeOutputIndex: u32,
4947     pub GraphOutputIndex: u32,
4948     pub Name: super::super::super::Foundation::PSTR,
4949 }
4950 #[cfg(feature = "Win32_Foundation")]
4951 impl DML_OUTPUT_GRAPH_EDGE_DESC {}
4952 #[cfg(feature = "Win32_Foundation")]
4953 impl ::std::default::Default for DML_OUTPUT_GRAPH_EDGE_DESC {
default() -> Self4954     fn default() -> Self {
4955         unsafe { ::std::mem::zeroed() }
4956     }
4957 }
4958 #[cfg(feature = "Win32_Foundation")]
4959 impl ::std::fmt::Debug for DML_OUTPUT_GRAPH_EDGE_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result4960     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4961         fmt.debug_struct("DML_OUTPUT_GRAPH_EDGE_DESC").field("FromNodeIndex", &self.FromNodeIndex).field("FromNodeOutputIndex", &self.FromNodeOutputIndex).field("GraphOutputIndex", &self.GraphOutputIndex).field("Name", &self.Name).finish()
4962     }
4963 }
4964 #[cfg(feature = "Win32_Foundation")]
4965 impl ::std::cmp::PartialEq for DML_OUTPUT_GRAPH_EDGE_DESC {
eq(&self, other: &Self) -> bool4966     fn eq(&self, other: &Self) -> bool {
4967         self.FromNodeIndex == other.FromNodeIndex && self.FromNodeOutputIndex == other.FromNodeOutputIndex && self.GraphOutputIndex == other.GraphOutputIndex && self.Name == other.Name
4968     }
4969 }
4970 #[cfg(feature = "Win32_Foundation")]
4971 impl ::std::cmp::Eq for DML_OUTPUT_GRAPH_EDGE_DESC {}
4972 #[cfg(feature = "Win32_Foundation")]
4973 unsafe impl ::windows::runtime::Abi for DML_OUTPUT_GRAPH_EDGE_DESC {
4974     type Abi = Self;
4975     type DefaultType = Self;
4976 }
4977 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4978 #[repr(transparent)]
4979 pub struct DML_PADDING_MODE(pub i32);
4980 pub const DML_PADDING_MODE_CONSTANT: DML_PADDING_MODE = DML_PADDING_MODE(0i32);
4981 pub const DML_PADDING_MODE_EDGE: DML_PADDING_MODE = DML_PADDING_MODE(1i32);
4982 pub const DML_PADDING_MODE_REFLECTION: DML_PADDING_MODE = DML_PADDING_MODE(2i32);
4983 pub const DML_PADDING_MODE_SYMMETRIC: DML_PADDING_MODE = DML_PADDING_MODE(3i32);
4984 impl ::std::convert::From<i32> for DML_PADDING_MODE {
from(value: i32) -> Self4985     fn from(value: i32) -> Self {
4986         Self(value)
4987     }
4988 }
4989 unsafe impl ::windows::runtime::Abi for DML_PADDING_MODE {
4990     type Abi = Self;
4991     type DefaultType = Self;
4992 }
4993 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
4994 #[repr(C)]
4995 pub struct DML_PADDING_OPERATOR_DESC {
4996     pub InputTensor: *mut DML_TENSOR_DESC,
4997     pub OutputTensor: *mut DML_TENSOR_DESC,
4998     pub PaddingMode: DML_PADDING_MODE,
4999     pub PaddingValue: f32,
5000     pub DimensionCount: u32,
5001     pub StartPadding: *mut u32,
5002     pub EndPadding: *mut u32,
5003 }
5004 impl DML_PADDING_OPERATOR_DESC {}
5005 impl ::std::default::Default for DML_PADDING_OPERATOR_DESC {
default() -> Self5006     fn default() -> Self {
5007         unsafe { ::std::mem::zeroed() }
5008     }
5009 }
5010 impl ::std::fmt::Debug for DML_PADDING_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5011     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5012         fmt.debug_struct("DML_PADDING_OPERATOR_DESC")
5013             .field("InputTensor", &self.InputTensor)
5014             .field("OutputTensor", &self.OutputTensor)
5015             .field("PaddingMode", &self.PaddingMode)
5016             .field("PaddingValue", &self.PaddingValue)
5017             .field("DimensionCount", &self.DimensionCount)
5018             .field("StartPadding", &self.StartPadding)
5019             .field("EndPadding", &self.EndPadding)
5020             .finish()
5021     }
5022 }
5023 impl ::std::cmp::PartialEq for DML_PADDING_OPERATOR_DESC {
eq(&self, other: &Self) -> bool5024     fn eq(&self, other: &Self) -> bool {
5025         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.PaddingMode == other.PaddingMode && self.PaddingValue == other.PaddingValue && self.DimensionCount == other.DimensionCount && self.StartPadding == other.StartPadding && self.EndPadding == other.EndPadding
5026     }
5027 }
5028 impl ::std::cmp::Eq for DML_PADDING_OPERATOR_DESC {}
5029 unsafe impl ::windows::runtime::Abi for DML_PADDING_OPERATOR_DESC {
5030     type Abi = Self;
5031     type DefaultType = Self;
5032 }
5033 pub const DML_PERSISTENT_BUFFER_ALIGNMENT: u32 = 256u32;
5034 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5035 #[repr(C)]
5036 pub struct DML_QUANTIZED_LINEAR_CONVOLUTION_OPERATOR_DESC {
5037     pub InputTensor: *mut DML_TENSOR_DESC,
5038     pub InputScaleTensor: *mut DML_TENSOR_DESC,
5039     pub InputZeroPointTensor: *mut DML_TENSOR_DESC,
5040     pub FilterTensor: *mut DML_TENSOR_DESC,
5041     pub FilterScaleTensor: *mut DML_TENSOR_DESC,
5042     pub FilterZeroPointTensor: *mut DML_TENSOR_DESC,
5043     pub BiasTensor: *mut DML_TENSOR_DESC,
5044     pub OutputScaleTensor: *mut DML_TENSOR_DESC,
5045     pub OutputZeroPointTensor: *mut DML_TENSOR_DESC,
5046     pub OutputTensor: *mut DML_TENSOR_DESC,
5047     pub DimensionCount: u32,
5048     pub Strides: *mut u32,
5049     pub Dilations: *mut u32,
5050     pub StartPadding: *mut u32,
5051     pub EndPadding: *mut u32,
5052     pub GroupCount: u32,
5053 }
5054 impl DML_QUANTIZED_LINEAR_CONVOLUTION_OPERATOR_DESC {}
5055 impl ::std::default::Default for DML_QUANTIZED_LINEAR_CONVOLUTION_OPERATOR_DESC {
default() -> Self5056     fn default() -> Self {
5057         unsafe { ::std::mem::zeroed() }
5058     }
5059 }
5060 impl ::std::fmt::Debug for DML_QUANTIZED_LINEAR_CONVOLUTION_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5061     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5062         fmt.debug_struct("DML_QUANTIZED_LINEAR_CONVOLUTION_OPERATOR_DESC")
5063             .field("InputTensor", &self.InputTensor)
5064             .field("InputScaleTensor", &self.InputScaleTensor)
5065             .field("InputZeroPointTensor", &self.InputZeroPointTensor)
5066             .field("FilterTensor", &self.FilterTensor)
5067             .field("FilterScaleTensor", &self.FilterScaleTensor)
5068             .field("FilterZeroPointTensor", &self.FilterZeroPointTensor)
5069             .field("BiasTensor", &self.BiasTensor)
5070             .field("OutputScaleTensor", &self.OutputScaleTensor)
5071             .field("OutputZeroPointTensor", &self.OutputZeroPointTensor)
5072             .field("OutputTensor", &self.OutputTensor)
5073             .field("DimensionCount", &self.DimensionCount)
5074             .field("Strides", &self.Strides)
5075             .field("Dilations", &self.Dilations)
5076             .field("StartPadding", &self.StartPadding)
5077             .field("EndPadding", &self.EndPadding)
5078             .field("GroupCount", &self.GroupCount)
5079             .finish()
5080     }
5081 }
5082 impl ::std::cmp::PartialEq for DML_QUANTIZED_LINEAR_CONVOLUTION_OPERATOR_DESC {
eq(&self, other: &Self) -> bool5083     fn eq(&self, other: &Self) -> bool {
5084         self.InputTensor == other.InputTensor
5085             && self.InputScaleTensor == other.InputScaleTensor
5086             && self.InputZeroPointTensor == other.InputZeroPointTensor
5087             && self.FilterTensor == other.FilterTensor
5088             && self.FilterScaleTensor == other.FilterScaleTensor
5089             && self.FilterZeroPointTensor == other.FilterZeroPointTensor
5090             && self.BiasTensor == other.BiasTensor
5091             && self.OutputScaleTensor == other.OutputScaleTensor
5092             && self.OutputZeroPointTensor == other.OutputZeroPointTensor
5093             && self.OutputTensor == other.OutputTensor
5094             && self.DimensionCount == other.DimensionCount
5095             && self.Strides == other.Strides
5096             && self.Dilations == other.Dilations
5097             && self.StartPadding == other.StartPadding
5098             && self.EndPadding == other.EndPadding
5099             && self.GroupCount == other.GroupCount
5100     }
5101 }
5102 impl ::std::cmp::Eq for DML_QUANTIZED_LINEAR_CONVOLUTION_OPERATOR_DESC {}
5103 unsafe impl ::windows::runtime::Abi for DML_QUANTIZED_LINEAR_CONVOLUTION_OPERATOR_DESC {
5104     type Abi = Self;
5105     type DefaultType = Self;
5106 }
5107 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5108 #[repr(C)]
5109 pub struct DML_QUANTIZED_LINEAR_MATRIX_MULTIPLY_OPERATOR_DESC {
5110     pub ATensor: *mut DML_TENSOR_DESC,
5111     pub AScaleTensor: *mut DML_TENSOR_DESC,
5112     pub AZeroPointTensor: *mut DML_TENSOR_DESC,
5113     pub BTensor: *mut DML_TENSOR_DESC,
5114     pub BScaleTensor: *mut DML_TENSOR_DESC,
5115     pub BZeroPointTensor: *mut DML_TENSOR_DESC,
5116     pub OutputScaleTensor: *mut DML_TENSOR_DESC,
5117     pub OutputZeroPointTensor: *mut DML_TENSOR_DESC,
5118     pub OutputTensor: *mut DML_TENSOR_DESC,
5119 }
5120 impl DML_QUANTIZED_LINEAR_MATRIX_MULTIPLY_OPERATOR_DESC {}
5121 impl ::std::default::Default for DML_QUANTIZED_LINEAR_MATRIX_MULTIPLY_OPERATOR_DESC {
default() -> Self5122     fn default() -> Self {
5123         unsafe { ::std::mem::zeroed() }
5124     }
5125 }
5126 impl ::std::fmt::Debug for DML_QUANTIZED_LINEAR_MATRIX_MULTIPLY_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5127     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5128         fmt.debug_struct("DML_QUANTIZED_LINEAR_MATRIX_MULTIPLY_OPERATOR_DESC")
5129             .field("ATensor", &self.ATensor)
5130             .field("AScaleTensor", &self.AScaleTensor)
5131             .field("AZeroPointTensor", &self.AZeroPointTensor)
5132             .field("BTensor", &self.BTensor)
5133             .field("BScaleTensor", &self.BScaleTensor)
5134             .field("BZeroPointTensor", &self.BZeroPointTensor)
5135             .field("OutputScaleTensor", &self.OutputScaleTensor)
5136             .field("OutputZeroPointTensor", &self.OutputZeroPointTensor)
5137             .field("OutputTensor", &self.OutputTensor)
5138             .finish()
5139     }
5140 }
5141 impl ::std::cmp::PartialEq for DML_QUANTIZED_LINEAR_MATRIX_MULTIPLY_OPERATOR_DESC {
eq(&self, other: &Self) -> bool5142     fn eq(&self, other: &Self) -> bool {
5143         self.ATensor == other.ATensor && self.AScaleTensor == other.AScaleTensor && self.AZeroPointTensor == other.AZeroPointTensor && self.BTensor == other.BTensor && self.BScaleTensor == other.BScaleTensor && self.BZeroPointTensor == other.BZeroPointTensor && self.OutputScaleTensor == other.OutputScaleTensor && self.OutputZeroPointTensor == other.OutputZeroPointTensor && self.OutputTensor == other.OutputTensor
5144     }
5145 }
5146 impl ::std::cmp::Eq for DML_QUANTIZED_LINEAR_MATRIX_MULTIPLY_OPERATOR_DESC {}
5147 unsafe impl ::windows::runtime::Abi for DML_QUANTIZED_LINEAR_MATRIX_MULTIPLY_OPERATOR_DESC {
5148     type Abi = Self;
5149     type DefaultType = Self;
5150 }
5151 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5152 #[repr(C)]
5153 pub struct DML_RANDOM_GENERATOR_OPERATOR_DESC {
5154     pub InputStateTensor: *mut DML_TENSOR_DESC,
5155     pub OutputTensor: *mut DML_TENSOR_DESC,
5156     pub OutputStateTensor: *mut DML_TENSOR_DESC,
5157     pub Type: DML_RANDOM_GENERATOR_TYPE,
5158 }
5159 impl DML_RANDOM_GENERATOR_OPERATOR_DESC {}
5160 impl ::std::default::Default for DML_RANDOM_GENERATOR_OPERATOR_DESC {
default() -> Self5161     fn default() -> Self {
5162         unsafe { ::std::mem::zeroed() }
5163     }
5164 }
5165 impl ::std::fmt::Debug for DML_RANDOM_GENERATOR_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5166     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5167         fmt.debug_struct("DML_RANDOM_GENERATOR_OPERATOR_DESC").field("InputStateTensor", &self.InputStateTensor).field("OutputTensor", &self.OutputTensor).field("OutputStateTensor", &self.OutputStateTensor).field("Type", &self.Type).finish()
5168     }
5169 }
5170 impl ::std::cmp::PartialEq for DML_RANDOM_GENERATOR_OPERATOR_DESC {
eq(&self, other: &Self) -> bool5171     fn eq(&self, other: &Self) -> bool {
5172         self.InputStateTensor == other.InputStateTensor && self.OutputTensor == other.OutputTensor && self.OutputStateTensor == other.OutputStateTensor && self.Type == other.Type
5173     }
5174 }
5175 impl ::std::cmp::Eq for DML_RANDOM_GENERATOR_OPERATOR_DESC {}
5176 unsafe impl ::windows::runtime::Abi for DML_RANDOM_GENERATOR_OPERATOR_DESC {
5177     type Abi = Self;
5178     type DefaultType = Self;
5179 }
5180 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5181 #[repr(transparent)]
5182 pub struct DML_RANDOM_GENERATOR_TYPE(pub i32);
5183 pub const DML_RANDOM_GENERATOR_TYPE_PHILOX_4X32_10: DML_RANDOM_GENERATOR_TYPE = DML_RANDOM_GENERATOR_TYPE(0i32);
5184 impl ::std::convert::From<i32> for DML_RANDOM_GENERATOR_TYPE {
from(value: i32) -> Self5185     fn from(value: i32) -> Self {
5186         Self(value)
5187     }
5188 }
5189 unsafe impl ::windows::runtime::Abi for DML_RANDOM_GENERATOR_TYPE {
5190     type Abi = Self;
5191     type DefaultType = Self;
5192 }
5193 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5194 #[repr(transparent)]
5195 pub struct DML_RECURRENT_NETWORK_DIRECTION(pub i32);
5196 pub const DML_RECURRENT_NETWORK_DIRECTION_FORWARD: DML_RECURRENT_NETWORK_DIRECTION = DML_RECURRENT_NETWORK_DIRECTION(0i32);
5197 pub const DML_RECURRENT_NETWORK_DIRECTION_BACKWARD: DML_RECURRENT_NETWORK_DIRECTION = DML_RECURRENT_NETWORK_DIRECTION(1i32);
5198 pub const DML_RECURRENT_NETWORK_DIRECTION_BIDIRECTIONAL: DML_RECURRENT_NETWORK_DIRECTION = DML_RECURRENT_NETWORK_DIRECTION(2i32);
5199 impl ::std::convert::From<i32> for DML_RECURRENT_NETWORK_DIRECTION {
from(value: i32) -> Self5200     fn from(value: i32) -> Self {
5201         Self(value)
5202     }
5203 }
5204 unsafe impl ::windows::runtime::Abi for DML_RECURRENT_NETWORK_DIRECTION {
5205     type Abi = Self;
5206     type DefaultType = Self;
5207 }
5208 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5209 #[repr(transparent)]
5210 pub struct DML_REDUCE_FUNCTION(pub i32);
5211 pub const DML_REDUCE_FUNCTION_ARGMAX: DML_REDUCE_FUNCTION = DML_REDUCE_FUNCTION(0i32);
5212 pub const DML_REDUCE_FUNCTION_ARGMIN: DML_REDUCE_FUNCTION = DML_REDUCE_FUNCTION(1i32);
5213 pub const DML_REDUCE_FUNCTION_AVERAGE: DML_REDUCE_FUNCTION = DML_REDUCE_FUNCTION(2i32);
5214 pub const DML_REDUCE_FUNCTION_L1: DML_REDUCE_FUNCTION = DML_REDUCE_FUNCTION(3i32);
5215 pub const DML_REDUCE_FUNCTION_L2: DML_REDUCE_FUNCTION = DML_REDUCE_FUNCTION(4i32);
5216 pub const DML_REDUCE_FUNCTION_LOG_SUM: DML_REDUCE_FUNCTION = DML_REDUCE_FUNCTION(5i32);
5217 pub const DML_REDUCE_FUNCTION_LOG_SUM_EXP: DML_REDUCE_FUNCTION = DML_REDUCE_FUNCTION(6i32);
5218 pub const DML_REDUCE_FUNCTION_MAX: DML_REDUCE_FUNCTION = DML_REDUCE_FUNCTION(7i32);
5219 pub const DML_REDUCE_FUNCTION_MIN: DML_REDUCE_FUNCTION = DML_REDUCE_FUNCTION(8i32);
5220 pub const DML_REDUCE_FUNCTION_MULTIPLY: DML_REDUCE_FUNCTION = DML_REDUCE_FUNCTION(9i32);
5221 pub const DML_REDUCE_FUNCTION_SUM: DML_REDUCE_FUNCTION = DML_REDUCE_FUNCTION(10i32);
5222 pub const DML_REDUCE_FUNCTION_SUM_SQUARE: DML_REDUCE_FUNCTION = DML_REDUCE_FUNCTION(11i32);
5223 impl ::std::convert::From<i32> for DML_REDUCE_FUNCTION {
from(value: i32) -> Self5224     fn from(value: i32) -> Self {
5225         Self(value)
5226     }
5227 }
5228 unsafe impl ::windows::runtime::Abi for DML_REDUCE_FUNCTION {
5229     type Abi = Self;
5230     type DefaultType = Self;
5231 }
5232 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5233 #[repr(C)]
5234 pub struct DML_REDUCE_OPERATOR_DESC {
5235     pub Function: DML_REDUCE_FUNCTION,
5236     pub InputTensor: *mut DML_TENSOR_DESC,
5237     pub OutputTensor: *mut DML_TENSOR_DESC,
5238     pub AxisCount: u32,
5239     pub Axes: *mut u32,
5240 }
5241 impl DML_REDUCE_OPERATOR_DESC {}
5242 impl ::std::default::Default for DML_REDUCE_OPERATOR_DESC {
default() -> Self5243     fn default() -> Self {
5244         unsafe { ::std::mem::zeroed() }
5245     }
5246 }
5247 impl ::std::fmt::Debug for DML_REDUCE_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5248     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5249         fmt.debug_struct("DML_REDUCE_OPERATOR_DESC").field("Function", &self.Function).field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("AxisCount", &self.AxisCount).field("Axes", &self.Axes).finish()
5250     }
5251 }
5252 impl ::std::cmp::PartialEq for DML_REDUCE_OPERATOR_DESC {
eq(&self, other: &Self) -> bool5253     fn eq(&self, other: &Self) -> bool {
5254         self.Function == other.Function && self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.AxisCount == other.AxisCount && self.Axes == other.Axes
5255     }
5256 }
5257 impl ::std::cmp::Eq for DML_REDUCE_OPERATOR_DESC {}
5258 unsafe impl ::windows::runtime::Abi for DML_REDUCE_OPERATOR_DESC {
5259     type Abi = Self;
5260     type DefaultType = Self;
5261 }
5262 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5263 #[repr(C)]
5264 pub struct DML_RESAMPLE1_OPERATOR_DESC {
5265     pub InputTensor: *mut DML_TENSOR_DESC,
5266     pub OutputTensor: *mut DML_TENSOR_DESC,
5267     pub InterpolationMode: DML_INTERPOLATION_MODE,
5268     pub DimensionCount: u32,
5269     pub Scales: *mut f32,
5270     pub InputPixelOffsets: *mut f32,
5271     pub OutputPixelOffsets: *mut f32,
5272 }
5273 impl DML_RESAMPLE1_OPERATOR_DESC {}
5274 impl ::std::default::Default for DML_RESAMPLE1_OPERATOR_DESC {
default() -> Self5275     fn default() -> Self {
5276         unsafe { ::std::mem::zeroed() }
5277     }
5278 }
5279 impl ::std::fmt::Debug for DML_RESAMPLE1_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5280     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5281         fmt.debug_struct("DML_RESAMPLE1_OPERATOR_DESC")
5282             .field("InputTensor", &self.InputTensor)
5283             .field("OutputTensor", &self.OutputTensor)
5284             .field("InterpolationMode", &self.InterpolationMode)
5285             .field("DimensionCount", &self.DimensionCount)
5286             .field("Scales", &self.Scales)
5287             .field("InputPixelOffsets", &self.InputPixelOffsets)
5288             .field("OutputPixelOffsets", &self.OutputPixelOffsets)
5289             .finish()
5290     }
5291 }
5292 impl ::std::cmp::PartialEq for DML_RESAMPLE1_OPERATOR_DESC {
eq(&self, other: &Self) -> bool5293     fn eq(&self, other: &Self) -> bool {
5294         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.InterpolationMode == other.InterpolationMode && self.DimensionCount == other.DimensionCount && self.Scales == other.Scales && self.InputPixelOffsets == other.InputPixelOffsets && self.OutputPixelOffsets == other.OutputPixelOffsets
5295     }
5296 }
5297 impl ::std::cmp::Eq for DML_RESAMPLE1_OPERATOR_DESC {}
5298 unsafe impl ::windows::runtime::Abi for DML_RESAMPLE1_OPERATOR_DESC {
5299     type Abi = Self;
5300     type DefaultType = Self;
5301 }
5302 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5303 #[repr(C)]
5304 pub struct DML_RESAMPLE_GRAD_OPERATOR_DESC {
5305     pub InputGradientTensor: *mut DML_TENSOR_DESC,
5306     pub OutputGradientTensor: *mut DML_TENSOR_DESC,
5307     pub InterpolationMode: DML_INTERPOLATION_MODE,
5308     pub DimensionCount: u32,
5309     pub Scales: *mut f32,
5310     pub InputPixelOffsets: *mut f32,
5311     pub OutputPixelOffsets: *mut f32,
5312 }
5313 impl DML_RESAMPLE_GRAD_OPERATOR_DESC {}
5314 impl ::std::default::Default for DML_RESAMPLE_GRAD_OPERATOR_DESC {
default() -> Self5315     fn default() -> Self {
5316         unsafe { ::std::mem::zeroed() }
5317     }
5318 }
5319 impl ::std::fmt::Debug for DML_RESAMPLE_GRAD_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5320     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5321         fmt.debug_struct("DML_RESAMPLE_GRAD_OPERATOR_DESC")
5322             .field("InputGradientTensor", &self.InputGradientTensor)
5323             .field("OutputGradientTensor", &self.OutputGradientTensor)
5324             .field("InterpolationMode", &self.InterpolationMode)
5325             .field("DimensionCount", &self.DimensionCount)
5326             .field("Scales", &self.Scales)
5327             .field("InputPixelOffsets", &self.InputPixelOffsets)
5328             .field("OutputPixelOffsets", &self.OutputPixelOffsets)
5329             .finish()
5330     }
5331 }
5332 impl ::std::cmp::PartialEq for DML_RESAMPLE_GRAD_OPERATOR_DESC {
eq(&self, other: &Self) -> bool5333     fn eq(&self, other: &Self) -> bool {
5334         self.InputGradientTensor == other.InputGradientTensor && self.OutputGradientTensor == other.OutputGradientTensor && self.InterpolationMode == other.InterpolationMode && self.DimensionCount == other.DimensionCount && self.Scales == other.Scales && self.InputPixelOffsets == other.InputPixelOffsets && self.OutputPixelOffsets == other.OutputPixelOffsets
5335     }
5336 }
5337 impl ::std::cmp::Eq for DML_RESAMPLE_GRAD_OPERATOR_DESC {}
5338 unsafe impl ::windows::runtime::Abi for DML_RESAMPLE_GRAD_OPERATOR_DESC {
5339     type Abi = Self;
5340     type DefaultType = Self;
5341 }
5342 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5343 #[repr(C)]
5344 pub struct DML_RESAMPLE_OPERATOR_DESC {
5345     pub InputTensor: *mut DML_TENSOR_DESC,
5346     pub OutputTensor: *mut DML_TENSOR_DESC,
5347     pub InterpolationMode: DML_INTERPOLATION_MODE,
5348     pub ScaleCount: u32,
5349     pub Scales: *mut f32,
5350 }
5351 impl DML_RESAMPLE_OPERATOR_DESC {}
5352 impl ::std::default::Default for DML_RESAMPLE_OPERATOR_DESC {
default() -> Self5353     fn default() -> Self {
5354         unsafe { ::std::mem::zeroed() }
5355     }
5356 }
5357 impl ::std::fmt::Debug for DML_RESAMPLE_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5358     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5359         fmt.debug_struct("DML_RESAMPLE_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("InterpolationMode", &self.InterpolationMode).field("ScaleCount", &self.ScaleCount).field("Scales", &self.Scales).finish()
5360     }
5361 }
5362 impl ::std::cmp::PartialEq for DML_RESAMPLE_OPERATOR_DESC {
eq(&self, other: &Self) -> bool5363     fn eq(&self, other: &Self) -> bool {
5364         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.InterpolationMode == other.InterpolationMode && self.ScaleCount == other.ScaleCount && self.Scales == other.Scales
5365     }
5366 }
5367 impl ::std::cmp::Eq for DML_RESAMPLE_OPERATOR_DESC {}
5368 unsafe impl ::windows::runtime::Abi for DML_RESAMPLE_OPERATOR_DESC {
5369     type Abi = Self;
5370     type DefaultType = Self;
5371 }
5372 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5373 #[repr(C)]
5374 pub struct DML_REVERSE_SUBSEQUENCES_OPERATOR_DESC {
5375     pub InputTensor: *mut DML_TENSOR_DESC,
5376     pub SequenceLengthsTensor: *mut DML_TENSOR_DESC,
5377     pub OutputTensor: *mut DML_TENSOR_DESC,
5378     pub Axis: u32,
5379 }
5380 impl DML_REVERSE_SUBSEQUENCES_OPERATOR_DESC {}
5381 impl ::std::default::Default for DML_REVERSE_SUBSEQUENCES_OPERATOR_DESC {
default() -> Self5382     fn default() -> Self {
5383         unsafe { ::std::mem::zeroed() }
5384     }
5385 }
5386 impl ::std::fmt::Debug for DML_REVERSE_SUBSEQUENCES_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5387     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5388         fmt.debug_struct("DML_REVERSE_SUBSEQUENCES_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("SequenceLengthsTensor", &self.SequenceLengthsTensor).field("OutputTensor", &self.OutputTensor).field("Axis", &self.Axis).finish()
5389     }
5390 }
5391 impl ::std::cmp::PartialEq for DML_REVERSE_SUBSEQUENCES_OPERATOR_DESC {
eq(&self, other: &Self) -> bool5392     fn eq(&self, other: &Self) -> bool {
5393         self.InputTensor == other.InputTensor && self.SequenceLengthsTensor == other.SequenceLengthsTensor && self.OutputTensor == other.OutputTensor && self.Axis == other.Axis
5394     }
5395 }
5396 impl ::std::cmp::Eq for DML_REVERSE_SUBSEQUENCES_OPERATOR_DESC {}
5397 unsafe impl ::windows::runtime::Abi for DML_REVERSE_SUBSEQUENCES_OPERATOR_DESC {
5398     type Abi = Self;
5399     type DefaultType = Self;
5400 }
5401 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5402 #[repr(C)]
5403 pub struct DML_RNN_OPERATOR_DESC {
5404     pub InputTensor: *mut DML_TENSOR_DESC,
5405     pub WeightTensor: *mut DML_TENSOR_DESC,
5406     pub RecurrenceTensor: *mut DML_TENSOR_DESC,
5407     pub BiasTensor: *mut DML_TENSOR_DESC,
5408     pub HiddenInitTensor: *mut DML_TENSOR_DESC,
5409     pub SequenceLengthsTensor: *mut DML_TENSOR_DESC,
5410     pub OutputSequenceTensor: *mut DML_TENSOR_DESC,
5411     pub OutputSingleTensor: *mut DML_TENSOR_DESC,
5412     pub ActivationDescCount: u32,
5413     pub ActivationDescs: *mut DML_OPERATOR_DESC,
5414     pub Direction: DML_RECURRENT_NETWORK_DIRECTION,
5415 }
5416 impl DML_RNN_OPERATOR_DESC {}
5417 impl ::std::default::Default for DML_RNN_OPERATOR_DESC {
default() -> Self5418     fn default() -> Self {
5419         unsafe { ::std::mem::zeroed() }
5420     }
5421 }
5422 impl ::std::fmt::Debug for DML_RNN_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5423     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5424         fmt.debug_struct("DML_RNN_OPERATOR_DESC")
5425             .field("InputTensor", &self.InputTensor)
5426             .field("WeightTensor", &self.WeightTensor)
5427             .field("RecurrenceTensor", &self.RecurrenceTensor)
5428             .field("BiasTensor", &self.BiasTensor)
5429             .field("HiddenInitTensor", &self.HiddenInitTensor)
5430             .field("SequenceLengthsTensor", &self.SequenceLengthsTensor)
5431             .field("OutputSequenceTensor", &self.OutputSequenceTensor)
5432             .field("OutputSingleTensor", &self.OutputSingleTensor)
5433             .field("ActivationDescCount", &self.ActivationDescCount)
5434             .field("ActivationDescs", &self.ActivationDescs)
5435             .field("Direction", &self.Direction)
5436             .finish()
5437     }
5438 }
5439 impl ::std::cmp::PartialEq for DML_RNN_OPERATOR_DESC {
eq(&self, other: &Self) -> bool5440     fn eq(&self, other: &Self) -> bool {
5441         self.InputTensor == other.InputTensor
5442             && self.WeightTensor == other.WeightTensor
5443             && self.RecurrenceTensor == other.RecurrenceTensor
5444             && self.BiasTensor == other.BiasTensor
5445             && self.HiddenInitTensor == other.HiddenInitTensor
5446             && self.SequenceLengthsTensor == other.SequenceLengthsTensor
5447             && self.OutputSequenceTensor == other.OutputSequenceTensor
5448             && self.OutputSingleTensor == other.OutputSingleTensor
5449             && self.ActivationDescCount == other.ActivationDescCount
5450             && self.ActivationDescs == other.ActivationDescs
5451             && self.Direction == other.Direction
5452     }
5453 }
5454 impl ::std::cmp::Eq for DML_RNN_OPERATOR_DESC {}
5455 unsafe impl ::windows::runtime::Abi for DML_RNN_OPERATOR_DESC {
5456     type Abi = Self;
5457     type DefaultType = Self;
5458 }
5459 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5460 #[repr(C)]
5461 #[cfg(feature = "Win32_Foundation")]
5462 pub struct DML_ROI_ALIGN1_OPERATOR_DESC {
5463     pub InputTensor: *mut DML_TENSOR_DESC,
5464     pub ROITensor: *mut DML_TENSOR_DESC,
5465     pub BatchIndicesTensor: *mut DML_TENSOR_DESC,
5466     pub OutputTensor: *mut DML_TENSOR_DESC,
5467     pub ReductionFunction: DML_REDUCE_FUNCTION,
5468     pub InterpolationMode: DML_INTERPOLATION_MODE,
5469     pub SpatialScaleX: f32,
5470     pub SpatialScaleY: f32,
5471     pub InputPixelOffset: f32,
5472     pub OutputPixelOffset: f32,
5473     pub OutOfBoundsInputValue: f32,
5474     pub MinimumSamplesPerOutput: u32,
5475     pub MaximumSamplesPerOutput: u32,
5476     pub AlignRegionsToCorners: super::super::super::Foundation::BOOL,
5477 }
5478 #[cfg(feature = "Win32_Foundation")]
5479 impl DML_ROI_ALIGN1_OPERATOR_DESC {}
5480 #[cfg(feature = "Win32_Foundation")]
5481 impl ::std::default::Default for DML_ROI_ALIGN1_OPERATOR_DESC {
default() -> Self5482     fn default() -> Self {
5483         unsafe { ::std::mem::zeroed() }
5484     }
5485 }
5486 #[cfg(feature = "Win32_Foundation")]
5487 impl ::std::fmt::Debug for DML_ROI_ALIGN1_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5488     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5489         fmt.debug_struct("DML_ROI_ALIGN1_OPERATOR_DESC")
5490             .field("InputTensor", &self.InputTensor)
5491             .field("ROITensor", &self.ROITensor)
5492             .field("BatchIndicesTensor", &self.BatchIndicesTensor)
5493             .field("OutputTensor", &self.OutputTensor)
5494             .field("ReductionFunction", &self.ReductionFunction)
5495             .field("InterpolationMode", &self.InterpolationMode)
5496             .field("SpatialScaleX", &self.SpatialScaleX)
5497             .field("SpatialScaleY", &self.SpatialScaleY)
5498             .field("InputPixelOffset", &self.InputPixelOffset)
5499             .field("OutputPixelOffset", &self.OutputPixelOffset)
5500             .field("OutOfBoundsInputValue", &self.OutOfBoundsInputValue)
5501             .field("MinimumSamplesPerOutput", &self.MinimumSamplesPerOutput)
5502             .field("MaximumSamplesPerOutput", &self.MaximumSamplesPerOutput)
5503             .field("AlignRegionsToCorners", &self.AlignRegionsToCorners)
5504             .finish()
5505     }
5506 }
5507 #[cfg(feature = "Win32_Foundation")]
5508 impl ::std::cmp::PartialEq for DML_ROI_ALIGN1_OPERATOR_DESC {
eq(&self, other: &Self) -> bool5509     fn eq(&self, other: &Self) -> bool {
5510         self.InputTensor == other.InputTensor
5511             && self.ROITensor == other.ROITensor
5512             && self.BatchIndicesTensor == other.BatchIndicesTensor
5513             && self.OutputTensor == other.OutputTensor
5514             && self.ReductionFunction == other.ReductionFunction
5515             && self.InterpolationMode == other.InterpolationMode
5516             && self.SpatialScaleX == other.SpatialScaleX
5517             && self.SpatialScaleY == other.SpatialScaleY
5518             && self.InputPixelOffset == other.InputPixelOffset
5519             && self.OutputPixelOffset == other.OutputPixelOffset
5520             && self.OutOfBoundsInputValue == other.OutOfBoundsInputValue
5521             && self.MinimumSamplesPerOutput == other.MinimumSamplesPerOutput
5522             && self.MaximumSamplesPerOutput == other.MaximumSamplesPerOutput
5523             && self.AlignRegionsToCorners == other.AlignRegionsToCorners
5524     }
5525 }
5526 #[cfg(feature = "Win32_Foundation")]
5527 impl ::std::cmp::Eq for DML_ROI_ALIGN1_OPERATOR_DESC {}
5528 #[cfg(feature = "Win32_Foundation")]
5529 unsafe impl ::windows::runtime::Abi for DML_ROI_ALIGN1_OPERATOR_DESC {
5530     type Abi = Self;
5531     type DefaultType = Self;
5532 }
5533 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5534 #[repr(C)]
5535 pub struct DML_ROI_ALIGN_OPERATOR_DESC {
5536     pub InputTensor: *mut DML_TENSOR_DESC,
5537     pub ROITensor: *mut DML_TENSOR_DESC,
5538     pub BatchIndicesTensor: *mut DML_TENSOR_DESC,
5539     pub OutputTensor: *mut DML_TENSOR_DESC,
5540     pub ReductionFunction: DML_REDUCE_FUNCTION,
5541     pub InterpolationMode: DML_INTERPOLATION_MODE,
5542     pub SpatialScaleX: f32,
5543     pub SpatialScaleY: f32,
5544     pub OutOfBoundsInputValue: f32,
5545     pub MinimumSamplesPerOutput: u32,
5546     pub MaximumSamplesPerOutput: u32,
5547 }
5548 impl DML_ROI_ALIGN_OPERATOR_DESC {}
5549 impl ::std::default::Default for DML_ROI_ALIGN_OPERATOR_DESC {
default() -> Self5550     fn default() -> Self {
5551         unsafe { ::std::mem::zeroed() }
5552     }
5553 }
5554 impl ::std::fmt::Debug for DML_ROI_ALIGN_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5555     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5556         fmt.debug_struct("DML_ROI_ALIGN_OPERATOR_DESC")
5557             .field("InputTensor", &self.InputTensor)
5558             .field("ROITensor", &self.ROITensor)
5559             .field("BatchIndicesTensor", &self.BatchIndicesTensor)
5560             .field("OutputTensor", &self.OutputTensor)
5561             .field("ReductionFunction", &self.ReductionFunction)
5562             .field("InterpolationMode", &self.InterpolationMode)
5563             .field("SpatialScaleX", &self.SpatialScaleX)
5564             .field("SpatialScaleY", &self.SpatialScaleY)
5565             .field("OutOfBoundsInputValue", &self.OutOfBoundsInputValue)
5566             .field("MinimumSamplesPerOutput", &self.MinimumSamplesPerOutput)
5567             .field("MaximumSamplesPerOutput", &self.MaximumSamplesPerOutput)
5568             .finish()
5569     }
5570 }
5571 impl ::std::cmp::PartialEq for DML_ROI_ALIGN_OPERATOR_DESC {
eq(&self, other: &Self) -> bool5572     fn eq(&self, other: &Self) -> bool {
5573         self.InputTensor == other.InputTensor
5574             && self.ROITensor == other.ROITensor
5575             && self.BatchIndicesTensor == other.BatchIndicesTensor
5576             && self.OutputTensor == other.OutputTensor
5577             && self.ReductionFunction == other.ReductionFunction
5578             && self.InterpolationMode == other.InterpolationMode
5579             && self.SpatialScaleX == other.SpatialScaleX
5580             && self.SpatialScaleY == other.SpatialScaleY
5581             && self.OutOfBoundsInputValue == other.OutOfBoundsInputValue
5582             && self.MinimumSamplesPerOutput == other.MinimumSamplesPerOutput
5583             && self.MaximumSamplesPerOutput == other.MaximumSamplesPerOutput
5584     }
5585 }
5586 impl ::std::cmp::Eq for DML_ROI_ALIGN_OPERATOR_DESC {}
5587 unsafe impl ::windows::runtime::Abi for DML_ROI_ALIGN_OPERATOR_DESC {
5588     type Abi = Self;
5589     type DefaultType = Self;
5590 }
5591 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5592 #[repr(C)]
5593 pub struct DML_ROI_POOLING_OPERATOR_DESC {
5594     pub InputTensor: *mut DML_TENSOR_DESC,
5595     pub ROITensor: *mut DML_TENSOR_DESC,
5596     pub OutputTensor: *mut DML_TENSOR_DESC,
5597     pub SpatialScale: f32,
5598     pub PooledSize: DML_SIZE_2D,
5599 }
5600 impl DML_ROI_POOLING_OPERATOR_DESC {}
5601 impl ::std::default::Default for DML_ROI_POOLING_OPERATOR_DESC {
default() -> Self5602     fn default() -> Self {
5603         unsafe { ::std::mem::zeroed() }
5604     }
5605 }
5606 impl ::std::fmt::Debug for DML_ROI_POOLING_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5607     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5608         fmt.debug_struct("DML_ROI_POOLING_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("ROITensor", &self.ROITensor).field("OutputTensor", &self.OutputTensor).field("SpatialScale", &self.SpatialScale).field("PooledSize", &self.PooledSize).finish()
5609     }
5610 }
5611 impl ::std::cmp::PartialEq for DML_ROI_POOLING_OPERATOR_DESC {
eq(&self, other: &Self) -> bool5612     fn eq(&self, other: &Self) -> bool {
5613         self.InputTensor == other.InputTensor && self.ROITensor == other.ROITensor && self.OutputTensor == other.OutputTensor && self.SpatialScale == other.SpatialScale && self.PooledSize == other.PooledSize
5614     }
5615 }
5616 impl ::std::cmp::Eq for DML_ROI_POOLING_OPERATOR_DESC {}
5617 unsafe impl ::windows::runtime::Abi for DML_ROI_POOLING_OPERATOR_DESC {
5618     type Abi = Self;
5619     type DefaultType = Self;
5620 }
5621 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5622 #[repr(transparent)]
5623 pub struct DML_ROUNDING_MODE(pub i32);
5624 pub const DML_ROUNDING_MODE_HALVES_TO_NEAREST_EVEN: DML_ROUNDING_MODE = DML_ROUNDING_MODE(0i32);
5625 pub const DML_ROUNDING_MODE_TOWARD_ZERO: DML_ROUNDING_MODE = DML_ROUNDING_MODE(1i32);
5626 pub const DML_ROUNDING_MODE_TOWARD_INFINITY: DML_ROUNDING_MODE = DML_ROUNDING_MODE(2i32);
5627 impl ::std::convert::From<i32> for DML_ROUNDING_MODE {
from(value: i32) -> Self5628     fn from(value: i32) -> Self {
5629         Self(value)
5630     }
5631 }
5632 unsafe impl ::windows::runtime::Abi for DML_ROUNDING_MODE {
5633     type Abi = Self;
5634     type DefaultType = Self;
5635 }
5636 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5637 #[repr(C)]
5638 pub union DML_SCALAR_UNION {
5639     pub Bytes: [u8; 8],
5640     pub Int8: i8,
5641     pub UInt8: u8,
5642     pub Int16: i16,
5643     pub UInt16: u16,
5644     pub Int32: i32,
5645     pub UInt32: u32,
5646     pub Int64: i64,
5647     pub UInt64: u64,
5648     pub Float32: f32,
5649     pub Float64: f64,
5650 }
5651 impl DML_SCALAR_UNION {}
5652 impl ::std::default::Default for DML_SCALAR_UNION {
default() -> Self5653     fn default() -> Self {
5654         unsafe { ::std::mem::zeroed() }
5655     }
5656 }
5657 impl ::std::cmp::PartialEq for DML_SCALAR_UNION {
eq(&self, _other: &Self) -> bool5658     fn eq(&self, _other: &Self) -> bool {
5659         unimplemented!()
5660     }
5661 }
5662 impl ::std::cmp::Eq for DML_SCALAR_UNION {}
5663 unsafe impl ::windows::runtime::Abi for DML_SCALAR_UNION {
5664     type Abi = Self;
5665     type DefaultType = Self;
5666 }
5667 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5668 #[repr(C)]
5669 pub struct DML_SCALE_BIAS {
5670     pub Scale: f32,
5671     pub Bias: f32,
5672 }
5673 impl DML_SCALE_BIAS {}
5674 impl ::std::default::Default for DML_SCALE_BIAS {
default() -> Self5675     fn default() -> Self {
5676         unsafe { ::std::mem::zeroed() }
5677     }
5678 }
5679 impl ::std::fmt::Debug for DML_SCALE_BIAS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5680     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5681         fmt.debug_struct("DML_SCALE_BIAS").field("Scale", &self.Scale).field("Bias", &self.Bias).finish()
5682     }
5683 }
5684 impl ::std::cmp::PartialEq for DML_SCALE_BIAS {
eq(&self, other: &Self) -> bool5685     fn eq(&self, other: &Self) -> bool {
5686         self.Scale == other.Scale && self.Bias == other.Bias
5687     }
5688 }
5689 impl ::std::cmp::Eq for DML_SCALE_BIAS {}
5690 unsafe impl ::windows::runtime::Abi for DML_SCALE_BIAS {
5691     type Abi = Self;
5692     type DefaultType = Self;
5693 }
5694 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5695 #[repr(C)]
5696 pub struct DML_SCATTER_ND_OPERATOR_DESC {
5697     pub InputTensor: *mut DML_TENSOR_DESC,
5698     pub IndicesTensor: *mut DML_TENSOR_DESC,
5699     pub UpdatesTensor: *mut DML_TENSOR_DESC,
5700     pub OutputTensor: *mut DML_TENSOR_DESC,
5701     pub InputDimensionCount: u32,
5702     pub IndicesDimensionCount: u32,
5703 }
5704 impl DML_SCATTER_ND_OPERATOR_DESC {}
5705 impl ::std::default::Default for DML_SCATTER_ND_OPERATOR_DESC {
default() -> Self5706     fn default() -> Self {
5707         unsafe { ::std::mem::zeroed() }
5708     }
5709 }
5710 impl ::std::fmt::Debug for DML_SCATTER_ND_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5711     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5712         fmt.debug_struct("DML_SCATTER_ND_OPERATOR_DESC")
5713             .field("InputTensor", &self.InputTensor)
5714             .field("IndicesTensor", &self.IndicesTensor)
5715             .field("UpdatesTensor", &self.UpdatesTensor)
5716             .field("OutputTensor", &self.OutputTensor)
5717             .field("InputDimensionCount", &self.InputDimensionCount)
5718             .field("IndicesDimensionCount", &self.IndicesDimensionCount)
5719             .finish()
5720     }
5721 }
5722 impl ::std::cmp::PartialEq for DML_SCATTER_ND_OPERATOR_DESC {
eq(&self, other: &Self) -> bool5723     fn eq(&self, other: &Self) -> bool {
5724         self.InputTensor == other.InputTensor && self.IndicesTensor == other.IndicesTensor && self.UpdatesTensor == other.UpdatesTensor && self.OutputTensor == other.OutputTensor && self.InputDimensionCount == other.InputDimensionCount && self.IndicesDimensionCount == other.IndicesDimensionCount
5725     }
5726 }
5727 impl ::std::cmp::Eq for DML_SCATTER_ND_OPERATOR_DESC {}
5728 unsafe impl ::windows::runtime::Abi for DML_SCATTER_ND_OPERATOR_DESC {
5729     type Abi = Self;
5730     type DefaultType = Self;
5731 }
5732 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5733 #[repr(C)]
5734 pub struct DML_SCATTER_OPERATOR_DESC {
5735     pub InputTensor: *mut DML_TENSOR_DESC,
5736     pub IndicesTensor: *mut DML_TENSOR_DESC,
5737     pub UpdatesTensor: *mut DML_TENSOR_DESC,
5738     pub OutputTensor: *mut DML_TENSOR_DESC,
5739     pub Axis: u32,
5740 }
5741 impl DML_SCATTER_OPERATOR_DESC {}
5742 impl ::std::default::Default for DML_SCATTER_OPERATOR_DESC {
default() -> Self5743     fn default() -> Self {
5744         unsafe { ::std::mem::zeroed() }
5745     }
5746 }
5747 impl ::std::fmt::Debug for DML_SCATTER_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5748     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5749         fmt.debug_struct("DML_SCATTER_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("IndicesTensor", &self.IndicesTensor).field("UpdatesTensor", &self.UpdatesTensor).field("OutputTensor", &self.OutputTensor).field("Axis", &self.Axis).finish()
5750     }
5751 }
5752 impl ::std::cmp::PartialEq for DML_SCATTER_OPERATOR_DESC {
eq(&self, other: &Self) -> bool5753     fn eq(&self, other: &Self) -> bool {
5754         self.InputTensor == other.InputTensor && self.IndicesTensor == other.IndicesTensor && self.UpdatesTensor == other.UpdatesTensor && self.OutputTensor == other.OutputTensor && self.Axis == other.Axis
5755     }
5756 }
5757 impl ::std::cmp::Eq for DML_SCATTER_OPERATOR_DESC {}
5758 unsafe impl ::windows::runtime::Abi for DML_SCATTER_OPERATOR_DESC {
5759     type Abi = Self;
5760     type DefaultType = Self;
5761 }
5762 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5763 #[repr(C)]
5764 pub struct DML_SIZE_2D {
5765     pub Width: u32,
5766     pub Height: u32,
5767 }
5768 impl DML_SIZE_2D {}
5769 impl ::std::default::Default for DML_SIZE_2D {
default() -> Self5770     fn default() -> Self {
5771         unsafe { ::std::mem::zeroed() }
5772     }
5773 }
5774 impl ::std::fmt::Debug for DML_SIZE_2D {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5775     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5776         fmt.debug_struct("DML_SIZE_2D").field("Width", &self.Width).field("Height", &self.Height).finish()
5777     }
5778 }
5779 impl ::std::cmp::PartialEq for DML_SIZE_2D {
eq(&self, other: &Self) -> bool5780     fn eq(&self, other: &Self) -> bool {
5781         self.Width == other.Width && self.Height == other.Height
5782     }
5783 }
5784 impl ::std::cmp::Eq for DML_SIZE_2D {}
5785 unsafe impl ::windows::runtime::Abi for DML_SIZE_2D {
5786     type Abi = Self;
5787     type DefaultType = Self;
5788 }
5789 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5790 #[repr(C)]
5791 pub struct DML_SLICE1_OPERATOR_DESC {
5792     pub InputTensor: *mut DML_TENSOR_DESC,
5793     pub OutputTensor: *mut DML_TENSOR_DESC,
5794     pub DimensionCount: u32,
5795     pub InputWindowOffsets: *mut u32,
5796     pub InputWindowSizes: *mut u32,
5797     pub InputWindowStrides: *mut i32,
5798 }
5799 impl DML_SLICE1_OPERATOR_DESC {}
5800 impl ::std::default::Default for DML_SLICE1_OPERATOR_DESC {
default() -> Self5801     fn default() -> Self {
5802         unsafe { ::std::mem::zeroed() }
5803     }
5804 }
5805 impl ::std::fmt::Debug for DML_SLICE1_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5806     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5807         fmt.debug_struct("DML_SLICE1_OPERATOR_DESC")
5808             .field("InputTensor", &self.InputTensor)
5809             .field("OutputTensor", &self.OutputTensor)
5810             .field("DimensionCount", &self.DimensionCount)
5811             .field("InputWindowOffsets", &self.InputWindowOffsets)
5812             .field("InputWindowSizes", &self.InputWindowSizes)
5813             .field("InputWindowStrides", &self.InputWindowStrides)
5814             .finish()
5815     }
5816 }
5817 impl ::std::cmp::PartialEq for DML_SLICE1_OPERATOR_DESC {
eq(&self, other: &Self) -> bool5818     fn eq(&self, other: &Self) -> bool {
5819         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.DimensionCount == other.DimensionCount && self.InputWindowOffsets == other.InputWindowOffsets && self.InputWindowSizes == other.InputWindowSizes && self.InputWindowStrides == other.InputWindowStrides
5820     }
5821 }
5822 impl ::std::cmp::Eq for DML_SLICE1_OPERATOR_DESC {}
5823 unsafe impl ::windows::runtime::Abi for DML_SLICE1_OPERATOR_DESC {
5824     type Abi = Self;
5825     type DefaultType = Self;
5826 }
5827 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5828 #[repr(C)]
5829 pub struct DML_SLICE_GRAD_OPERATOR_DESC {
5830     pub InputGradientTensor: *mut DML_TENSOR_DESC,
5831     pub OutputGradientTensor: *mut DML_TENSOR_DESC,
5832     pub DimensionCount: u32,
5833     pub InputWindowOffsets: *mut u32,
5834     pub InputWindowSizes: *mut u32,
5835     pub InputWindowStrides: *mut i32,
5836 }
5837 impl DML_SLICE_GRAD_OPERATOR_DESC {}
5838 impl ::std::default::Default for DML_SLICE_GRAD_OPERATOR_DESC {
default() -> Self5839     fn default() -> Self {
5840         unsafe { ::std::mem::zeroed() }
5841     }
5842 }
5843 impl ::std::fmt::Debug for DML_SLICE_GRAD_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5844     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5845         fmt.debug_struct("DML_SLICE_GRAD_OPERATOR_DESC")
5846             .field("InputGradientTensor", &self.InputGradientTensor)
5847             .field("OutputGradientTensor", &self.OutputGradientTensor)
5848             .field("DimensionCount", &self.DimensionCount)
5849             .field("InputWindowOffsets", &self.InputWindowOffsets)
5850             .field("InputWindowSizes", &self.InputWindowSizes)
5851             .field("InputWindowStrides", &self.InputWindowStrides)
5852             .finish()
5853     }
5854 }
5855 impl ::std::cmp::PartialEq for DML_SLICE_GRAD_OPERATOR_DESC {
eq(&self, other: &Self) -> bool5856     fn eq(&self, other: &Self) -> bool {
5857         self.InputGradientTensor == other.InputGradientTensor && self.OutputGradientTensor == other.OutputGradientTensor && self.DimensionCount == other.DimensionCount && self.InputWindowOffsets == other.InputWindowOffsets && self.InputWindowSizes == other.InputWindowSizes && self.InputWindowStrides == other.InputWindowStrides
5858     }
5859 }
5860 impl ::std::cmp::Eq for DML_SLICE_GRAD_OPERATOR_DESC {}
5861 unsafe impl ::windows::runtime::Abi for DML_SLICE_GRAD_OPERATOR_DESC {
5862     type Abi = Self;
5863     type DefaultType = Self;
5864 }
5865 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5866 #[repr(C)]
5867 pub struct DML_SLICE_OPERATOR_DESC {
5868     pub InputTensor: *mut DML_TENSOR_DESC,
5869     pub OutputTensor: *mut DML_TENSOR_DESC,
5870     pub DimensionCount: u32,
5871     pub Offsets: *mut u32,
5872     pub Sizes: *mut u32,
5873     pub Strides: *mut u32,
5874 }
5875 impl DML_SLICE_OPERATOR_DESC {}
5876 impl ::std::default::Default for DML_SLICE_OPERATOR_DESC {
default() -> Self5877     fn default() -> Self {
5878         unsafe { ::std::mem::zeroed() }
5879     }
5880 }
5881 impl ::std::fmt::Debug for DML_SLICE_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5882     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5883         fmt.debug_struct("DML_SLICE_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("DimensionCount", &self.DimensionCount).field("Offsets", &self.Offsets).field("Sizes", &self.Sizes).field("Strides", &self.Strides).finish()
5884     }
5885 }
5886 impl ::std::cmp::PartialEq for DML_SLICE_OPERATOR_DESC {
eq(&self, other: &Self) -> bool5887     fn eq(&self, other: &Self) -> bool {
5888         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.DimensionCount == other.DimensionCount && self.Offsets == other.Offsets && self.Sizes == other.Sizes && self.Strides == other.Strides
5889     }
5890 }
5891 impl ::std::cmp::Eq for DML_SLICE_OPERATOR_DESC {}
5892 unsafe impl ::windows::runtime::Abi for DML_SLICE_OPERATOR_DESC {
5893     type Abi = Self;
5894     type DefaultType = Self;
5895 }
5896 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5897 #[repr(C)]
5898 pub struct DML_SPACE_TO_DEPTH1_OPERATOR_DESC {
5899     pub InputTensor: *mut DML_TENSOR_DESC,
5900     pub OutputTensor: *mut DML_TENSOR_DESC,
5901     pub BlockSize: u32,
5902     pub Order: DML_DEPTH_SPACE_ORDER,
5903 }
5904 impl DML_SPACE_TO_DEPTH1_OPERATOR_DESC {}
5905 impl ::std::default::Default for DML_SPACE_TO_DEPTH1_OPERATOR_DESC {
default() -> Self5906     fn default() -> Self {
5907         unsafe { ::std::mem::zeroed() }
5908     }
5909 }
5910 impl ::std::fmt::Debug for DML_SPACE_TO_DEPTH1_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5911     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5912         fmt.debug_struct("DML_SPACE_TO_DEPTH1_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("BlockSize", &self.BlockSize).field("Order", &self.Order).finish()
5913     }
5914 }
5915 impl ::std::cmp::PartialEq for DML_SPACE_TO_DEPTH1_OPERATOR_DESC {
eq(&self, other: &Self) -> bool5916     fn eq(&self, other: &Self) -> bool {
5917         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.BlockSize == other.BlockSize && self.Order == other.Order
5918     }
5919 }
5920 impl ::std::cmp::Eq for DML_SPACE_TO_DEPTH1_OPERATOR_DESC {}
5921 unsafe impl ::windows::runtime::Abi for DML_SPACE_TO_DEPTH1_OPERATOR_DESC {
5922     type Abi = Self;
5923     type DefaultType = Self;
5924 }
5925 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5926 #[repr(C)]
5927 pub struct DML_SPACE_TO_DEPTH_OPERATOR_DESC {
5928     pub InputTensor: *mut DML_TENSOR_DESC,
5929     pub OutputTensor: *mut DML_TENSOR_DESC,
5930     pub BlockSize: u32,
5931 }
5932 impl DML_SPACE_TO_DEPTH_OPERATOR_DESC {}
5933 impl ::std::default::Default for DML_SPACE_TO_DEPTH_OPERATOR_DESC {
default() -> Self5934     fn default() -> Self {
5935         unsafe { ::std::mem::zeroed() }
5936     }
5937 }
5938 impl ::std::fmt::Debug for DML_SPACE_TO_DEPTH_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5939     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5940         fmt.debug_struct("DML_SPACE_TO_DEPTH_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("BlockSize", &self.BlockSize).finish()
5941     }
5942 }
5943 impl ::std::cmp::PartialEq for DML_SPACE_TO_DEPTH_OPERATOR_DESC {
eq(&self, other: &Self) -> bool5944     fn eq(&self, other: &Self) -> bool {
5945         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.BlockSize == other.BlockSize
5946     }
5947 }
5948 impl ::std::cmp::Eq for DML_SPACE_TO_DEPTH_OPERATOR_DESC {}
5949 unsafe impl ::windows::runtime::Abi for DML_SPACE_TO_DEPTH_OPERATOR_DESC {
5950     type Abi = Self;
5951     type DefaultType = Self;
5952 }
5953 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5954 #[repr(C)]
5955 pub struct DML_SPLIT_OPERATOR_DESC {
5956     pub InputTensor: *mut DML_TENSOR_DESC,
5957     pub OutputCount: u32,
5958     pub OutputTensors: *mut DML_TENSOR_DESC,
5959     pub Axis: u32,
5960 }
5961 impl DML_SPLIT_OPERATOR_DESC {}
5962 impl ::std::default::Default for DML_SPLIT_OPERATOR_DESC {
default() -> Self5963     fn default() -> Self {
5964         unsafe { ::std::mem::zeroed() }
5965     }
5966 }
5967 impl ::std::fmt::Debug for DML_SPLIT_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5968     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5969         fmt.debug_struct("DML_SPLIT_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputCount", &self.OutputCount).field("OutputTensors", &self.OutputTensors).field("Axis", &self.Axis).finish()
5970     }
5971 }
5972 impl ::std::cmp::PartialEq for DML_SPLIT_OPERATOR_DESC {
eq(&self, other: &Self) -> bool5973     fn eq(&self, other: &Self) -> bool {
5974         self.InputTensor == other.InputTensor && self.OutputCount == other.OutputCount && self.OutputTensors == other.OutputTensors && self.Axis == other.Axis
5975     }
5976 }
5977 impl ::std::cmp::Eq for DML_SPLIT_OPERATOR_DESC {}
5978 unsafe impl ::windows::runtime::Abi for DML_SPLIT_OPERATOR_DESC {
5979     type Abi = Self;
5980     type DefaultType = Self;
5981 }
5982 pub const DML_TARGET_VERSION: u32 = 16384u32;
5983 pub const DML_TEMPORARY_BUFFER_ALIGNMENT: u32 = 256u32;
5984 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5985 #[repr(transparent)]
5986 pub struct DML_TENSOR_DATA_TYPE(pub i32);
5987 pub const DML_TENSOR_DATA_TYPE_UNKNOWN: DML_TENSOR_DATA_TYPE = DML_TENSOR_DATA_TYPE(0i32);
5988 pub const DML_TENSOR_DATA_TYPE_FLOAT32: DML_TENSOR_DATA_TYPE = DML_TENSOR_DATA_TYPE(1i32);
5989 pub const DML_TENSOR_DATA_TYPE_FLOAT16: DML_TENSOR_DATA_TYPE = DML_TENSOR_DATA_TYPE(2i32);
5990 pub const DML_TENSOR_DATA_TYPE_UINT32: DML_TENSOR_DATA_TYPE = DML_TENSOR_DATA_TYPE(3i32);
5991 pub const DML_TENSOR_DATA_TYPE_UINT16: DML_TENSOR_DATA_TYPE = DML_TENSOR_DATA_TYPE(4i32);
5992 pub const DML_TENSOR_DATA_TYPE_UINT8: DML_TENSOR_DATA_TYPE = DML_TENSOR_DATA_TYPE(5i32);
5993 pub const DML_TENSOR_DATA_TYPE_INT32: DML_TENSOR_DATA_TYPE = DML_TENSOR_DATA_TYPE(6i32);
5994 pub const DML_TENSOR_DATA_TYPE_INT16: DML_TENSOR_DATA_TYPE = DML_TENSOR_DATA_TYPE(7i32);
5995 pub const DML_TENSOR_DATA_TYPE_INT8: DML_TENSOR_DATA_TYPE = DML_TENSOR_DATA_TYPE(8i32);
5996 pub const DML_TENSOR_DATA_TYPE_FLOAT64: DML_TENSOR_DATA_TYPE = DML_TENSOR_DATA_TYPE(9i32);
5997 pub const DML_TENSOR_DATA_TYPE_UINT64: DML_TENSOR_DATA_TYPE = DML_TENSOR_DATA_TYPE(10i32);
5998 pub const DML_TENSOR_DATA_TYPE_INT64: DML_TENSOR_DATA_TYPE = DML_TENSOR_DATA_TYPE(11i32);
5999 impl ::std::convert::From<i32> for DML_TENSOR_DATA_TYPE {
from(value: i32) -> Self6000     fn from(value: i32) -> Self {
6001         Self(value)
6002     }
6003 }
6004 unsafe impl ::windows::runtime::Abi for DML_TENSOR_DATA_TYPE {
6005     type Abi = Self;
6006     type DefaultType = Self;
6007 }
6008 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6009 #[repr(C)]
6010 pub struct DML_TENSOR_DESC {
6011     pub Type: DML_TENSOR_TYPE,
6012     pub Desc: *mut ::std::ffi::c_void,
6013 }
6014 impl DML_TENSOR_DESC {}
6015 impl ::std::default::Default for DML_TENSOR_DESC {
default() -> Self6016     fn default() -> Self {
6017         unsafe { ::std::mem::zeroed() }
6018     }
6019 }
6020 impl ::std::fmt::Debug for DML_TENSOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6021     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6022         fmt.debug_struct("DML_TENSOR_DESC").field("Type", &self.Type).field("Desc", &self.Desc).finish()
6023     }
6024 }
6025 impl ::std::cmp::PartialEq for DML_TENSOR_DESC {
eq(&self, other: &Self) -> bool6026     fn eq(&self, other: &Self) -> bool {
6027         self.Type == other.Type && self.Desc == other.Desc
6028     }
6029 }
6030 impl ::std::cmp::Eq for DML_TENSOR_DESC {}
6031 unsafe impl ::windows::runtime::Abi for DML_TENSOR_DESC {
6032     type Abi = Self;
6033     type DefaultType = Self;
6034 }
6035 pub const DML_TENSOR_DIMENSION_COUNT_MAX: u32 = 5u32;
6036 pub const DML_TENSOR_DIMENSION_COUNT_MAX1: u32 = 8u32;
6037 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6038 #[repr(transparent)]
6039 pub struct DML_TENSOR_FLAGS(pub u32);
6040 pub const DML_TENSOR_FLAG_NONE: DML_TENSOR_FLAGS = DML_TENSOR_FLAGS(0u32);
6041 pub const DML_TENSOR_FLAG_OWNED_BY_DML: DML_TENSOR_FLAGS = DML_TENSOR_FLAGS(1u32);
6042 impl ::std::convert::From<u32> for DML_TENSOR_FLAGS {
from(value: u32) -> Self6043     fn from(value: u32) -> Self {
6044         Self(value)
6045     }
6046 }
6047 unsafe impl ::windows::runtime::Abi for DML_TENSOR_FLAGS {
6048     type Abi = Self;
6049     type DefaultType = Self;
6050 }
6051 impl ::std::ops::BitOr for DML_TENSOR_FLAGS {
6052     type Output = Self;
bitor(self, rhs: Self) -> Self6053     fn bitor(self, rhs: Self) -> Self {
6054         Self(self.0 | rhs.0)
6055     }
6056 }
6057 impl ::std::ops::BitAnd for DML_TENSOR_FLAGS {
6058     type Output = Self;
bitand(self, rhs: Self) -> Self6059     fn bitand(self, rhs: Self) -> Self {
6060         Self(self.0 & rhs.0)
6061     }
6062 }
6063 impl ::std::ops::BitOrAssign for DML_TENSOR_FLAGS {
bitor_assign(&mut self, rhs: Self)6064     fn bitor_assign(&mut self, rhs: Self) {
6065         self.0.bitor_assign(rhs.0)
6066     }
6067 }
6068 impl ::std::ops::BitAndAssign for DML_TENSOR_FLAGS {
bitand_assign(&mut self, rhs: Self)6069     fn bitand_assign(&mut self, rhs: Self) {
6070         self.0.bitand_assign(rhs.0)
6071     }
6072 }
6073 impl ::std::ops::Not for DML_TENSOR_FLAGS {
6074     type Output = Self;
not(self) -> Self6075     fn not(self) -> Self {
6076         Self(self.0.not())
6077     }
6078 }
6079 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6080 #[repr(transparent)]
6081 pub struct DML_TENSOR_TYPE(pub i32);
6082 pub const DML_TENSOR_TYPE_INVALID: DML_TENSOR_TYPE = DML_TENSOR_TYPE(0i32);
6083 pub const DML_TENSOR_TYPE_BUFFER: DML_TENSOR_TYPE = DML_TENSOR_TYPE(1i32);
6084 impl ::std::convert::From<i32> for DML_TENSOR_TYPE {
from(value: i32) -> Self6085     fn from(value: i32) -> Self {
6086         Self(value)
6087     }
6088 }
6089 unsafe impl ::windows::runtime::Abi for DML_TENSOR_TYPE {
6090     type Abi = Self;
6091     type DefaultType = Self;
6092 }
6093 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6094 #[repr(C)]
6095 pub struct DML_TILE_OPERATOR_DESC {
6096     pub InputTensor: *mut DML_TENSOR_DESC,
6097     pub OutputTensor: *mut DML_TENSOR_DESC,
6098     pub RepeatsCount: u32,
6099     pub Repeats: *mut u32,
6100 }
6101 impl DML_TILE_OPERATOR_DESC {}
6102 impl ::std::default::Default for DML_TILE_OPERATOR_DESC {
default() -> Self6103     fn default() -> Self {
6104         unsafe { ::std::mem::zeroed() }
6105     }
6106 }
6107 impl ::std::fmt::Debug for DML_TILE_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6108     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6109         fmt.debug_struct("DML_TILE_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("RepeatsCount", &self.RepeatsCount).field("Repeats", &self.Repeats).finish()
6110     }
6111 }
6112 impl ::std::cmp::PartialEq for DML_TILE_OPERATOR_DESC {
eq(&self, other: &Self) -> bool6113     fn eq(&self, other: &Self) -> bool {
6114         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.RepeatsCount == other.RepeatsCount && self.Repeats == other.Repeats
6115     }
6116 }
6117 impl ::std::cmp::Eq for DML_TILE_OPERATOR_DESC {}
6118 unsafe impl ::windows::runtime::Abi for DML_TILE_OPERATOR_DESC {
6119     type Abi = Self;
6120     type DefaultType = Self;
6121 }
6122 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6123 #[repr(C)]
6124 pub struct DML_TOP_K1_OPERATOR_DESC {
6125     pub InputTensor: *mut DML_TENSOR_DESC,
6126     pub OutputValueTensor: *mut DML_TENSOR_DESC,
6127     pub OutputIndexTensor: *mut DML_TENSOR_DESC,
6128     pub Axis: u32,
6129     pub K: u32,
6130     pub AxisDirection: DML_AXIS_DIRECTION,
6131 }
6132 impl DML_TOP_K1_OPERATOR_DESC {}
6133 impl ::std::default::Default for DML_TOP_K1_OPERATOR_DESC {
default() -> Self6134     fn default() -> Self {
6135         unsafe { ::std::mem::zeroed() }
6136     }
6137 }
6138 impl ::std::fmt::Debug for DML_TOP_K1_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6139     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6140         fmt.debug_struct("DML_TOP_K1_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputValueTensor", &self.OutputValueTensor).field("OutputIndexTensor", &self.OutputIndexTensor).field("Axis", &self.Axis).field("K", &self.K).field("AxisDirection", &self.AxisDirection).finish()
6141     }
6142 }
6143 impl ::std::cmp::PartialEq for DML_TOP_K1_OPERATOR_DESC {
eq(&self, other: &Self) -> bool6144     fn eq(&self, other: &Self) -> bool {
6145         self.InputTensor == other.InputTensor && self.OutputValueTensor == other.OutputValueTensor && self.OutputIndexTensor == other.OutputIndexTensor && self.Axis == other.Axis && self.K == other.K && self.AxisDirection == other.AxisDirection
6146     }
6147 }
6148 impl ::std::cmp::Eq for DML_TOP_K1_OPERATOR_DESC {}
6149 unsafe impl ::windows::runtime::Abi for DML_TOP_K1_OPERATOR_DESC {
6150     type Abi = Self;
6151     type DefaultType = Self;
6152 }
6153 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6154 #[repr(C)]
6155 pub struct DML_TOP_K_OPERATOR_DESC {
6156     pub InputTensor: *mut DML_TENSOR_DESC,
6157     pub OutputValueTensor: *mut DML_TENSOR_DESC,
6158     pub OutputIndexTensor: *mut DML_TENSOR_DESC,
6159     pub Axis: u32,
6160     pub K: u32,
6161 }
6162 impl DML_TOP_K_OPERATOR_DESC {}
6163 impl ::std::default::Default for DML_TOP_K_OPERATOR_DESC {
default() -> Self6164     fn default() -> Self {
6165         unsafe { ::std::mem::zeroed() }
6166     }
6167 }
6168 impl ::std::fmt::Debug for DML_TOP_K_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6169     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6170         fmt.debug_struct("DML_TOP_K_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputValueTensor", &self.OutputValueTensor).field("OutputIndexTensor", &self.OutputIndexTensor).field("Axis", &self.Axis).field("K", &self.K).finish()
6171     }
6172 }
6173 impl ::std::cmp::PartialEq for DML_TOP_K_OPERATOR_DESC {
eq(&self, other: &Self) -> bool6174     fn eq(&self, other: &Self) -> bool {
6175         self.InputTensor == other.InputTensor && self.OutputValueTensor == other.OutputValueTensor && self.OutputIndexTensor == other.OutputIndexTensor && self.Axis == other.Axis && self.K == other.K
6176     }
6177 }
6178 impl ::std::cmp::Eq for DML_TOP_K_OPERATOR_DESC {}
6179 unsafe impl ::windows::runtime::Abi for DML_TOP_K_OPERATOR_DESC {
6180     type Abi = Self;
6181     type DefaultType = Self;
6182 }
6183 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6184 #[repr(C)]
6185 pub struct DML_UPSAMPLE_2D_OPERATOR_DESC {
6186     pub InputTensor: *mut DML_TENSOR_DESC,
6187     pub OutputTensor: *mut DML_TENSOR_DESC,
6188     pub ScaleSize: DML_SIZE_2D,
6189     pub InterpolationMode: DML_INTERPOLATION_MODE,
6190 }
6191 impl DML_UPSAMPLE_2D_OPERATOR_DESC {}
6192 impl ::std::default::Default for DML_UPSAMPLE_2D_OPERATOR_DESC {
default() -> Self6193     fn default() -> Self {
6194         unsafe { ::std::mem::zeroed() }
6195     }
6196 }
6197 impl ::std::fmt::Debug for DML_UPSAMPLE_2D_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6198     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6199         fmt.debug_struct("DML_UPSAMPLE_2D_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("ScaleSize", &self.ScaleSize).field("InterpolationMode", &self.InterpolationMode).finish()
6200     }
6201 }
6202 impl ::std::cmp::PartialEq for DML_UPSAMPLE_2D_OPERATOR_DESC {
eq(&self, other: &Self) -> bool6203     fn eq(&self, other: &Self) -> bool {
6204         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.ScaleSize == other.ScaleSize && self.InterpolationMode == other.InterpolationMode
6205     }
6206 }
6207 impl ::std::cmp::Eq for DML_UPSAMPLE_2D_OPERATOR_DESC {}
6208 unsafe impl ::windows::runtime::Abi for DML_UPSAMPLE_2D_OPERATOR_DESC {
6209     type Abi = Self;
6210     type DefaultType = Self;
6211 }
6212 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6213 #[repr(C)]
6214 pub struct DML_VALUE_SCALE_2D_OPERATOR_DESC {
6215     pub InputTensor: *mut DML_TENSOR_DESC,
6216     pub OutputTensor: *mut DML_TENSOR_DESC,
6217     pub Scale: f32,
6218     pub ChannelCount: u32,
6219     pub Bias: *mut f32,
6220 }
6221 impl DML_VALUE_SCALE_2D_OPERATOR_DESC {}
6222 impl ::std::default::Default for DML_VALUE_SCALE_2D_OPERATOR_DESC {
default() -> Self6223     fn default() -> Self {
6224         unsafe { ::std::mem::zeroed() }
6225     }
6226 }
6227 impl ::std::fmt::Debug for DML_VALUE_SCALE_2D_OPERATOR_DESC {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6228     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6229         fmt.debug_struct("DML_VALUE_SCALE_2D_OPERATOR_DESC").field("InputTensor", &self.InputTensor).field("OutputTensor", &self.OutputTensor).field("Scale", &self.Scale).field("ChannelCount", &self.ChannelCount).field("Bias", &self.Bias).finish()
6230     }
6231 }
6232 impl ::std::cmp::PartialEq for DML_VALUE_SCALE_2D_OPERATOR_DESC {
eq(&self, other: &Self) -> bool6233     fn eq(&self, other: &Self) -> bool {
6234         self.InputTensor == other.InputTensor && self.OutputTensor == other.OutputTensor && self.Scale == other.Scale && self.ChannelCount == other.ChannelCount && self.Bias == other.Bias
6235     }
6236 }
6237 impl ::std::cmp::Eq for DML_VALUE_SCALE_2D_OPERATOR_DESC {}
6238 unsafe impl ::windows::runtime::Abi for DML_VALUE_SCALE_2D_OPERATOR_DESC {
6239     type Abi = Self;
6240     type DefaultType = Self;
6241 }
6242 #[repr(transparent)]
6243 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
6244 pub struct IDMLBindingTable(::windows::runtime::IUnknown);
6245 impl IDMLBindingTable {
GetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>6246     pub unsafe fn GetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6247         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), ::std::mem::transmute(datasize), ::std::mem::transmute(data)).ok()
6248     }
SetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()>6249     pub unsafe fn SetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6250         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), ::std::mem::transmute(datasize), ::std::mem::transmute(data)).ok()
6251     }
SetPrivateDataInterface<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, guid: *const ::windows::runtime::GUID, data: Param1) -> ::windows::runtime::Result<()>6252     pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, guid: *const ::windows::runtime::GUID, data: Param1) -> ::windows::runtime::Result<()> {
6253         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), data.into_param().abi()).ok()
6254     }
6255     #[cfg(feature = "Win32_Foundation")]
SetName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::runtime::Result<()>6256     pub unsafe fn SetName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::runtime::Result<()> {
6257         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), name.into_param().abi()).ok()
6258     }
GetDevice<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T>6259     pub unsafe fn GetDevice<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T> {
6260         let mut result__ = ::std::option::Option::None;
6261         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), &<T as ::windows::runtime::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
6262     }
BindInputs(&self, bindingcount: u32, bindings: *const DML_BINDING_DESC)6263     pub unsafe fn BindInputs(&self, bindingcount: u32, bindings: *const DML_BINDING_DESC) {
6264         ::std::mem::transmute((::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(bindingcount), ::std::mem::transmute(bindings)))
6265     }
BindOutputs(&self, bindingcount: u32, bindings: *const DML_BINDING_DESC)6266     pub unsafe fn BindOutputs(&self, bindingcount: u32, bindings: *const DML_BINDING_DESC) {
6267         ::std::mem::transmute((::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), ::std::mem::transmute(bindingcount), ::std::mem::transmute(bindings)))
6268     }
BindTemporaryResource(&self, binding: *const DML_BINDING_DESC)6269     pub unsafe fn BindTemporaryResource(&self, binding: *const DML_BINDING_DESC) {
6270         ::std::mem::transmute((::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), ::std::mem::transmute(binding)))
6271     }
BindPersistentResource(&self, binding: *const DML_BINDING_DESC)6272     pub unsafe fn BindPersistentResource(&self, binding: *const DML_BINDING_DESC) {
6273         ::std::mem::transmute((::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), ::std::mem::transmute(binding)))
6274     }
6275     #[cfg(feature = "Win32_Graphics_Direct3D12")]
Reset(&self, desc: *const DML_BINDING_TABLE_DESC) -> ::windows::runtime::Result<()>6276     pub unsafe fn Reset(&self, desc: *const DML_BINDING_TABLE_DESC) -> ::windows::runtime::Result<()> {
6277         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), ::std::mem::transmute(desc)).ok()
6278     }
6279 }
6280 unsafe impl ::windows::runtime::Interface for IDMLBindingTable {
6281     type Vtable = IDMLBindingTable_abi;
6282     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(700876764, 56948, 20027, [171, 0, 17, 104, 242, 252, 60, 252]);
6283 }
6284 impl ::std::convert::From<IDMLBindingTable> for ::windows::runtime::IUnknown {
from(value: IDMLBindingTable) -> Self6285     fn from(value: IDMLBindingTable) -> Self {
6286         unsafe { ::std::mem::transmute(value) }
6287     }
6288 }
6289 impl ::std::convert::From<&IDMLBindingTable> for ::windows::runtime::IUnknown {
from(value: &IDMLBindingTable) -> Self6290     fn from(value: &IDMLBindingTable) -> Self {
6291         ::std::convert::From::from(::std::clone::Clone::clone(value))
6292     }
6293 }
6294 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IDMLBindingTable {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>6295     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
6296         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
6297     }
6298 }
6299 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IDMLBindingTable {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>6300     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
6301         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
6302     }
6303 }
6304 impl ::std::convert::From<IDMLBindingTable> for IDMLDeviceChild {
from(value: IDMLBindingTable) -> Self6305     fn from(value: IDMLBindingTable) -> Self {
6306         unsafe { ::std::mem::transmute(value) }
6307     }
6308 }
6309 impl ::std::convert::From<&IDMLBindingTable> for IDMLDeviceChild {
from(value: &IDMLBindingTable) -> Self6310     fn from(value: &IDMLBindingTable) -> Self {
6311         ::std::convert::From::from(::std::clone::Clone::clone(value))
6312     }
6313 }
6314 impl<'a> ::windows::runtime::IntoParam<'a, IDMLDeviceChild> for IDMLBindingTable {
into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild>6315     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild> {
6316         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLDeviceChild>::into(self))
6317     }
6318 }
6319 impl<'a> ::windows::runtime::IntoParam<'a, IDMLDeviceChild> for &IDMLBindingTable {
into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild>6320     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild> {
6321         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLDeviceChild>::into(::std::clone::Clone::clone(self)))
6322     }
6323 }
6324 impl ::std::convert::From<IDMLBindingTable> for IDMLObject {
from(value: IDMLBindingTable) -> Self6325     fn from(value: IDMLBindingTable) -> Self {
6326         unsafe { ::std::mem::transmute(value) }
6327     }
6328 }
6329 impl ::std::convert::From<&IDMLBindingTable> for IDMLObject {
from(value: &IDMLBindingTable) -> Self6330     fn from(value: &IDMLBindingTable) -> Self {
6331         ::std::convert::From::from(::std::clone::Clone::clone(value))
6332     }
6333 }
6334 impl<'a> ::windows::runtime::IntoParam<'a, IDMLObject> for IDMLBindingTable {
into_param(self) -> ::windows::runtime::Param<'a, IDMLObject>6335     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLObject> {
6336         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLObject>::into(self))
6337     }
6338 }
6339 impl<'a> ::windows::runtime::IntoParam<'a, IDMLObject> for &IDMLBindingTable {
into_param(self) -> ::windows::runtime::Param<'a, IDMLObject>6340     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLObject> {
6341         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLObject>::into(::std::clone::Clone::clone(self)))
6342     }
6343 }
6344 #[repr(C)]
6345 #[doc(hidden)]
6346 pub struct IDMLBindingTable_abi(
6347     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
6348     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
6349     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
6350     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6351     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6352     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, data: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
6353     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, name: super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
6354     #[cfg(not(feature = "Win32_Foundation"))] usize,
6355     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6356     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bindingcount: u32, bindings: *const DML_BINDING_DESC),
6357     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, bindingcount: u32, bindings: *const DML_BINDING_DESC),
6358     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, binding: *const DML_BINDING_DESC),
6359     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, binding: *const DML_BINDING_DESC),
6360     #[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, desc: *const ::std::mem::ManuallyDrop<DML_BINDING_TABLE_DESC>) -> ::windows::runtime::HRESULT,
6361     #[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
6362 );
6363 #[repr(transparent)]
6364 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
6365 pub struct IDMLCommandRecorder(::windows::runtime::IUnknown);
6366 impl IDMLCommandRecorder {
GetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>6367     pub unsafe fn GetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6368         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), ::std::mem::transmute(datasize), ::std::mem::transmute(data)).ok()
6369     }
SetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()>6370     pub unsafe fn SetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6371         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), ::std::mem::transmute(datasize), ::std::mem::transmute(data)).ok()
6372     }
SetPrivateDataInterface<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, guid: *const ::windows::runtime::GUID, data: Param1) -> ::windows::runtime::Result<()>6373     pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, guid: *const ::windows::runtime::GUID, data: Param1) -> ::windows::runtime::Result<()> {
6374         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), data.into_param().abi()).ok()
6375     }
6376     #[cfg(feature = "Win32_Foundation")]
SetName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::runtime::Result<()>6377     pub unsafe fn SetName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::runtime::Result<()> {
6378         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), name.into_param().abi()).ok()
6379     }
GetDevice<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T>6380     pub unsafe fn GetDevice<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T> {
6381         let mut result__ = ::std::option::Option::None;
6382         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), &<T as ::windows::runtime::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
6383     }
6384     #[cfg(feature = "Win32_Graphics_Direct3D12")]
RecordDispatch<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Graphics::Direct3D12::ID3D12CommandList>, Param1: ::windows::runtime::IntoParam<'a, IDMLDispatchable>, Param2: ::windows::runtime::IntoParam<'a, IDMLBindingTable>>(&self, commandlist: Param0, dispatchable: Param1, bindings: Param2)6385     pub unsafe fn RecordDispatch<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Graphics::Direct3D12::ID3D12CommandList>, Param1: ::windows::runtime::IntoParam<'a, IDMLDispatchable>, Param2: ::windows::runtime::IntoParam<'a, IDMLBindingTable>>(&self, commandlist: Param0, dispatchable: Param1, bindings: Param2) {
6386         ::std::mem::transmute((::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), commandlist.into_param().abi(), dispatchable.into_param().abi(), bindings.into_param().abi()))
6387     }
6388 }
6389 unsafe impl ::windows::runtime::Interface for IDMLCommandRecorder {
6390     type Vtable = IDMLCommandRecorder_abi;
6391     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3867507318, 11838, 20445, [191, 244, 93, 43, 161, 15, 180, 83]);
6392 }
6393 impl ::std::convert::From<IDMLCommandRecorder> for ::windows::runtime::IUnknown {
from(value: IDMLCommandRecorder) -> Self6394     fn from(value: IDMLCommandRecorder) -> Self {
6395         unsafe { ::std::mem::transmute(value) }
6396     }
6397 }
6398 impl ::std::convert::From<&IDMLCommandRecorder> for ::windows::runtime::IUnknown {
from(value: &IDMLCommandRecorder) -> Self6399     fn from(value: &IDMLCommandRecorder) -> Self {
6400         ::std::convert::From::from(::std::clone::Clone::clone(value))
6401     }
6402 }
6403 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IDMLCommandRecorder {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>6404     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
6405         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
6406     }
6407 }
6408 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IDMLCommandRecorder {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>6409     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
6410         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
6411     }
6412 }
6413 impl ::std::convert::From<IDMLCommandRecorder> for IDMLDeviceChild {
from(value: IDMLCommandRecorder) -> Self6414     fn from(value: IDMLCommandRecorder) -> Self {
6415         unsafe { ::std::mem::transmute(value) }
6416     }
6417 }
6418 impl ::std::convert::From<&IDMLCommandRecorder> for IDMLDeviceChild {
from(value: &IDMLCommandRecorder) -> Self6419     fn from(value: &IDMLCommandRecorder) -> Self {
6420         ::std::convert::From::from(::std::clone::Clone::clone(value))
6421     }
6422 }
6423 impl<'a> ::windows::runtime::IntoParam<'a, IDMLDeviceChild> for IDMLCommandRecorder {
into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild>6424     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild> {
6425         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLDeviceChild>::into(self))
6426     }
6427 }
6428 impl<'a> ::windows::runtime::IntoParam<'a, IDMLDeviceChild> for &IDMLCommandRecorder {
into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild>6429     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild> {
6430         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLDeviceChild>::into(::std::clone::Clone::clone(self)))
6431     }
6432 }
6433 impl ::std::convert::From<IDMLCommandRecorder> for IDMLObject {
from(value: IDMLCommandRecorder) -> Self6434     fn from(value: IDMLCommandRecorder) -> Self {
6435         unsafe { ::std::mem::transmute(value) }
6436     }
6437 }
6438 impl ::std::convert::From<&IDMLCommandRecorder> for IDMLObject {
from(value: &IDMLCommandRecorder) -> Self6439     fn from(value: &IDMLCommandRecorder) -> Self {
6440         ::std::convert::From::from(::std::clone::Clone::clone(value))
6441     }
6442 }
6443 impl<'a> ::windows::runtime::IntoParam<'a, IDMLObject> for IDMLCommandRecorder {
into_param(self) -> ::windows::runtime::Param<'a, IDMLObject>6444     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLObject> {
6445         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLObject>::into(self))
6446     }
6447 }
6448 impl<'a> ::windows::runtime::IntoParam<'a, IDMLObject> for &IDMLCommandRecorder {
into_param(self) -> ::windows::runtime::Param<'a, IDMLObject>6449     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLObject> {
6450         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLObject>::into(::std::clone::Clone::clone(self)))
6451     }
6452 }
6453 #[repr(C)]
6454 #[doc(hidden)]
6455 pub struct IDMLCommandRecorder_abi(
6456     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
6457     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
6458     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
6459     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6460     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6461     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, data: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
6462     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, name: super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
6463     #[cfg(not(feature = "Win32_Foundation"))] usize,
6464     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6465     #[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, commandlist: ::windows::runtime::RawPtr, dispatchable: ::windows::runtime::RawPtr, bindings: ::windows::runtime::RawPtr),
6466     #[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
6467 );
6468 #[repr(transparent)]
6469 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
6470 pub struct IDMLCompiledOperator(::windows::runtime::IUnknown);
6471 impl IDMLCompiledOperator {
GetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>6472     pub unsafe fn GetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6473         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), ::std::mem::transmute(datasize), ::std::mem::transmute(data)).ok()
6474     }
SetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()>6475     pub unsafe fn SetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6476         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), ::std::mem::transmute(datasize), ::std::mem::transmute(data)).ok()
6477     }
SetPrivateDataInterface<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, guid: *const ::windows::runtime::GUID, data: Param1) -> ::windows::runtime::Result<()>6478     pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, guid: *const ::windows::runtime::GUID, data: Param1) -> ::windows::runtime::Result<()> {
6479         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), data.into_param().abi()).ok()
6480     }
6481     #[cfg(feature = "Win32_Foundation")]
SetName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::runtime::Result<()>6482     pub unsafe fn SetName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::runtime::Result<()> {
6483         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), name.into_param().abi()).ok()
6484     }
GetDevice<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T>6485     pub unsafe fn GetDevice<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T> {
6486         let mut result__ = ::std::option::Option::None;
6487         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), &<T as ::windows::runtime::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
6488     }
GetBindingProperties(&self) -> DML_BINDING_PROPERTIES6489     pub unsafe fn GetBindingProperties(&self) -> DML_BINDING_PROPERTIES {
6490         let mut result__: DML_BINDING_PROPERTIES = ::std::default::Default::default();
6491         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), &mut result__);
6492         result__
6493     }
6494 }
6495 unsafe impl ::windows::runtime::Interface for IDMLCompiledOperator {
6496     type Vtable = IDMLCompiledOperator_abi;
6497     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1796597098, 48988, 18690, [146, 216, 218, 58, 101, 10, 254, 164]);
6498 }
6499 impl ::std::convert::From<IDMLCompiledOperator> for ::windows::runtime::IUnknown {
from(value: IDMLCompiledOperator) -> Self6500     fn from(value: IDMLCompiledOperator) -> Self {
6501         unsafe { ::std::mem::transmute(value) }
6502     }
6503 }
6504 impl ::std::convert::From<&IDMLCompiledOperator> for ::windows::runtime::IUnknown {
from(value: &IDMLCompiledOperator) -> Self6505     fn from(value: &IDMLCompiledOperator) -> Self {
6506         ::std::convert::From::from(::std::clone::Clone::clone(value))
6507     }
6508 }
6509 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IDMLCompiledOperator {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>6510     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
6511         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
6512     }
6513 }
6514 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IDMLCompiledOperator {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>6515     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
6516         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
6517     }
6518 }
6519 impl ::std::convert::From<IDMLCompiledOperator> for IDMLDispatchable {
from(value: IDMLCompiledOperator) -> Self6520     fn from(value: IDMLCompiledOperator) -> Self {
6521         unsafe { ::std::mem::transmute(value) }
6522     }
6523 }
6524 impl ::std::convert::From<&IDMLCompiledOperator> for IDMLDispatchable {
from(value: &IDMLCompiledOperator) -> Self6525     fn from(value: &IDMLCompiledOperator) -> Self {
6526         ::std::convert::From::from(::std::clone::Clone::clone(value))
6527     }
6528 }
6529 impl<'a> ::windows::runtime::IntoParam<'a, IDMLDispatchable> for IDMLCompiledOperator {
into_param(self) -> ::windows::runtime::Param<'a, IDMLDispatchable>6530     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLDispatchable> {
6531         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLDispatchable>::into(self))
6532     }
6533 }
6534 impl<'a> ::windows::runtime::IntoParam<'a, IDMLDispatchable> for &IDMLCompiledOperator {
into_param(self) -> ::windows::runtime::Param<'a, IDMLDispatchable>6535     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLDispatchable> {
6536         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLDispatchable>::into(::std::clone::Clone::clone(self)))
6537     }
6538 }
6539 impl ::std::convert::From<IDMLCompiledOperator> for IDMLPageable {
from(value: IDMLCompiledOperator) -> Self6540     fn from(value: IDMLCompiledOperator) -> Self {
6541         unsafe { ::std::mem::transmute(value) }
6542     }
6543 }
6544 impl ::std::convert::From<&IDMLCompiledOperator> for IDMLPageable {
from(value: &IDMLCompiledOperator) -> Self6545     fn from(value: &IDMLCompiledOperator) -> Self {
6546         ::std::convert::From::from(::std::clone::Clone::clone(value))
6547     }
6548 }
6549 impl<'a> ::windows::runtime::IntoParam<'a, IDMLPageable> for IDMLCompiledOperator {
into_param(self) -> ::windows::runtime::Param<'a, IDMLPageable>6550     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLPageable> {
6551         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLPageable>::into(self))
6552     }
6553 }
6554 impl<'a> ::windows::runtime::IntoParam<'a, IDMLPageable> for &IDMLCompiledOperator {
into_param(self) -> ::windows::runtime::Param<'a, IDMLPageable>6555     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLPageable> {
6556         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLPageable>::into(::std::clone::Clone::clone(self)))
6557     }
6558 }
6559 impl ::std::convert::From<IDMLCompiledOperator> for IDMLDeviceChild {
from(value: IDMLCompiledOperator) -> Self6560     fn from(value: IDMLCompiledOperator) -> Self {
6561         unsafe { ::std::mem::transmute(value) }
6562     }
6563 }
6564 impl ::std::convert::From<&IDMLCompiledOperator> for IDMLDeviceChild {
from(value: &IDMLCompiledOperator) -> Self6565     fn from(value: &IDMLCompiledOperator) -> Self {
6566         ::std::convert::From::from(::std::clone::Clone::clone(value))
6567     }
6568 }
6569 impl<'a> ::windows::runtime::IntoParam<'a, IDMLDeviceChild> for IDMLCompiledOperator {
into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild>6570     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild> {
6571         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLDeviceChild>::into(self))
6572     }
6573 }
6574 impl<'a> ::windows::runtime::IntoParam<'a, IDMLDeviceChild> for &IDMLCompiledOperator {
into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild>6575     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild> {
6576         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLDeviceChild>::into(::std::clone::Clone::clone(self)))
6577     }
6578 }
6579 impl ::std::convert::From<IDMLCompiledOperator> for IDMLObject {
from(value: IDMLCompiledOperator) -> Self6580     fn from(value: IDMLCompiledOperator) -> Self {
6581         unsafe { ::std::mem::transmute(value) }
6582     }
6583 }
6584 impl ::std::convert::From<&IDMLCompiledOperator> for IDMLObject {
from(value: &IDMLCompiledOperator) -> Self6585     fn from(value: &IDMLCompiledOperator) -> Self {
6586         ::std::convert::From::from(::std::clone::Clone::clone(value))
6587     }
6588 }
6589 impl<'a> ::windows::runtime::IntoParam<'a, IDMLObject> for IDMLCompiledOperator {
into_param(self) -> ::windows::runtime::Param<'a, IDMLObject>6590     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLObject> {
6591         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLObject>::into(self))
6592     }
6593 }
6594 impl<'a> ::windows::runtime::IntoParam<'a, IDMLObject> for &IDMLCompiledOperator {
into_param(self) -> ::windows::runtime::Param<'a, IDMLObject>6595     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLObject> {
6596         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLObject>::into(::std::clone::Clone::clone(self)))
6597     }
6598 }
6599 #[repr(C)]
6600 #[doc(hidden)]
6601 pub struct IDMLCompiledOperator_abi(
6602     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
6603     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
6604     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
6605     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6606     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6607     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, data: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
6608     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, name: super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
6609     #[cfg(not(feature = "Win32_Foundation"))] usize,
6610     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6611     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, result__: *mut DML_BINDING_PROPERTIES),
6612 );
6613 #[repr(transparent)]
6614 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
6615 pub struct IDMLDebugDevice(::windows::runtime::IUnknown);
6616 impl IDMLDebugDevice {
6617     #[cfg(feature = "Win32_Foundation")]
SetMuteDebugOutput<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, mute: Param0)6618     pub unsafe fn SetMuteDebugOutput<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, mute: Param0) {
6619         ::std::mem::transmute((::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), mute.into_param().abi()))
6620     }
6621 }
6622 unsafe impl ::windows::runtime::Interface for IDMLDebugDevice {
6623     type Vtable = IDMLDebugDevice_abi;
6624     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(2104441545, 14666, 19139, [146, 167, 57, 12, 197, 122, 130, 23]);
6625 }
6626 impl ::std::convert::From<IDMLDebugDevice> for ::windows::runtime::IUnknown {
from(value: IDMLDebugDevice) -> Self6627     fn from(value: IDMLDebugDevice) -> Self {
6628         unsafe { ::std::mem::transmute(value) }
6629     }
6630 }
6631 impl ::std::convert::From<&IDMLDebugDevice> for ::windows::runtime::IUnknown {
from(value: &IDMLDebugDevice) -> Self6632     fn from(value: &IDMLDebugDevice) -> Self {
6633         ::std::convert::From::from(::std::clone::Clone::clone(value))
6634     }
6635 }
6636 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IDMLDebugDevice {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>6637     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
6638         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
6639     }
6640 }
6641 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IDMLDebugDevice {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>6642     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
6643         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
6644     }
6645 }
6646 #[repr(C)]
6647 #[doc(hidden)]
6648 pub struct IDMLDebugDevice_abi(
6649     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
6650     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
6651     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
6652     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, mute: super::super::super::Foundation::BOOL),
6653     #[cfg(not(feature = "Win32_Foundation"))] usize,
6654 );
6655 #[repr(transparent)]
6656 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
6657 pub struct IDMLDevice(::windows::runtime::IUnknown);
6658 impl IDMLDevice {
GetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>6659     pub unsafe fn GetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6660         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), ::std::mem::transmute(datasize), ::std::mem::transmute(data)).ok()
6661     }
SetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()>6662     pub unsafe fn SetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6663         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), ::std::mem::transmute(datasize), ::std::mem::transmute(data)).ok()
6664     }
SetPrivateDataInterface<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, guid: *const ::windows::runtime::GUID, data: Param1) -> ::windows::runtime::Result<()>6665     pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, guid: *const ::windows::runtime::GUID, data: Param1) -> ::windows::runtime::Result<()> {
6666         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), data.into_param().abi()).ok()
6667     }
6668     #[cfg(feature = "Win32_Foundation")]
SetName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::runtime::Result<()>6669     pub unsafe fn SetName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::runtime::Result<()> {
6670         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), name.into_param().abi()).ok()
6671     }
CheckFeatureSupport(&self, feature: DML_FEATURE, featurequerydatasize: u32, featurequerydata: *const ::std::ffi::c_void, featuresupportdatasize: u32, featuresupportdata: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>6672     pub unsafe fn CheckFeatureSupport(&self, feature: DML_FEATURE, featurequerydatasize: u32, featurequerydata: *const ::std::ffi::c_void, featuresupportdatasize: u32, featuresupportdata: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6673         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(feature), ::std::mem::transmute(featurequerydatasize), ::std::mem::transmute(featurequerydata), ::std::mem::transmute(featuresupportdatasize), ::std::mem::transmute(featuresupportdata)).ok()
6674     }
CreateOperator<T: ::windows::runtime::Interface>(&self, desc: *const DML_OPERATOR_DESC, result__: *mut ::std::option::Option<T>) -> ::windows::runtime::Result<()>6675     pub unsafe fn CreateOperator<T: ::windows::runtime::Interface>(&self, desc: *const DML_OPERATOR_DESC, result__: *mut ::std::option::Option<T>) -> ::windows::runtime::Result<()> {
6676         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(desc), &<T as ::windows::runtime::Interface>::IID, result__ as *mut _ as *mut _).ok()
6677     }
CompileOperator<'a, Param0: ::windows::runtime::IntoParam<'a, IDMLOperator>, T: ::windows::runtime::Interface>(&self, op: Param0, flags: DML_EXECUTION_FLAGS, result__: *mut ::std::option::Option<T>) -> ::windows::runtime::Result<()>6678     pub unsafe fn CompileOperator<'a, Param0: ::windows::runtime::IntoParam<'a, IDMLOperator>, T: ::windows::runtime::Interface>(&self, op: Param0, flags: DML_EXECUTION_FLAGS, result__: *mut ::std::option::Option<T>) -> ::windows::runtime::Result<()> {
6679         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), op.into_param().abi(), ::std::mem::transmute(flags), &<T as ::windows::runtime::Interface>::IID, result__ as *mut _ as *mut _).ok()
6680     }
CreateOperatorInitializer<T: ::windows::runtime::Interface>(&self, operatorcount: u32, operators: *const ::std::option::Option<IDMLCompiledOperator>) -> ::windows::runtime::Result<T>6681     pub unsafe fn CreateOperatorInitializer<T: ::windows::runtime::Interface>(&self, operatorcount: u32, operators: *const ::std::option::Option<IDMLCompiledOperator>) -> ::windows::runtime::Result<T> {
6682         let mut result__ = ::std::option::Option::None;
6683         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), ::std::mem::transmute(operatorcount), ::std::mem::transmute(operators), &<T as ::windows::runtime::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
6684     }
CreateCommandRecorder<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T>6685     pub unsafe fn CreateCommandRecorder<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T> {
6686         let mut result__ = ::std::option::Option::None;
6687         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), &<T as ::windows::runtime::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
6688     }
6689     #[cfg(feature = "Win32_Graphics_Direct3D12")]
CreateBindingTable<T: ::windows::runtime::Interface>(&self, desc: *const DML_BINDING_TABLE_DESC) -> ::windows::runtime::Result<T>6690     pub unsafe fn CreateBindingTable<T: ::windows::runtime::Interface>(&self, desc: *const DML_BINDING_TABLE_DESC) -> ::windows::runtime::Result<T> {
6691         let mut result__ = ::std::option::Option::None;
6692         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), ::std::mem::transmute(desc), &<T as ::windows::runtime::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
6693     }
Evict(&self, count: u32, ppobjects: *const ::std::option::Option<IDMLPageable>) -> ::windows::runtime::Result<()>6694     pub unsafe fn Evict(&self, count: u32, ppobjects: *const ::std::option::Option<IDMLPageable>) -> ::windows::runtime::Result<()> {
6695         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), ::std::mem::transmute(count), ::std::mem::transmute(ppobjects)).ok()
6696     }
MakeResident(&self, count: u32, ppobjects: *const ::std::option::Option<IDMLPageable>) -> ::windows::runtime::Result<()>6697     pub unsafe fn MakeResident(&self, count: u32, ppobjects: *const ::std::option::Option<IDMLPageable>) -> ::windows::runtime::Result<()> {
6698         (::windows::runtime::Interface::vtable(self).14)(::std::mem::transmute_copy(self), ::std::mem::transmute(count), ::std::mem::transmute(ppobjects)).ok()
6699     }
GetDeviceRemovedReason(&self) -> ::windows::runtime::Result<()>6700     pub unsafe fn GetDeviceRemovedReason(&self) -> ::windows::runtime::Result<()> {
6701         (::windows::runtime::Interface::vtable(self).15)(::std::mem::transmute_copy(self)).ok()
6702     }
GetParentDevice<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T>6703     pub unsafe fn GetParentDevice<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T> {
6704         let mut result__ = ::std::option::Option::None;
6705         (::windows::runtime::Interface::vtable(self).16)(::std::mem::transmute_copy(self), &<T as ::windows::runtime::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
6706     }
6707 }
6708 unsafe impl ::windows::runtime::Interface for IDMLDevice {
6709     type Vtable = IDMLDevice_abi;
6710     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1841128503, 38653, 16959, [169, 140, 174, 94, 124, 42, 87, 63]);
6711 }
6712 impl ::std::convert::From<IDMLDevice> for ::windows::runtime::IUnknown {
from(value: IDMLDevice) -> Self6713     fn from(value: IDMLDevice) -> Self {
6714         unsafe { ::std::mem::transmute(value) }
6715     }
6716 }
6717 impl ::std::convert::From<&IDMLDevice> for ::windows::runtime::IUnknown {
from(value: &IDMLDevice) -> Self6718     fn from(value: &IDMLDevice) -> Self {
6719         ::std::convert::From::from(::std::clone::Clone::clone(value))
6720     }
6721 }
6722 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IDMLDevice {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>6723     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
6724         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
6725     }
6726 }
6727 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IDMLDevice {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>6728     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
6729         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
6730     }
6731 }
6732 impl ::std::convert::From<IDMLDevice> for IDMLObject {
from(value: IDMLDevice) -> Self6733     fn from(value: IDMLDevice) -> Self {
6734         unsafe { ::std::mem::transmute(value) }
6735     }
6736 }
6737 impl ::std::convert::From<&IDMLDevice> for IDMLObject {
from(value: &IDMLDevice) -> Self6738     fn from(value: &IDMLDevice) -> Self {
6739         ::std::convert::From::from(::std::clone::Clone::clone(value))
6740     }
6741 }
6742 impl<'a> ::windows::runtime::IntoParam<'a, IDMLObject> for IDMLDevice {
into_param(self) -> ::windows::runtime::Param<'a, IDMLObject>6743     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLObject> {
6744         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLObject>::into(self))
6745     }
6746 }
6747 impl<'a> ::windows::runtime::IntoParam<'a, IDMLObject> for &IDMLDevice {
into_param(self) -> ::windows::runtime::Param<'a, IDMLObject>6748     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLObject> {
6749         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLObject>::into(::std::clone::Clone::clone(self)))
6750     }
6751 }
6752 #[repr(C)]
6753 #[doc(hidden)]
6754 pub struct IDMLDevice_abi(
6755     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
6756     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
6757     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
6758     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6759     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6760     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, data: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
6761     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, name: super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
6762     #[cfg(not(feature = "Win32_Foundation"))] usize,
6763     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, feature: DML_FEATURE, featurequerydatasize: u32, featurequerydata: *const ::std::ffi::c_void, featuresupportdatasize: u32, featuresupportdata: *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6764     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, desc: *const DML_OPERATOR_DESC, riid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6765     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, op: ::windows::runtime::RawPtr, flags: DML_EXECUTION_FLAGS, riid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6766     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, operatorcount: u32, operators: *const ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6767     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6768     #[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, desc: *const ::std::mem::ManuallyDrop<DML_BINDING_TABLE_DESC>, riid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6769     #[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
6770     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, count: u32, ppobjects: *const ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
6771     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, count: u32, ppobjects: *const ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
6772     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
6773     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6774 );
6775 #[repr(transparent)]
6776 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
6777 pub struct IDMLDevice1(::windows::runtime::IUnknown);
6778 impl IDMLDevice1 {
GetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>6779     pub unsafe fn GetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6780         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), ::std::mem::transmute(datasize), ::std::mem::transmute(data)).ok()
6781     }
SetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()>6782     pub unsafe fn SetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6783         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), ::std::mem::transmute(datasize), ::std::mem::transmute(data)).ok()
6784     }
SetPrivateDataInterface<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, guid: *const ::windows::runtime::GUID, data: Param1) -> ::windows::runtime::Result<()>6785     pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, guid: *const ::windows::runtime::GUID, data: Param1) -> ::windows::runtime::Result<()> {
6786         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), data.into_param().abi()).ok()
6787     }
6788     #[cfg(feature = "Win32_Foundation")]
SetName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::runtime::Result<()>6789     pub unsafe fn SetName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::runtime::Result<()> {
6790         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), name.into_param().abi()).ok()
6791     }
CheckFeatureSupport(&self, feature: DML_FEATURE, featurequerydatasize: u32, featurequerydata: *const ::std::ffi::c_void, featuresupportdatasize: u32, featuresupportdata: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>6792     pub unsafe fn CheckFeatureSupport(&self, feature: DML_FEATURE, featurequerydatasize: u32, featurequerydata: *const ::std::ffi::c_void, featuresupportdatasize: u32, featuresupportdata: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6793         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(feature), ::std::mem::transmute(featurequerydatasize), ::std::mem::transmute(featurequerydata), ::std::mem::transmute(featuresupportdatasize), ::std::mem::transmute(featuresupportdata)).ok()
6794     }
CreateOperator<T: ::windows::runtime::Interface>(&self, desc: *const DML_OPERATOR_DESC, result__: *mut ::std::option::Option<T>) -> ::windows::runtime::Result<()>6795     pub unsafe fn CreateOperator<T: ::windows::runtime::Interface>(&self, desc: *const DML_OPERATOR_DESC, result__: *mut ::std::option::Option<T>) -> ::windows::runtime::Result<()> {
6796         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(desc), &<T as ::windows::runtime::Interface>::IID, result__ as *mut _ as *mut _).ok()
6797     }
CompileOperator<'a, Param0: ::windows::runtime::IntoParam<'a, IDMLOperator>, T: ::windows::runtime::Interface>(&self, op: Param0, flags: DML_EXECUTION_FLAGS, result__: *mut ::std::option::Option<T>) -> ::windows::runtime::Result<()>6798     pub unsafe fn CompileOperator<'a, Param0: ::windows::runtime::IntoParam<'a, IDMLOperator>, T: ::windows::runtime::Interface>(&self, op: Param0, flags: DML_EXECUTION_FLAGS, result__: *mut ::std::option::Option<T>) -> ::windows::runtime::Result<()> {
6799         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), op.into_param().abi(), ::std::mem::transmute(flags), &<T as ::windows::runtime::Interface>::IID, result__ as *mut _ as *mut _).ok()
6800     }
CreateOperatorInitializer<T: ::windows::runtime::Interface>(&self, operatorcount: u32, operators: *const ::std::option::Option<IDMLCompiledOperator>) -> ::windows::runtime::Result<T>6801     pub unsafe fn CreateOperatorInitializer<T: ::windows::runtime::Interface>(&self, operatorcount: u32, operators: *const ::std::option::Option<IDMLCompiledOperator>) -> ::windows::runtime::Result<T> {
6802         let mut result__ = ::std::option::Option::None;
6803         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), ::std::mem::transmute(operatorcount), ::std::mem::transmute(operators), &<T as ::windows::runtime::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
6804     }
CreateCommandRecorder<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T>6805     pub unsafe fn CreateCommandRecorder<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T> {
6806         let mut result__ = ::std::option::Option::None;
6807         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), &<T as ::windows::runtime::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
6808     }
6809     #[cfg(feature = "Win32_Graphics_Direct3D12")]
CreateBindingTable<T: ::windows::runtime::Interface>(&self, desc: *const DML_BINDING_TABLE_DESC) -> ::windows::runtime::Result<T>6810     pub unsafe fn CreateBindingTable<T: ::windows::runtime::Interface>(&self, desc: *const DML_BINDING_TABLE_DESC) -> ::windows::runtime::Result<T> {
6811         let mut result__ = ::std::option::Option::None;
6812         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), ::std::mem::transmute(desc), &<T as ::windows::runtime::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
6813     }
Evict(&self, count: u32, ppobjects: *const ::std::option::Option<IDMLPageable>) -> ::windows::runtime::Result<()>6814     pub unsafe fn Evict(&self, count: u32, ppobjects: *const ::std::option::Option<IDMLPageable>) -> ::windows::runtime::Result<()> {
6815         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), ::std::mem::transmute(count), ::std::mem::transmute(ppobjects)).ok()
6816     }
MakeResident(&self, count: u32, ppobjects: *const ::std::option::Option<IDMLPageable>) -> ::windows::runtime::Result<()>6817     pub unsafe fn MakeResident(&self, count: u32, ppobjects: *const ::std::option::Option<IDMLPageable>) -> ::windows::runtime::Result<()> {
6818         (::windows::runtime::Interface::vtable(self).14)(::std::mem::transmute_copy(self), ::std::mem::transmute(count), ::std::mem::transmute(ppobjects)).ok()
6819     }
GetDeviceRemovedReason(&self) -> ::windows::runtime::Result<()>6820     pub unsafe fn GetDeviceRemovedReason(&self) -> ::windows::runtime::Result<()> {
6821         (::windows::runtime::Interface::vtable(self).15)(::std::mem::transmute_copy(self)).ok()
6822     }
GetParentDevice<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T>6823     pub unsafe fn GetParentDevice<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T> {
6824         let mut result__ = ::std::option::Option::None;
6825         (::windows::runtime::Interface::vtable(self).16)(::std::mem::transmute_copy(self), &<T as ::windows::runtime::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
6826     }
CompileGraph<T: ::windows::runtime::Interface>(&self, desc: *const DML_GRAPH_DESC, flags: DML_EXECUTION_FLAGS, result__: *mut ::std::option::Option<T>) -> ::windows::runtime::Result<()>6827     pub unsafe fn CompileGraph<T: ::windows::runtime::Interface>(&self, desc: *const DML_GRAPH_DESC, flags: DML_EXECUTION_FLAGS, result__: *mut ::std::option::Option<T>) -> ::windows::runtime::Result<()> {
6828         (::windows::runtime::Interface::vtable(self).17)(::std::mem::transmute_copy(self), ::std::mem::transmute(desc), ::std::mem::transmute(flags), &<T as ::windows::runtime::Interface>::IID, result__ as *mut _ as *mut _).ok()
6829     }
6830 }
6831 unsafe impl ::windows::runtime::Interface for IDMLDevice1 {
6832     type Vtable = IDMLDevice1_abi;
6833     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(2693287834, 53950, 17237, [170, 93, 89, 1, 40, 26, 209, 210]);
6834 }
6835 impl ::std::convert::From<IDMLDevice1> for ::windows::runtime::IUnknown {
from(value: IDMLDevice1) -> Self6836     fn from(value: IDMLDevice1) -> Self {
6837         unsafe { ::std::mem::transmute(value) }
6838     }
6839 }
6840 impl ::std::convert::From<&IDMLDevice1> for ::windows::runtime::IUnknown {
from(value: &IDMLDevice1) -> Self6841     fn from(value: &IDMLDevice1) -> Self {
6842         ::std::convert::From::from(::std::clone::Clone::clone(value))
6843     }
6844 }
6845 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IDMLDevice1 {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>6846     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
6847         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
6848     }
6849 }
6850 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IDMLDevice1 {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>6851     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
6852         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
6853     }
6854 }
6855 impl ::std::convert::From<IDMLDevice1> for IDMLDevice {
from(value: IDMLDevice1) -> Self6856     fn from(value: IDMLDevice1) -> Self {
6857         unsafe { ::std::mem::transmute(value) }
6858     }
6859 }
6860 impl ::std::convert::From<&IDMLDevice1> for IDMLDevice {
from(value: &IDMLDevice1) -> Self6861     fn from(value: &IDMLDevice1) -> Self {
6862         ::std::convert::From::from(::std::clone::Clone::clone(value))
6863     }
6864 }
6865 impl<'a> ::windows::runtime::IntoParam<'a, IDMLDevice> for IDMLDevice1 {
into_param(self) -> ::windows::runtime::Param<'a, IDMLDevice>6866     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLDevice> {
6867         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLDevice>::into(self))
6868     }
6869 }
6870 impl<'a> ::windows::runtime::IntoParam<'a, IDMLDevice> for &IDMLDevice1 {
into_param(self) -> ::windows::runtime::Param<'a, IDMLDevice>6871     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLDevice> {
6872         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLDevice>::into(::std::clone::Clone::clone(self)))
6873     }
6874 }
6875 impl ::std::convert::From<IDMLDevice1> for IDMLObject {
from(value: IDMLDevice1) -> Self6876     fn from(value: IDMLDevice1) -> Self {
6877         unsafe { ::std::mem::transmute(value) }
6878     }
6879 }
6880 impl ::std::convert::From<&IDMLDevice1> for IDMLObject {
from(value: &IDMLDevice1) -> Self6881     fn from(value: &IDMLDevice1) -> Self {
6882         ::std::convert::From::from(::std::clone::Clone::clone(value))
6883     }
6884 }
6885 impl<'a> ::windows::runtime::IntoParam<'a, IDMLObject> for IDMLDevice1 {
into_param(self) -> ::windows::runtime::Param<'a, IDMLObject>6886     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLObject> {
6887         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLObject>::into(self))
6888     }
6889 }
6890 impl<'a> ::windows::runtime::IntoParam<'a, IDMLObject> for &IDMLDevice1 {
into_param(self) -> ::windows::runtime::Param<'a, IDMLObject>6891     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLObject> {
6892         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLObject>::into(::std::clone::Clone::clone(self)))
6893     }
6894 }
6895 #[repr(C)]
6896 #[doc(hidden)]
6897 pub struct IDMLDevice1_abi(
6898     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
6899     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
6900     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
6901     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6902     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6903     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, data: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
6904     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, name: super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
6905     #[cfg(not(feature = "Win32_Foundation"))] usize,
6906     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, feature: DML_FEATURE, featurequerydatasize: u32, featurequerydata: *const ::std::ffi::c_void, featuresupportdatasize: u32, featuresupportdata: *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6907     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, desc: *const DML_OPERATOR_DESC, riid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6908     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, op: ::windows::runtime::RawPtr, flags: DML_EXECUTION_FLAGS, riid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6909     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, operatorcount: u32, operators: *const ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6910     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6911     #[cfg(feature = "Win32_Graphics_Direct3D12")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, desc: *const ::std::mem::ManuallyDrop<DML_BINDING_TABLE_DESC>, riid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6912     #[cfg(not(feature = "Win32_Graphics_Direct3D12"))] usize,
6913     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, count: u32, ppobjects: *const ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
6914     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, count: u32, ppobjects: *const ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
6915     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
6916     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6917     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, desc: *const DML_GRAPH_DESC, flags: DML_EXECUTION_FLAGS, riid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6918 );
6919 #[repr(transparent)]
6920 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
6921 pub struct IDMLDeviceChild(::windows::runtime::IUnknown);
6922 impl IDMLDeviceChild {
GetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>6923     pub unsafe fn GetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6924         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), ::std::mem::transmute(datasize), ::std::mem::transmute(data)).ok()
6925     }
SetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()>6926     pub unsafe fn SetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6927         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), ::std::mem::transmute(datasize), ::std::mem::transmute(data)).ok()
6928     }
SetPrivateDataInterface<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, guid: *const ::windows::runtime::GUID, data: Param1) -> ::windows::runtime::Result<()>6929     pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, guid: *const ::windows::runtime::GUID, data: Param1) -> ::windows::runtime::Result<()> {
6930         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), data.into_param().abi()).ok()
6931     }
6932     #[cfg(feature = "Win32_Foundation")]
SetName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::runtime::Result<()>6933     pub unsafe fn SetName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::runtime::Result<()> {
6934         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), name.into_param().abi()).ok()
6935     }
GetDevice<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T>6936     pub unsafe fn GetDevice<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T> {
6937         let mut result__ = ::std::option::Option::None;
6938         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), &<T as ::windows::runtime::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
6939     }
6940 }
6941 unsafe impl ::windows::runtime::Interface for IDMLDeviceChild {
6942     type Vtable = IDMLDeviceChild_abi;
6943     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(669528386, 33125, 18915, [151, 78, 47, 214, 110, 76, 182, 157]);
6944 }
6945 impl ::std::convert::From<IDMLDeviceChild> for ::windows::runtime::IUnknown {
from(value: IDMLDeviceChild) -> Self6946     fn from(value: IDMLDeviceChild) -> Self {
6947         unsafe { ::std::mem::transmute(value) }
6948     }
6949 }
6950 impl ::std::convert::From<&IDMLDeviceChild> for ::windows::runtime::IUnknown {
from(value: &IDMLDeviceChild) -> Self6951     fn from(value: &IDMLDeviceChild) -> Self {
6952         ::std::convert::From::from(::std::clone::Clone::clone(value))
6953     }
6954 }
6955 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IDMLDeviceChild {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>6956     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
6957         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
6958     }
6959 }
6960 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IDMLDeviceChild {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>6961     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
6962         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
6963     }
6964 }
6965 impl ::std::convert::From<IDMLDeviceChild> for IDMLObject {
from(value: IDMLDeviceChild) -> Self6966     fn from(value: IDMLDeviceChild) -> Self {
6967         unsafe { ::std::mem::transmute(value) }
6968     }
6969 }
6970 impl ::std::convert::From<&IDMLDeviceChild> for IDMLObject {
from(value: &IDMLDeviceChild) -> Self6971     fn from(value: &IDMLDeviceChild) -> Self {
6972         ::std::convert::From::from(::std::clone::Clone::clone(value))
6973     }
6974 }
6975 impl<'a> ::windows::runtime::IntoParam<'a, IDMLObject> for IDMLDeviceChild {
into_param(self) -> ::windows::runtime::Param<'a, IDMLObject>6976     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLObject> {
6977         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLObject>::into(self))
6978     }
6979 }
6980 impl<'a> ::windows::runtime::IntoParam<'a, IDMLObject> for &IDMLDeviceChild {
into_param(self) -> ::windows::runtime::Param<'a, IDMLObject>6981     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLObject> {
6982         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLObject>::into(::std::clone::Clone::clone(self)))
6983     }
6984 }
6985 #[repr(C)]
6986 #[doc(hidden)]
6987 pub struct IDMLDeviceChild_abi(
6988     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
6989     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
6990     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
6991     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6992     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6993     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, data: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
6994     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, name: super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
6995     #[cfg(not(feature = "Win32_Foundation"))] usize,
6996     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
6997 );
6998 #[repr(transparent)]
6999 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
7000 pub struct IDMLDispatchable(::windows::runtime::IUnknown);
7001 impl IDMLDispatchable {
GetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>7002     pub unsafe fn GetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
7003         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), ::std::mem::transmute(datasize), ::std::mem::transmute(data)).ok()
7004     }
SetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()>7005     pub unsafe fn SetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
7006         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), ::std::mem::transmute(datasize), ::std::mem::transmute(data)).ok()
7007     }
SetPrivateDataInterface<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, guid: *const ::windows::runtime::GUID, data: Param1) -> ::windows::runtime::Result<()>7008     pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, guid: *const ::windows::runtime::GUID, data: Param1) -> ::windows::runtime::Result<()> {
7009         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), data.into_param().abi()).ok()
7010     }
7011     #[cfg(feature = "Win32_Foundation")]
SetName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::runtime::Result<()>7012     pub unsafe fn SetName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::runtime::Result<()> {
7013         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), name.into_param().abi()).ok()
7014     }
GetDevice<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T>7015     pub unsafe fn GetDevice<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T> {
7016         let mut result__ = ::std::option::Option::None;
7017         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), &<T as ::windows::runtime::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
7018     }
GetBindingProperties(&self) -> DML_BINDING_PROPERTIES7019     pub unsafe fn GetBindingProperties(&self) -> DML_BINDING_PROPERTIES {
7020         let mut result__: DML_BINDING_PROPERTIES = ::std::default::Default::default();
7021         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), &mut result__);
7022         result__
7023     }
7024 }
7025 unsafe impl ::windows::runtime::Interface for IDMLDispatchable {
7026     type Vtable = IDMLDispatchable_abi;
7027     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3703054760, 4153, 17438, [159, 28, 177, 117, 156, 47, 60, 236]);
7028 }
7029 impl ::std::convert::From<IDMLDispatchable> for ::windows::runtime::IUnknown {
from(value: IDMLDispatchable) -> Self7030     fn from(value: IDMLDispatchable) -> Self {
7031         unsafe { ::std::mem::transmute(value) }
7032     }
7033 }
7034 impl ::std::convert::From<&IDMLDispatchable> for ::windows::runtime::IUnknown {
from(value: &IDMLDispatchable) -> Self7035     fn from(value: &IDMLDispatchable) -> Self {
7036         ::std::convert::From::from(::std::clone::Clone::clone(value))
7037     }
7038 }
7039 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IDMLDispatchable {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>7040     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
7041         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
7042     }
7043 }
7044 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IDMLDispatchable {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>7045     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
7046         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
7047     }
7048 }
7049 impl ::std::convert::From<IDMLDispatchable> for IDMLPageable {
from(value: IDMLDispatchable) -> Self7050     fn from(value: IDMLDispatchable) -> Self {
7051         unsafe { ::std::mem::transmute(value) }
7052     }
7053 }
7054 impl ::std::convert::From<&IDMLDispatchable> for IDMLPageable {
from(value: &IDMLDispatchable) -> Self7055     fn from(value: &IDMLDispatchable) -> Self {
7056         ::std::convert::From::from(::std::clone::Clone::clone(value))
7057     }
7058 }
7059 impl<'a> ::windows::runtime::IntoParam<'a, IDMLPageable> for IDMLDispatchable {
into_param(self) -> ::windows::runtime::Param<'a, IDMLPageable>7060     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLPageable> {
7061         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLPageable>::into(self))
7062     }
7063 }
7064 impl<'a> ::windows::runtime::IntoParam<'a, IDMLPageable> for &IDMLDispatchable {
into_param(self) -> ::windows::runtime::Param<'a, IDMLPageable>7065     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLPageable> {
7066         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLPageable>::into(::std::clone::Clone::clone(self)))
7067     }
7068 }
7069 impl ::std::convert::From<IDMLDispatchable> for IDMLDeviceChild {
from(value: IDMLDispatchable) -> Self7070     fn from(value: IDMLDispatchable) -> Self {
7071         unsafe { ::std::mem::transmute(value) }
7072     }
7073 }
7074 impl ::std::convert::From<&IDMLDispatchable> for IDMLDeviceChild {
from(value: &IDMLDispatchable) -> Self7075     fn from(value: &IDMLDispatchable) -> Self {
7076         ::std::convert::From::from(::std::clone::Clone::clone(value))
7077     }
7078 }
7079 impl<'a> ::windows::runtime::IntoParam<'a, IDMLDeviceChild> for IDMLDispatchable {
into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild>7080     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild> {
7081         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLDeviceChild>::into(self))
7082     }
7083 }
7084 impl<'a> ::windows::runtime::IntoParam<'a, IDMLDeviceChild> for &IDMLDispatchable {
into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild>7085     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild> {
7086         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLDeviceChild>::into(::std::clone::Clone::clone(self)))
7087     }
7088 }
7089 impl ::std::convert::From<IDMLDispatchable> for IDMLObject {
from(value: IDMLDispatchable) -> Self7090     fn from(value: IDMLDispatchable) -> Self {
7091         unsafe { ::std::mem::transmute(value) }
7092     }
7093 }
7094 impl ::std::convert::From<&IDMLDispatchable> for IDMLObject {
from(value: &IDMLDispatchable) -> Self7095     fn from(value: &IDMLDispatchable) -> Self {
7096         ::std::convert::From::from(::std::clone::Clone::clone(value))
7097     }
7098 }
7099 impl<'a> ::windows::runtime::IntoParam<'a, IDMLObject> for IDMLDispatchable {
into_param(self) -> ::windows::runtime::Param<'a, IDMLObject>7100     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLObject> {
7101         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLObject>::into(self))
7102     }
7103 }
7104 impl<'a> ::windows::runtime::IntoParam<'a, IDMLObject> for &IDMLDispatchable {
into_param(self) -> ::windows::runtime::Param<'a, IDMLObject>7105     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLObject> {
7106         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLObject>::into(::std::clone::Clone::clone(self)))
7107     }
7108 }
7109 #[repr(C)]
7110 #[doc(hidden)]
7111 pub struct IDMLDispatchable_abi(
7112     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
7113     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
7114     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
7115     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
7116     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
7117     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, data: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
7118     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, name: super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
7119     #[cfg(not(feature = "Win32_Foundation"))] usize,
7120     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
7121     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, result__: *mut DML_BINDING_PROPERTIES),
7122 );
7123 #[repr(transparent)]
7124 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
7125 pub struct IDMLObject(::windows::runtime::IUnknown);
7126 impl IDMLObject {
GetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>7127     pub unsafe fn GetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
7128         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), ::std::mem::transmute(datasize), ::std::mem::transmute(data)).ok()
7129     }
SetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()>7130     pub unsafe fn SetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
7131         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), ::std::mem::transmute(datasize), ::std::mem::transmute(data)).ok()
7132     }
SetPrivateDataInterface<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, guid: *const ::windows::runtime::GUID, data: Param1) -> ::windows::runtime::Result<()>7133     pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, guid: *const ::windows::runtime::GUID, data: Param1) -> ::windows::runtime::Result<()> {
7134         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), data.into_param().abi()).ok()
7135     }
7136     #[cfg(feature = "Win32_Foundation")]
SetName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::runtime::Result<()>7137     pub unsafe fn SetName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::runtime::Result<()> {
7138         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), name.into_param().abi()).ok()
7139     }
7140 }
7141 unsafe impl ::windows::runtime::Interface for IDMLObject {
7142     type Vtable = IDMLObject_abi;
7143     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3357948588, 40460, 18989, [155, 142, 0, 117, 33, 163, 49, 124]);
7144 }
7145 impl ::std::convert::From<IDMLObject> for ::windows::runtime::IUnknown {
from(value: IDMLObject) -> Self7146     fn from(value: IDMLObject) -> Self {
7147         unsafe { ::std::mem::transmute(value) }
7148     }
7149 }
7150 impl ::std::convert::From<&IDMLObject> for ::windows::runtime::IUnknown {
from(value: &IDMLObject) -> Self7151     fn from(value: &IDMLObject) -> Self {
7152         ::std::convert::From::from(::std::clone::Clone::clone(value))
7153     }
7154 }
7155 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IDMLObject {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>7156     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
7157         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
7158     }
7159 }
7160 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IDMLObject {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>7161     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
7162         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
7163     }
7164 }
7165 #[repr(C)]
7166 #[doc(hidden)]
7167 pub struct IDMLObject_abi(
7168     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
7169     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
7170     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
7171     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
7172     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
7173     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, data: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
7174     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, name: super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
7175     #[cfg(not(feature = "Win32_Foundation"))] usize,
7176 );
7177 #[repr(transparent)]
7178 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
7179 pub struct IDMLOperator(::windows::runtime::IUnknown);
7180 impl IDMLOperator {
GetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>7181     pub unsafe fn GetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
7182         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), ::std::mem::transmute(datasize), ::std::mem::transmute(data)).ok()
7183     }
SetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()>7184     pub unsafe fn SetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
7185         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), ::std::mem::transmute(datasize), ::std::mem::transmute(data)).ok()
7186     }
SetPrivateDataInterface<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, guid: *const ::windows::runtime::GUID, data: Param1) -> ::windows::runtime::Result<()>7187     pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, guid: *const ::windows::runtime::GUID, data: Param1) -> ::windows::runtime::Result<()> {
7188         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), data.into_param().abi()).ok()
7189     }
7190     #[cfg(feature = "Win32_Foundation")]
SetName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::runtime::Result<()>7191     pub unsafe fn SetName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::runtime::Result<()> {
7192         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), name.into_param().abi()).ok()
7193     }
GetDevice<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T>7194     pub unsafe fn GetDevice<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T> {
7195         let mut result__ = ::std::option::Option::None;
7196         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), &<T as ::windows::runtime::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
7197     }
7198 }
7199 unsafe impl ::windows::runtime::Interface for IDMLOperator {
7200     type Vtable = IDMLOperator_abi;
7201     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(650817146, 12417, 17971, [149, 129, 34, 111, 190, 87, 105, 93]);
7202 }
7203 impl ::std::convert::From<IDMLOperator> for ::windows::runtime::IUnknown {
from(value: IDMLOperator) -> Self7204     fn from(value: IDMLOperator) -> Self {
7205         unsafe { ::std::mem::transmute(value) }
7206     }
7207 }
7208 impl ::std::convert::From<&IDMLOperator> for ::windows::runtime::IUnknown {
from(value: &IDMLOperator) -> Self7209     fn from(value: &IDMLOperator) -> Self {
7210         ::std::convert::From::from(::std::clone::Clone::clone(value))
7211     }
7212 }
7213 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IDMLOperator {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>7214     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
7215         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
7216     }
7217 }
7218 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IDMLOperator {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>7219     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
7220         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
7221     }
7222 }
7223 impl ::std::convert::From<IDMLOperator> for IDMLDeviceChild {
from(value: IDMLOperator) -> Self7224     fn from(value: IDMLOperator) -> Self {
7225         unsafe { ::std::mem::transmute(value) }
7226     }
7227 }
7228 impl ::std::convert::From<&IDMLOperator> for IDMLDeviceChild {
from(value: &IDMLOperator) -> Self7229     fn from(value: &IDMLOperator) -> Self {
7230         ::std::convert::From::from(::std::clone::Clone::clone(value))
7231     }
7232 }
7233 impl<'a> ::windows::runtime::IntoParam<'a, IDMLDeviceChild> for IDMLOperator {
into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild>7234     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild> {
7235         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLDeviceChild>::into(self))
7236     }
7237 }
7238 impl<'a> ::windows::runtime::IntoParam<'a, IDMLDeviceChild> for &IDMLOperator {
into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild>7239     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild> {
7240         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLDeviceChild>::into(::std::clone::Clone::clone(self)))
7241     }
7242 }
7243 impl ::std::convert::From<IDMLOperator> for IDMLObject {
from(value: IDMLOperator) -> Self7244     fn from(value: IDMLOperator) -> Self {
7245         unsafe { ::std::mem::transmute(value) }
7246     }
7247 }
7248 impl ::std::convert::From<&IDMLOperator> for IDMLObject {
from(value: &IDMLOperator) -> Self7249     fn from(value: &IDMLOperator) -> Self {
7250         ::std::convert::From::from(::std::clone::Clone::clone(value))
7251     }
7252 }
7253 impl<'a> ::windows::runtime::IntoParam<'a, IDMLObject> for IDMLOperator {
into_param(self) -> ::windows::runtime::Param<'a, IDMLObject>7254     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLObject> {
7255         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLObject>::into(self))
7256     }
7257 }
7258 impl<'a> ::windows::runtime::IntoParam<'a, IDMLObject> for &IDMLOperator {
into_param(self) -> ::windows::runtime::Param<'a, IDMLObject>7259     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLObject> {
7260         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLObject>::into(::std::clone::Clone::clone(self)))
7261     }
7262 }
7263 #[repr(C)]
7264 #[doc(hidden)]
7265 pub struct IDMLOperator_abi(
7266     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
7267     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
7268     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
7269     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
7270     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
7271     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, data: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
7272     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, name: super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
7273     #[cfg(not(feature = "Win32_Foundation"))] usize,
7274     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
7275 );
7276 #[repr(transparent)]
7277 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
7278 pub struct IDMLOperatorInitializer(::windows::runtime::IUnknown);
7279 impl IDMLOperatorInitializer {
GetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>7280     pub unsafe fn GetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
7281         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), ::std::mem::transmute(datasize), ::std::mem::transmute(data)).ok()
7282     }
SetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()>7283     pub unsafe fn SetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
7284         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), ::std::mem::transmute(datasize), ::std::mem::transmute(data)).ok()
7285     }
SetPrivateDataInterface<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, guid: *const ::windows::runtime::GUID, data: Param1) -> ::windows::runtime::Result<()>7286     pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, guid: *const ::windows::runtime::GUID, data: Param1) -> ::windows::runtime::Result<()> {
7287         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), data.into_param().abi()).ok()
7288     }
7289     #[cfg(feature = "Win32_Foundation")]
SetName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::runtime::Result<()>7290     pub unsafe fn SetName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::runtime::Result<()> {
7291         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), name.into_param().abi()).ok()
7292     }
GetDevice<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T>7293     pub unsafe fn GetDevice<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T> {
7294         let mut result__ = ::std::option::Option::None;
7295         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), &<T as ::windows::runtime::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
7296     }
GetBindingProperties(&self) -> DML_BINDING_PROPERTIES7297     pub unsafe fn GetBindingProperties(&self) -> DML_BINDING_PROPERTIES {
7298         let mut result__: DML_BINDING_PROPERTIES = ::std::default::Default::default();
7299         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), &mut result__);
7300         result__
7301     }
Reset(&self, operatorcount: u32, operators: *const ::std::option::Option<IDMLCompiledOperator>) -> ::windows::runtime::Result<()>7302     pub unsafe fn Reset(&self, operatorcount: u32, operators: *const ::std::option::Option<IDMLCompiledOperator>) -> ::windows::runtime::Result<()> {
7303         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), ::std::mem::transmute(operatorcount), ::std::mem::transmute(operators)).ok()
7304     }
7305 }
7306 unsafe impl ::windows::runtime::Interface for IDMLOperatorInitializer {
7307     type Vtable = IDMLOperatorInitializer_abi;
7308     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1115427091, 17244, 18076, [134, 118, 77, 93, 208, 114, 248, 19]);
7309 }
7310 impl ::std::convert::From<IDMLOperatorInitializer> for ::windows::runtime::IUnknown {
from(value: IDMLOperatorInitializer) -> Self7311     fn from(value: IDMLOperatorInitializer) -> Self {
7312         unsafe { ::std::mem::transmute(value) }
7313     }
7314 }
7315 impl ::std::convert::From<&IDMLOperatorInitializer> for ::windows::runtime::IUnknown {
from(value: &IDMLOperatorInitializer) -> Self7316     fn from(value: &IDMLOperatorInitializer) -> Self {
7317         ::std::convert::From::from(::std::clone::Clone::clone(value))
7318     }
7319 }
7320 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IDMLOperatorInitializer {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>7321     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
7322         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
7323     }
7324 }
7325 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IDMLOperatorInitializer {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>7326     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
7327         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
7328     }
7329 }
7330 impl ::std::convert::From<IDMLOperatorInitializer> for IDMLDispatchable {
from(value: IDMLOperatorInitializer) -> Self7331     fn from(value: IDMLOperatorInitializer) -> Self {
7332         unsafe { ::std::mem::transmute(value) }
7333     }
7334 }
7335 impl ::std::convert::From<&IDMLOperatorInitializer> for IDMLDispatchable {
from(value: &IDMLOperatorInitializer) -> Self7336     fn from(value: &IDMLOperatorInitializer) -> Self {
7337         ::std::convert::From::from(::std::clone::Clone::clone(value))
7338     }
7339 }
7340 impl<'a> ::windows::runtime::IntoParam<'a, IDMLDispatchable> for IDMLOperatorInitializer {
into_param(self) -> ::windows::runtime::Param<'a, IDMLDispatchable>7341     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLDispatchable> {
7342         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLDispatchable>::into(self))
7343     }
7344 }
7345 impl<'a> ::windows::runtime::IntoParam<'a, IDMLDispatchable> for &IDMLOperatorInitializer {
into_param(self) -> ::windows::runtime::Param<'a, IDMLDispatchable>7346     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLDispatchable> {
7347         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLDispatchable>::into(::std::clone::Clone::clone(self)))
7348     }
7349 }
7350 impl ::std::convert::From<IDMLOperatorInitializer> for IDMLPageable {
from(value: IDMLOperatorInitializer) -> Self7351     fn from(value: IDMLOperatorInitializer) -> Self {
7352         unsafe { ::std::mem::transmute(value) }
7353     }
7354 }
7355 impl ::std::convert::From<&IDMLOperatorInitializer> for IDMLPageable {
from(value: &IDMLOperatorInitializer) -> Self7356     fn from(value: &IDMLOperatorInitializer) -> Self {
7357         ::std::convert::From::from(::std::clone::Clone::clone(value))
7358     }
7359 }
7360 impl<'a> ::windows::runtime::IntoParam<'a, IDMLPageable> for IDMLOperatorInitializer {
into_param(self) -> ::windows::runtime::Param<'a, IDMLPageable>7361     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLPageable> {
7362         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLPageable>::into(self))
7363     }
7364 }
7365 impl<'a> ::windows::runtime::IntoParam<'a, IDMLPageable> for &IDMLOperatorInitializer {
into_param(self) -> ::windows::runtime::Param<'a, IDMLPageable>7366     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLPageable> {
7367         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLPageable>::into(::std::clone::Clone::clone(self)))
7368     }
7369 }
7370 impl ::std::convert::From<IDMLOperatorInitializer> for IDMLDeviceChild {
from(value: IDMLOperatorInitializer) -> Self7371     fn from(value: IDMLOperatorInitializer) -> Self {
7372         unsafe { ::std::mem::transmute(value) }
7373     }
7374 }
7375 impl ::std::convert::From<&IDMLOperatorInitializer> for IDMLDeviceChild {
from(value: &IDMLOperatorInitializer) -> Self7376     fn from(value: &IDMLOperatorInitializer) -> Self {
7377         ::std::convert::From::from(::std::clone::Clone::clone(value))
7378     }
7379 }
7380 impl<'a> ::windows::runtime::IntoParam<'a, IDMLDeviceChild> for IDMLOperatorInitializer {
into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild>7381     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild> {
7382         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLDeviceChild>::into(self))
7383     }
7384 }
7385 impl<'a> ::windows::runtime::IntoParam<'a, IDMLDeviceChild> for &IDMLOperatorInitializer {
into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild>7386     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild> {
7387         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLDeviceChild>::into(::std::clone::Clone::clone(self)))
7388     }
7389 }
7390 impl ::std::convert::From<IDMLOperatorInitializer> for IDMLObject {
from(value: IDMLOperatorInitializer) -> Self7391     fn from(value: IDMLOperatorInitializer) -> Self {
7392         unsafe { ::std::mem::transmute(value) }
7393     }
7394 }
7395 impl ::std::convert::From<&IDMLOperatorInitializer> for IDMLObject {
from(value: &IDMLOperatorInitializer) -> Self7396     fn from(value: &IDMLOperatorInitializer) -> Self {
7397         ::std::convert::From::from(::std::clone::Clone::clone(value))
7398     }
7399 }
7400 impl<'a> ::windows::runtime::IntoParam<'a, IDMLObject> for IDMLOperatorInitializer {
into_param(self) -> ::windows::runtime::Param<'a, IDMLObject>7401     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLObject> {
7402         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLObject>::into(self))
7403     }
7404 }
7405 impl<'a> ::windows::runtime::IntoParam<'a, IDMLObject> for &IDMLOperatorInitializer {
into_param(self) -> ::windows::runtime::Param<'a, IDMLObject>7406     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLObject> {
7407         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLObject>::into(::std::clone::Clone::clone(self)))
7408     }
7409 }
7410 #[repr(C)]
7411 #[doc(hidden)]
7412 pub struct IDMLOperatorInitializer_abi(
7413     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
7414     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
7415     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
7416     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
7417     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
7418     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, data: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
7419     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, name: super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
7420     #[cfg(not(feature = "Win32_Foundation"))] usize,
7421     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
7422     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, result__: *mut DML_BINDING_PROPERTIES),
7423     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, operatorcount: u32, operators: *const ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
7424 );
7425 #[repr(transparent)]
7426 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
7427 pub struct IDMLPageable(::windows::runtime::IUnknown);
7428 impl IDMLPageable {
GetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>7429     pub unsafe fn GetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
7430         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), ::std::mem::transmute(datasize), ::std::mem::transmute(data)).ok()
7431     }
SetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()>7432     pub unsafe fn SetPrivateData(&self, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
7433         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), ::std::mem::transmute(datasize), ::std::mem::transmute(data)).ok()
7434     }
SetPrivateDataInterface<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, guid: *const ::windows::runtime::GUID, data: Param1) -> ::windows::runtime::Result<()>7435     pub unsafe fn SetPrivateDataInterface<'a, Param1: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, guid: *const ::windows::runtime::GUID, data: Param1) -> ::windows::runtime::Result<()> {
7436         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(guid), data.into_param().abi()).ok()
7437     }
7438     #[cfg(feature = "Win32_Foundation")]
SetName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::runtime::Result<()>7439     pub unsafe fn SetName<'a, Param0: ::windows::runtime::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::runtime::Result<()> {
7440         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), name.into_param().abi()).ok()
7441     }
GetDevice<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T>7442     pub unsafe fn GetDevice<T: ::windows::runtime::Interface>(&self) -> ::windows::runtime::Result<T> {
7443         let mut result__ = ::std::option::Option::None;
7444         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), &<T as ::windows::runtime::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
7445     }
7446 }
7447 unsafe impl ::windows::runtime::Interface for IDMLPageable {
7448     type Vtable = IDMLPageable_abi;
7449     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(2980775973, 17730, 19019, [134, 23, 109, 222, 110, 143, 98, 1]);
7450 }
7451 impl ::std::convert::From<IDMLPageable> for ::windows::runtime::IUnknown {
from(value: IDMLPageable) -> Self7452     fn from(value: IDMLPageable) -> Self {
7453         unsafe { ::std::mem::transmute(value) }
7454     }
7455 }
7456 impl ::std::convert::From<&IDMLPageable> for ::windows::runtime::IUnknown {
from(value: &IDMLPageable) -> Self7457     fn from(value: &IDMLPageable) -> Self {
7458         ::std::convert::From::from(::std::clone::Clone::clone(value))
7459     }
7460 }
7461 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IDMLPageable {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>7462     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
7463         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
7464     }
7465 }
7466 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IDMLPageable {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>7467     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
7468         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
7469     }
7470 }
7471 impl ::std::convert::From<IDMLPageable> for IDMLDeviceChild {
from(value: IDMLPageable) -> Self7472     fn from(value: IDMLPageable) -> Self {
7473         unsafe { ::std::mem::transmute(value) }
7474     }
7475 }
7476 impl ::std::convert::From<&IDMLPageable> for IDMLDeviceChild {
from(value: &IDMLPageable) -> Self7477     fn from(value: &IDMLPageable) -> Self {
7478         ::std::convert::From::from(::std::clone::Clone::clone(value))
7479     }
7480 }
7481 impl<'a> ::windows::runtime::IntoParam<'a, IDMLDeviceChild> for IDMLPageable {
into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild>7482     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild> {
7483         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLDeviceChild>::into(self))
7484     }
7485 }
7486 impl<'a> ::windows::runtime::IntoParam<'a, IDMLDeviceChild> for &IDMLPageable {
into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild>7487     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLDeviceChild> {
7488         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLDeviceChild>::into(::std::clone::Clone::clone(self)))
7489     }
7490 }
7491 impl ::std::convert::From<IDMLPageable> for IDMLObject {
from(value: IDMLPageable) -> Self7492     fn from(value: IDMLPageable) -> Self {
7493         unsafe { ::std::mem::transmute(value) }
7494     }
7495 }
7496 impl ::std::convert::From<&IDMLPageable> for IDMLObject {
from(value: &IDMLPageable) -> Self7497     fn from(value: &IDMLPageable) -> Self {
7498         ::std::convert::From::from(::std::clone::Clone::clone(value))
7499     }
7500 }
7501 impl<'a> ::windows::runtime::IntoParam<'a, IDMLObject> for IDMLPageable {
into_param(self) -> ::windows::runtime::Param<'a, IDMLObject>7502     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLObject> {
7503         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLObject>::into(self))
7504     }
7505 }
7506 impl<'a> ::windows::runtime::IntoParam<'a, IDMLObject> for &IDMLPageable {
into_param(self) -> ::windows::runtime::Param<'a, IDMLObject>7507     fn into_param(self) -> ::windows::runtime::Param<'a, IDMLObject> {
7508         ::windows::runtime::Param::Owned(::std::convert::Into::<IDMLObject>::into(::std::clone::Clone::clone(self)))
7509     }
7510 }
7511 #[repr(C)]
7512 #[doc(hidden)]
7513 pub struct IDMLPageable_abi(
7514     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
7515     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
7516     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
7517     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, datasize: *mut u32, data: *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
7518     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, datasize: u32, data: *const ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
7519     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, guid: *const ::windows::runtime::GUID, data: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
7520     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, name: super::super::super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
7521     #[cfg(not(feature = "Win32_Foundation"))] usize,
7522     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, riid: *const ::windows::runtime::GUID, ppv: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT,
7523 );
7524