1 krisbash 1.1 /* @migen@ */
2 /*
3 **==============================================================================
4 **
5 ** WARNING: THIS FILE WAS AUTOMATICALLY GENERATED. PLEASE DO NOT EDIT.
6 **
7 **==============================================================================
8 */
9 #pragma once
10
11 #ifndef _CIM_Error_h
12 #define _CIM_Error_h
13
14 #include <MI.h>
15
16 /*
17 **==============================================================================
18 **
19 ** CIM_Error [CIM_Error]
20 **
21 ** Keys:
22 krisbash 1.1 **
23 **==============================================================================
24 */
25
26 typedef struct _CIM_Error
27 {
28 MI_Instance __instance;
29 /* CIM_Error properties */
30 MI_ConstUint16Field ErrorType;
31 MI_ConstStringField OtherErrorType;
32 MI_ConstStringField OwningEntity;
33 MI_ConstStringField MessageID;
34 MI_ConstStringField Message;
35 MI_ConstStringAField MessageArguments;
36 MI_ConstUint16Field PerceivedSeverity;
37 MI_ConstUint16Field ProbableCause;
38 MI_ConstStringField ProbableCauseDescription;
39 MI_ConstStringAField RecommendedActions;
40 MI_ConstStringField ErrorSource;
41 MI_ConstUint16Field ErrorSourceFormat;
42 MI_ConstStringField OtherErrorSourceFormat;
43 krisbash 1.1 MI_ConstUint32Field CIMStatusCode;
44 MI_ConstStringField CIMStatusCodeDescription;
45 }
46 CIM_Error;
47
48 typedef struct _CIM_Error_Ref
49 {
50 CIM_Error* value;
51 MI_Boolean exists;
52 MI_Uint8 flags;
53 }
54 CIM_Error_Ref;
55
56 typedef struct _CIM_Error_ConstRef
57 {
58 MI_CONST CIM_Error* value;
59 MI_Boolean exists;
60 MI_Uint8 flags;
61 }
62 CIM_Error_ConstRef;
63
64 krisbash 1.1 typedef struct _CIM_Error_Array
65 {
66 struct _CIM_Error** data;
67 MI_Uint32 size;
68 }
69 CIM_Error_Array;
70
71 typedef struct _CIM_Error_ConstArray
72 {
73 struct _CIM_Error MI_CONST* MI_CONST* data;
74 MI_Uint32 size;
75 }
76 CIM_Error_ConstArray;
77
78 typedef struct _CIM_Error_ArrayRef
79 {
80 CIM_Error_Array value;
81 MI_Boolean exists;
82 MI_Uint8 flags;
83 }
84 CIM_Error_ArrayRef;
85 krisbash 1.1
86 typedef struct _CIM_Error_ConstArrayRef
87 {
88 CIM_Error_ConstArray value;
89 MI_Boolean exists;
90 MI_Uint8 flags;
91 }
92 CIM_Error_ConstArrayRef;
93
94 MI_EXTERN_C MI_CONST MI_ClassDecl CIM_Error_rtti;
95
96 MI_INLINE MI_Result MI_CALL CIM_Error_Clone(
97 _In_ const CIM_Error* self,
98 _Outptr_ CIM_Error** newInstance)
99 {
100 return MI_Instance_Clone(
101 &self->__instance, (MI_Instance**)newInstance);
102 }
103
104 MI_INLINE MI_Boolean MI_CALL CIM_Error_IsA(
105 _In_ const MI_Instance* self)
106 krisbash 1.1 {
107 MI_Boolean res = MI_FALSE;
108 return MI_Instance_IsA(self, &CIM_Error_rtti, &res) == MI_RESULT_OK && res;
109 }
110
111 MI_INLINE MI_Result MI_CALL CIM_Error_Destruct(_Inout_ CIM_Error* self)
112 {
113 return MI_Instance_Destruct(&self->__instance);
114 }
115
116 MI_INLINE MI_Result MI_CALL CIM_Error_Delete(_Inout_ CIM_Error* self)
117 {
118 return MI_Instance_Delete(&self->__instance);
119 }
120
121 MI_INLINE MI_Result MI_CALL CIM_Error_Set_ErrorType(
122 _Inout_ CIM_Error* self,
123 _In_ MI_Uint16 x)
124 {
125 ((MI_Uint16Field*)&self->ErrorType)->value = x;
126 ((MI_Uint16Field*)&self->ErrorType)->exists = 1;
127 krisbash 1.1 return MI_RESULT_OK;
128 }
129
130 MI_INLINE MI_Result MI_CALL CIM_Error_Clear_ErrorType(
131 _Inout_ CIM_Error* self)
132 {
133 memset((void*)&self->ErrorType, 0, sizeof(self->ErrorType));
134 return MI_RESULT_OK;
135 }
136
137 MI_INLINE MI_Result MI_CALL CIM_Error_Set_OtherErrorType(
138 _Inout_ CIM_Error* self,
139 _In_z_ const MI_Char* str)
140 {
141 return self->__instance.ft->SetElementAt(
142 (MI_Instance*)&self->__instance,
143 1,
144 (MI_Value*)&str,
145 MI_STRING,
146 0);
147 }
148 krisbash 1.1
149 MI_INLINE MI_Result MI_CALL CIM_Error_SetPtr_OtherErrorType(
150 _Inout_ CIM_Error* self,
151 _In_z_ const MI_Char* str)
152 {
153 return self->__instance.ft->SetElementAt(
154 (MI_Instance*)&self->__instance,
155 1,
156 (MI_Value*)&str,
157 MI_STRING,
158 MI_FLAG_BORROW);
159 }
160
161 MI_INLINE MI_Result MI_CALL CIM_Error_Clear_OtherErrorType(
162 _Inout_ CIM_Error* self)
163 {
164 return self->__instance.ft->ClearElementAt(
165 (MI_Instance*)&self->__instance,
166 1);
167 }
168
169 krisbash 1.1 MI_INLINE MI_Result MI_CALL CIM_Error_Set_OwningEntity(
170 _Inout_ CIM_Error* self,
171 _In_z_ const MI_Char* str)
172 {
173 return self->__instance.ft->SetElementAt(
174 (MI_Instance*)&self->__instance,
175 2,
176 (MI_Value*)&str,
177 MI_STRING,
178 0);
179 }
180
181 MI_INLINE MI_Result MI_CALL CIM_Error_SetPtr_OwningEntity(
182 _Inout_ CIM_Error* self,
183 _In_z_ const MI_Char* str)
184 {
185 return self->__instance.ft->SetElementAt(
186 (MI_Instance*)&self->__instance,
187 2,
188 (MI_Value*)&str,
189 MI_STRING,
190 krisbash 1.1 MI_FLAG_BORROW);
191 }
192
193 MI_INLINE MI_Result MI_CALL CIM_Error_Clear_OwningEntity(
194 _Inout_ CIM_Error* self)
195 {
196 return self->__instance.ft->ClearElementAt(
197 (MI_Instance*)&self->__instance,
198 2);
199 }
200
201 MI_INLINE MI_Result MI_CALL CIM_Error_Set_MessageID(
202 _Inout_ CIM_Error* self,
203 _In_z_ const MI_Char* str)
204 {
205 return self->__instance.ft->SetElementAt(
206 (MI_Instance*)&self->__instance,
207 3,
208 (MI_Value*)&str,
209 MI_STRING,
210 0);
211 krisbash 1.1 }
212
213 MI_INLINE MI_Result MI_CALL CIM_Error_SetPtr_MessageID(
214 _Inout_ CIM_Error* self,
215 _In_z_ const MI_Char* str)
216 {
217 return self->__instance.ft->SetElementAt(
218 (MI_Instance*)&self->__instance,
219 3,
220 (MI_Value*)&str,
221 MI_STRING,
222 MI_FLAG_BORROW);
223 }
224
225 MI_INLINE MI_Result MI_CALL CIM_Error_Clear_MessageID(
226 _Inout_ CIM_Error* self)
227 {
228 return self->__instance.ft->ClearElementAt(
229 (MI_Instance*)&self->__instance,
230 3);
231 }
232 krisbash 1.1
233 MI_INLINE MI_Result MI_CALL CIM_Error_Set_Message(
234 _Inout_ CIM_Error* self,
235 _In_z_ const MI_Char* str)
236 {
237 return self->__instance.ft->SetElementAt(
238 (MI_Instance*)&self->__instance,
239 4,
240 (MI_Value*)&str,
241 MI_STRING,
242 0);
243 }
244
245 MI_INLINE MI_Result MI_CALL CIM_Error_SetPtr_Message(
246 _Inout_ CIM_Error* self,
247 _In_z_ const MI_Char* str)
248 {
249 return self->__instance.ft->SetElementAt(
250 (MI_Instance*)&self->__instance,
251 4,
252 (MI_Value*)&str,
253 krisbash 1.1 MI_STRING,
254 MI_FLAG_BORROW);
255 }
256
257 MI_INLINE MI_Result MI_CALL CIM_Error_Clear_Message(
258 _Inout_ CIM_Error* self)
259 {
260 return self->__instance.ft->ClearElementAt(
261 (MI_Instance*)&self->__instance,
262 4);
263 }
264
265 MI_INLINE MI_Result MI_CALL CIM_Error_Set_MessageArguments(
266 _Inout_ CIM_Error* self,
267 _In_reads_opt_(size) const MI_Char** data,
268 _In_ MI_Uint32 size)
269 {
270 MI_Array arr;
271 arr.data = (void*)data;
272 arr.size = size;
273 return self->__instance.ft->SetElementAt(
274 krisbash 1.1 (MI_Instance*)&self->__instance,
275 5,
276 (MI_Value*)&arr,
277 MI_STRINGA,
278 0);
279 }
280
281 MI_INLINE MI_Result MI_CALL CIM_Error_SetPtr_MessageArguments(
282 _Inout_ CIM_Error* self,
283 _In_reads_opt_(size) const MI_Char** data,
284 _In_ MI_Uint32 size)
285 {
286 MI_Array arr;
287 arr.data = (void*)data;
288 arr.size = size;
289 return self->__instance.ft->SetElementAt(
290 (MI_Instance*)&self->__instance,
291 5,
292 (MI_Value*)&arr,
293 MI_STRINGA,
294 MI_FLAG_BORROW);
295 krisbash 1.1 }
296
297 MI_INLINE MI_Result MI_CALL CIM_Error_Clear_MessageArguments(
298 _Inout_ CIM_Error* self)
299 {
300 return self->__instance.ft->ClearElementAt(
301 (MI_Instance*)&self->__instance,
302 5);
303 }
304
305 MI_INLINE MI_Result MI_CALL CIM_Error_Set_PerceivedSeverity(
306 _Inout_ CIM_Error* self,
307 _In_ MI_Uint16 x)
308 {
309 ((MI_Uint16Field*)&self->PerceivedSeverity)->value = x;
310 ((MI_Uint16Field*)&self->PerceivedSeverity)->exists = 1;
311 return MI_RESULT_OK;
312 }
313
314 MI_INLINE MI_Result MI_CALL CIM_Error_Clear_PerceivedSeverity(
315 _Inout_ CIM_Error* self)
316 krisbash 1.1 {
317 memset((void*)&self->PerceivedSeverity, 0, sizeof(self->PerceivedSeverity));
318 return MI_RESULT_OK;
319 }
320
321 MI_INLINE MI_Result MI_CALL CIM_Error_Set_ProbableCause(
322 _Inout_ CIM_Error* self,
323 _In_ MI_Uint16 x)
324 {
325 ((MI_Uint16Field*)&self->ProbableCause)->value = x;
326 ((MI_Uint16Field*)&self->ProbableCause)->exists = 1;
327 return MI_RESULT_OK;
328 }
329
330 MI_INLINE MI_Result MI_CALL CIM_Error_Clear_ProbableCause(
331 _Inout_ CIM_Error* self)
332 {
333 memset((void*)&self->ProbableCause, 0, sizeof(self->ProbableCause));
334 return MI_RESULT_OK;
335 }
336
337 krisbash 1.1 MI_INLINE MI_Result MI_CALL CIM_Error_Set_ProbableCauseDescription(
338 _Inout_ CIM_Error* self,
339 _In_z_ const MI_Char* str)
340 {
341 return self->__instance.ft->SetElementAt(
342 (MI_Instance*)&self->__instance,
343 8,
344 (MI_Value*)&str,
345 MI_STRING,
346 0);
347 }
348
349 MI_INLINE MI_Result MI_CALL CIM_Error_SetPtr_ProbableCauseDescription(
350 _Inout_ CIM_Error* self,
351 _In_z_ const MI_Char* str)
352 {
353 return self->__instance.ft->SetElementAt(
354 (MI_Instance*)&self->__instance,
355 8,
356 (MI_Value*)&str,
357 MI_STRING,
358 krisbash 1.1 MI_FLAG_BORROW);
359 }
360
361 MI_INLINE MI_Result MI_CALL CIM_Error_Clear_ProbableCauseDescription(
362 _Inout_ CIM_Error* self)
363 {
364 return self->__instance.ft->ClearElementAt(
365 (MI_Instance*)&self->__instance,
366 8);
367 }
368
369 MI_INLINE MI_Result MI_CALL CIM_Error_Set_RecommendedActions(
370 _Inout_ CIM_Error* self,
371 _In_reads_opt_(size) const MI_Char** data,
372 _In_ MI_Uint32 size)
373 {
374 MI_Array arr;
375 arr.data = (void*)data;
376 arr.size = size;
377 return self->__instance.ft->SetElementAt(
378 (MI_Instance*)&self->__instance,
379 krisbash 1.1 9,
380 (MI_Value*)&arr,
381 MI_STRINGA,
382 0);
383 }
384
385 MI_INLINE MI_Result MI_CALL CIM_Error_SetPtr_RecommendedActions(
386 _Inout_ CIM_Error* self,
387 _In_reads_opt_(size) const MI_Char** data,
388 _In_ MI_Uint32 size)
389 {
390 MI_Array arr;
391 arr.data = (void*)data;
392 arr.size = size;
393 return self->__instance.ft->SetElementAt(
394 (MI_Instance*)&self->__instance,
395 9,
396 (MI_Value*)&arr,
397 MI_STRINGA,
398 MI_FLAG_BORROW);
399 }
400 krisbash 1.1
401 MI_INLINE MI_Result MI_CALL CIM_Error_Clear_RecommendedActions(
402 _Inout_ CIM_Error* self)
403 {
404 return self->__instance.ft->ClearElementAt(
405 (MI_Instance*)&self->__instance,
406 9);
407 }
408
409 MI_INLINE MI_Result MI_CALL CIM_Error_Set_ErrorSource(
410 _Inout_ CIM_Error* self,
411 _In_z_ const MI_Char* str)
412 {
413 return self->__instance.ft->SetElementAt(
414 (MI_Instance*)&self->__instance,
415 10,
416 (MI_Value*)&str,
417 MI_STRING,
418 0);
419 }
420
421 krisbash 1.1 MI_INLINE MI_Result MI_CALL CIM_Error_SetPtr_ErrorSource(
422 _Inout_ CIM_Error* self,
423 _In_z_ const MI_Char* str)
424 {
425 return self->__instance.ft->SetElementAt(
426 (MI_Instance*)&self->__instance,
427 10,
428 (MI_Value*)&str,
429 MI_STRING,
430 MI_FLAG_BORROW);
431 }
432
433 MI_INLINE MI_Result MI_CALL CIM_Error_Clear_ErrorSource(
434 _Inout_ CIM_Error* self)
435 {
436 return self->__instance.ft->ClearElementAt(
437 (MI_Instance*)&self->__instance,
438 10);
439 }
440
441 MI_INLINE MI_Result MI_CALL CIM_Error_Set_ErrorSourceFormat(
442 krisbash 1.1 _Inout_ CIM_Error* self,
443 _In_ MI_Uint16 x)
444 {
445 ((MI_Uint16Field*)&self->ErrorSourceFormat)->value = x;
446 ((MI_Uint16Field*)&self->ErrorSourceFormat)->exists = 1;
447 return MI_RESULT_OK;
448 }
449
450 MI_INLINE MI_Result MI_CALL CIM_Error_Clear_ErrorSourceFormat(
451 _Inout_ CIM_Error* self)
452 {
453 memset((void*)&self->ErrorSourceFormat, 0, sizeof(self->ErrorSourceFormat));
454 return MI_RESULT_OK;
455 }
456
457 MI_INLINE MI_Result MI_CALL CIM_Error_Set_OtherErrorSourceFormat(
458 _Inout_ CIM_Error* self,
459 _In_z_ const MI_Char* str)
460 {
461 return self->__instance.ft->SetElementAt(
462 (MI_Instance*)&self->__instance,
463 krisbash 1.1 12,
464 (MI_Value*)&str,
465 MI_STRING,
466 0);
467 }
468
469 MI_INLINE MI_Result MI_CALL CIM_Error_SetPtr_OtherErrorSourceFormat(
470 _Inout_ CIM_Error* self,
471 _In_z_ const MI_Char* str)
472 {
473 return self->__instance.ft->SetElementAt(
474 (MI_Instance*)&self->__instance,
475 12,
476 (MI_Value*)&str,
477 MI_STRING,
478 MI_FLAG_BORROW);
479 }
480
481 MI_INLINE MI_Result MI_CALL CIM_Error_Clear_OtherErrorSourceFormat(
482 _Inout_ CIM_Error* self)
483 {
484 krisbash 1.1 return self->__instance.ft->ClearElementAt(
485 (MI_Instance*)&self->__instance,
486 12);
487 }
488
489 MI_INLINE MI_Result MI_CALL CIM_Error_Set_CIMStatusCode(
490 _Inout_ CIM_Error* self,
491 _In_ MI_Uint32 x)
492 {
493 ((MI_Uint32Field*)&self->CIMStatusCode)->value = x;
494 ((MI_Uint32Field*)&self->CIMStatusCode)->exists = 1;
495 return MI_RESULT_OK;
496 }
497
498 MI_INLINE MI_Result MI_CALL CIM_Error_Clear_CIMStatusCode(
499 _Inout_ CIM_Error* self)
500 {
501 memset((void*)&self->CIMStatusCode, 0, sizeof(self->CIMStatusCode));
502 return MI_RESULT_OK;
503 }
504
505 krisbash 1.1 MI_INLINE MI_Result MI_CALL CIM_Error_Set_CIMStatusCodeDescription(
506 _Inout_ CIM_Error* self,
507 _In_z_ const MI_Char* str)
508 {
509 return self->__instance.ft->SetElementAt(
510 (MI_Instance*)&self->__instance,
511 14,
512 (MI_Value*)&str,
513 MI_STRING,
514 0);
515 }
516
517 MI_INLINE MI_Result MI_CALL CIM_Error_SetPtr_CIMStatusCodeDescription(
518 _Inout_ CIM_Error* self,
519 _In_z_ const MI_Char* str)
520 {
521 return self->__instance.ft->SetElementAt(
522 (MI_Instance*)&self->__instance,
523 14,
524 (MI_Value*)&str,
525 MI_STRING,
526 krisbash 1.1 MI_FLAG_BORROW);
527 }
528
529 MI_INLINE MI_Result MI_CALL CIM_Error_Clear_CIMStatusCodeDescription(
530 _Inout_ CIM_Error* self)
531 {
532 return self->__instance.ft->ClearElementAt(
533 (MI_Instance*)&self->__instance,
534 14);
535 }
536
537 #endif /*_CIM_Error_h*/
|