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