1 krisbash 1.1 /* @migen@ */
2 /*
3 **==============================================================================
4 **
5 ** WARNING: THIS FILE WAS AUTOMATICALLY GENERATED. PLEASE DO NOT EDIT.
6 **
7 **==============================================================================
8 */
9 #ifndef _OMI_DebugError_h
10 #define _OMI_DebugError_h
11
12 #include <MI.h>
13 #include "OMI_Error.h"
14
15 /*
16 **==============================================================================
17 **
18 ** OMI_DebugError [OMI_DebugError]
19 **
20 ** Keys:
21 **
22 krisbash 1.1 **==============================================================================
23 */
24
25 typedef struct _OMI_DebugError /* extends OMI_Error */
26 {
27 MI_Instance __instance;
28 /* CIM_Error properties */
29 MI_ConstUint16Field ErrorType;
30 MI_ConstStringField OtherErrorType;
31 MI_ConstStringField OwningEntity;
32 MI_ConstStringField MessageID;
33 MI_ConstStringField Message;
34 MI_ConstStringAField MessageArguments;
35 MI_ConstUint16Field PerceivedSeverity;
36 MI_ConstUint16Field ProbableCause;
37 MI_ConstStringField ProbableCauseDescription;
38 MI_ConstStringAField RecommendedActions;
39 MI_ConstStringField ErrorSource;
40 MI_ConstUint16Field ErrorSourceFormat;
41 MI_ConstStringField OtherErrorSourceFormat;
42 MI_ConstUint32Field CIMStatusCode;
43 krisbash 1.1 MI_ConstStringField CIMStatusCodeDescription;
44 /* OMI_Error properties */
45 MI_ConstUint32Field error_Code;
46 MI_ConstStringField error_Type;
47 MI_ConstUint16Field error_Category;
48 /* OMI_DebugError properties */
49 MI_ConstStringAField OMI_BackTrace;
50 MI_ConstReferenceField inner_Error;
51 }
52 OMI_DebugError;
53
54 typedef struct _OMI_DebugError_Ref
55 {
56 OMI_DebugError* value;
57 MI_Boolean exists;
58 MI_Uint8 flags;
59 }
60 OMI_DebugError_Ref;
61
62 typedef struct _OMI_DebugError_ConstRef
63 {
64 krisbash 1.1 MI_CONST OMI_DebugError* value;
65 MI_Boolean exists;
66 MI_Uint8 flags;
67 }
68 OMI_DebugError_ConstRef;
69
70 typedef struct _OMI_DebugError_Array
71 {
72 struct _OMI_DebugError** data;
73 MI_Uint32 size;
74 }
75 OMI_DebugError_Array;
76
77 typedef struct _OMI_DebugError_ConstArray
78 {
79 struct _OMI_DebugError MI_CONST* MI_CONST* data;
80 MI_Uint32 size;
81 }
82 OMI_DebugError_ConstArray;
83
84 typedef struct _OMI_DebugError_ArrayRef
85 krisbash 1.1 {
86 OMI_DebugError_Array value;
87 MI_Boolean exists;
88 MI_Uint8 flags;
89 }
90 OMI_DebugError_ArrayRef;
91
92 typedef struct _OMI_DebugError_ConstArrayRef
93 {
94 OMI_DebugError_ConstArray value;
95 MI_Boolean exists;
96 MI_Uint8 flags;
97 }
98 OMI_DebugError_ConstArrayRef;
99
100 MI_EXTERN_C MI_CONST MI_ClassDecl OMI_DebugError_rtti;
101
102 MI_INLINE MI_Result MI_CALL OMI_DebugError_Clone(
103 _In_ const OMI_DebugError* self,
104 _Outptr_ OMI_DebugError** newInstance)
105 {
106 krisbash 1.1 return MI_Instance_Clone(
107 &self->__instance, (MI_Instance**)newInstance);
108 }
109
110 MI_INLINE MI_Boolean MI_CALL OMI_DebugError_IsA(
111 _In_ const MI_Instance* self)
112 {
113 MI_Boolean res = MI_FALSE;
114 return MI_Instance_IsA(self, &OMI_DebugError_rtti, &res) == MI_RESULT_OK && res;
115 }
116
117 MI_INLINE MI_Result MI_CALL OMI_DebugError_Destruct(_Inout_ OMI_DebugError* self)
118 {
119 return MI_Instance_Destruct(&self->__instance);
120 }
121
122 MI_INLINE MI_Result MI_CALL OMI_DebugError_Delete(_Inout_ OMI_DebugError* self)
123 {
124 return MI_Instance_Delete(&self->__instance);
125 }
126
127 krisbash 1.1 MI_INLINE MI_Result MI_CALL OMI_DebugError_Set_ErrorType(
128 _Inout_ OMI_DebugError* self,
129 _In_ MI_Uint16 x)
130 {
131 ((MI_Uint16Field*)&self->ErrorType)->value = x;
132 ((MI_Uint16Field*)&self->ErrorType)->exists = 1;
133 return MI_RESULT_OK;
134 }
135
136 MI_INLINE MI_Result MI_CALL OMI_DebugError_Clear_ErrorType(
137 _Inout_ OMI_DebugError* self)
138 {
139 memset((void*)&self->ErrorType, 0, sizeof(self->ErrorType));
140 return MI_RESULT_OK;
141 }
142
143 MI_INLINE MI_Result MI_CALL OMI_DebugError_Set_OtherErrorType(
144 _Inout_ OMI_DebugError* self,
145 _In_z_ const MI_Char* str)
146 {
147 return self->__instance.ft->SetElementAt(
148 krisbash 1.1 (MI_Instance*)&self->__instance,
149 1,
150 (MI_Value*)&str,
151 MI_STRING,
152 0);
153 }
154
155 MI_INLINE MI_Result MI_CALL OMI_DebugError_SetPtr_OtherErrorType(
156 _Inout_ OMI_DebugError* self,
157 _In_z_ const MI_Char* str)
158 {
159 return self->__instance.ft->SetElementAt(
160 (MI_Instance*)&self->__instance,
161 1,
162 (MI_Value*)&str,
163 MI_STRING,
164 MI_FLAG_BORROW);
165 }
166
167 MI_INLINE MI_Result MI_CALL OMI_DebugError_Clear_OtherErrorType(
168 _Inout_ OMI_DebugError* self)
169 krisbash 1.1 {
170 return self->__instance.ft->ClearElementAt(
171 (MI_Instance*)&self->__instance,
172 1);
173 }
174
175 MI_INLINE MI_Result MI_CALL OMI_DebugError_Set_OwningEntity(
176 _Inout_ OMI_DebugError* self,
177 _In_z_ const MI_Char* str)
178 {
179 return self->__instance.ft->SetElementAt(
180 (MI_Instance*)&self->__instance,
181 2,
182 (MI_Value*)&str,
183 MI_STRING,
184 0);
185 }
186
187 MI_INLINE MI_Result MI_CALL OMI_DebugError_SetPtr_OwningEntity(
188 _Inout_ OMI_DebugError* self,
189 _In_z_ const MI_Char* str)
190 krisbash 1.1 {
191 return self->__instance.ft->SetElementAt(
192 (MI_Instance*)&self->__instance,
193 2,
194 (MI_Value*)&str,
195 MI_STRING,
196 MI_FLAG_BORROW);
197 }
198
199 MI_INLINE MI_Result MI_CALL OMI_DebugError_Clear_OwningEntity(
200 _Inout_ OMI_DebugError* self)
201 {
202 return self->__instance.ft->ClearElementAt(
203 (MI_Instance*)&self->__instance,
204 2);
205 }
206
207 MI_INLINE MI_Result MI_CALL OMI_DebugError_Set_MessageID(
208 _Inout_ OMI_DebugError* self,
209 _In_z_ const MI_Char* str)
210 {
211 krisbash 1.1 return self->__instance.ft->SetElementAt(
212 (MI_Instance*)&self->__instance,
213 3,
214 (MI_Value*)&str,
215 MI_STRING,
216 0);
217 }
218
219 MI_INLINE MI_Result MI_CALL OMI_DebugError_SetPtr_MessageID(
220 _Inout_ OMI_DebugError* self,
221 _In_z_ const MI_Char* str)
222 {
223 return self->__instance.ft->SetElementAt(
224 (MI_Instance*)&self->__instance,
225 3,
226 (MI_Value*)&str,
227 MI_STRING,
228 MI_FLAG_BORROW);
229 }
230
231 MI_INLINE MI_Result MI_CALL OMI_DebugError_Clear_MessageID(
232 krisbash 1.1 _Inout_ OMI_DebugError* self)
233 {
234 return self->__instance.ft->ClearElementAt(
235 (MI_Instance*)&self->__instance,
236 3);
237 }
238
239 MI_INLINE MI_Result MI_CALL OMI_DebugError_Set_Message(
240 _Inout_ OMI_DebugError* self,
241 _In_z_ const MI_Char* str)
242 {
243 return self->__instance.ft->SetElementAt(
244 (MI_Instance*)&self->__instance,
245 4,
246 (MI_Value*)&str,
247 MI_STRING,
248 0);
249 }
250
251 MI_INLINE MI_Result MI_CALL OMI_DebugError_SetPtr_Message(
252 _Inout_ OMI_DebugError* self,
253 krisbash 1.1 _In_z_ const MI_Char* str)
254 {
255 return self->__instance.ft->SetElementAt(
256 (MI_Instance*)&self->__instance,
257 4,
258 (MI_Value*)&str,
259 MI_STRING,
260 MI_FLAG_BORROW);
261 }
262
263 MI_INLINE MI_Result MI_CALL OMI_DebugError_Clear_Message(
264 _Inout_ OMI_DebugError* self)
265 {
266 return self->__instance.ft->ClearElementAt(
267 (MI_Instance*)&self->__instance,
268 4);
269 }
270
271 MI_INLINE MI_Result MI_CALL OMI_DebugError_Set_MessageArguments(
272 _Inout_ OMI_DebugError* self,
273 _In_reads_opt_(size) const MI_Char** data,
274 krisbash 1.1 _In_ MI_Uint32 size)
275 {
276 MI_Array arr;
277 arr.data = (void*)data;
278 arr.size = size;
279 return self->__instance.ft->SetElementAt(
280 (MI_Instance*)&self->__instance,
281 5,
282 (MI_Value*)&arr,
283 MI_STRINGA,
284 0);
285 }
286
287 MI_INLINE MI_Result MI_CALL OMI_DebugError_SetPtr_MessageArguments(
288 _Inout_ OMI_DebugError* self,
289 _In_reads_opt_(size) const MI_Char** data,
290 _In_ MI_Uint32 size)
291 {
292 MI_Array arr;
293 arr.data = (void*)data;
294 arr.size = size;
295 krisbash 1.1 return self->__instance.ft->SetElementAt(
296 (MI_Instance*)&self->__instance,
297 5,
298 (MI_Value*)&arr,
299 MI_STRINGA,
300 MI_FLAG_BORROW);
301 }
302
303 MI_INLINE MI_Result MI_CALL OMI_DebugError_Clear_MessageArguments(
304 _Inout_ OMI_DebugError* self)
305 {
306 return self->__instance.ft->ClearElementAt(
307 (MI_Instance*)&self->__instance,
308 5);
309 }
310
311 MI_INLINE MI_Result MI_CALL OMI_DebugError_Set_PerceivedSeverity(
312 _Inout_ OMI_DebugError* self,
313 _In_ MI_Uint16 x)
314 {
315 ((MI_Uint16Field*)&self->PerceivedSeverity)->value = x;
316 krisbash 1.1 ((MI_Uint16Field*)&self->PerceivedSeverity)->exists = 1;
317 return MI_RESULT_OK;
318 }
319
320 MI_INLINE MI_Result MI_CALL OMI_DebugError_Clear_PerceivedSeverity(
321 _Inout_ OMI_DebugError* self)
322 {
323 memset((void*)&self->PerceivedSeverity, 0, sizeof(self->PerceivedSeverity));
324 return MI_RESULT_OK;
325 }
326
327 MI_INLINE MI_Result MI_CALL OMI_DebugError_Set_ProbableCause(
328 _Inout_ OMI_DebugError* self,
329 _In_ MI_Uint16 x)
330 {
331 ((MI_Uint16Field*)&self->ProbableCause)->value = x;
332 ((MI_Uint16Field*)&self->ProbableCause)->exists = 1;
333 return MI_RESULT_OK;
334 }
335
336 MI_INLINE MI_Result MI_CALL OMI_DebugError_Clear_ProbableCause(
337 krisbash 1.1 _Inout_ OMI_DebugError* self)
338 {
339 memset((void*)&self->ProbableCause, 0, sizeof(self->ProbableCause));
340 return MI_RESULT_OK;
341 }
342
343 MI_INLINE MI_Result MI_CALL OMI_DebugError_Set_ProbableCauseDescription(
344 _Inout_ OMI_DebugError* self,
345 _In_z_ const MI_Char* str)
346 {
347 return self->__instance.ft->SetElementAt(
348 (MI_Instance*)&self->__instance,
349 8,
350 (MI_Value*)&str,
351 MI_STRING,
352 0);
353 }
354
355 MI_INLINE MI_Result MI_CALL OMI_DebugError_SetPtr_ProbableCauseDescription(
356 _Inout_ OMI_DebugError* self,
357 _In_z_ const MI_Char* str)
358 krisbash 1.1 {
359 return self->__instance.ft->SetElementAt(
360 (MI_Instance*)&self->__instance,
361 8,
362 (MI_Value*)&str,
363 MI_STRING,
364 MI_FLAG_BORROW);
365 }
366
367 MI_INLINE MI_Result MI_CALL OMI_DebugError_Clear_ProbableCauseDescription(
368 _Inout_ OMI_DebugError* self)
369 {
370 return self->__instance.ft->ClearElementAt(
371 (MI_Instance*)&self->__instance,
372 8);
373 }
374
375 MI_INLINE MI_Result MI_CALL OMI_DebugError_Set_RecommendedActions(
376 _Inout_ OMI_DebugError* self,
377 _In_reads_opt_(size) const MI_Char** data,
378 _In_ MI_Uint32 size)
379 krisbash 1.1 {
380 MI_Array arr;
381 arr.data = (void*)data;
382 arr.size = size;
383 return self->__instance.ft->SetElementAt(
384 (MI_Instance*)&self->__instance,
385 9,
386 (MI_Value*)&arr,
387 MI_STRINGA,
388 0);
389 }
390
391 MI_INLINE MI_Result MI_CALL OMI_DebugError_SetPtr_RecommendedActions(
392 _Inout_ OMI_DebugError* self,
393 _In_reads_opt_(size) const MI_Char** data,
394 _In_ MI_Uint32 size)
395 {
396 MI_Array arr;
397 arr.data = (void*)data;
398 arr.size = size;
399 return self->__instance.ft->SetElementAt(
400 krisbash 1.1 (MI_Instance*)&self->__instance,
401 9,
402 (MI_Value*)&arr,
403 MI_STRINGA,
404 MI_FLAG_BORROW);
405 }
406
407 MI_INLINE MI_Result MI_CALL OMI_DebugError_Clear_RecommendedActions(
408 _Inout_ OMI_DebugError* self)
409 {
410 return self->__instance.ft->ClearElementAt(
411 (MI_Instance*)&self->__instance,
412 9);
413 }
414
415 MI_INLINE MI_Result MI_CALL OMI_DebugError_Set_ErrorSource(
416 _Inout_ OMI_DebugError* self,
417 _In_z_ const MI_Char* str)
418 {
419 return self->__instance.ft->SetElementAt(
420 (MI_Instance*)&self->__instance,
421 krisbash 1.1 10,
422 (MI_Value*)&str,
423 MI_STRING,
424 0);
425 }
426
427 MI_INLINE MI_Result MI_CALL OMI_DebugError_SetPtr_ErrorSource(
428 _Inout_ OMI_DebugError* self,
429 _In_z_ const MI_Char* str)
430 {
431 return self->__instance.ft->SetElementAt(
432 (MI_Instance*)&self->__instance,
433 10,
434 (MI_Value*)&str,
435 MI_STRING,
436 MI_FLAG_BORROW);
437 }
438
439 MI_INLINE MI_Result MI_CALL OMI_DebugError_Clear_ErrorSource(
440 _Inout_ OMI_DebugError* self)
441 {
442 krisbash 1.1 return self->__instance.ft->ClearElementAt(
443 (MI_Instance*)&self->__instance,
444 10);
445 }
446
447 MI_INLINE MI_Result MI_CALL OMI_DebugError_Set_ErrorSourceFormat(
448 _Inout_ OMI_DebugError* self,
449 _In_ MI_Uint16 x)
450 {
451 ((MI_Uint16Field*)&self->ErrorSourceFormat)->value = x;
452 ((MI_Uint16Field*)&self->ErrorSourceFormat)->exists = 1;
453 return MI_RESULT_OK;
454 }
455
456 MI_INLINE MI_Result MI_CALL OMI_DebugError_Clear_ErrorSourceFormat(
457 _Inout_ OMI_DebugError* self)
458 {
459 memset((void*)&self->ErrorSourceFormat, 0, sizeof(self->ErrorSourceFormat));
460 return MI_RESULT_OK;
461 }
462
463 krisbash 1.1 MI_INLINE MI_Result MI_CALL OMI_DebugError_Set_OtherErrorSourceFormat(
464 _Inout_ OMI_DebugError* self,
465 _In_z_ const MI_Char* str)
466 {
467 return self->__instance.ft->SetElementAt(
468 (MI_Instance*)&self->__instance,
469 12,
470 (MI_Value*)&str,
471 MI_STRING,
472 0);
473 }
474
475 MI_INLINE MI_Result MI_CALL OMI_DebugError_SetPtr_OtherErrorSourceFormat(
476 _Inout_ OMI_DebugError* self,
477 _In_z_ const MI_Char* str)
478 {
479 return self->__instance.ft->SetElementAt(
480 (MI_Instance*)&self->__instance,
481 12,
482 (MI_Value*)&str,
483 MI_STRING,
484 krisbash 1.1 MI_FLAG_BORROW);
485 }
486
487 MI_INLINE MI_Result MI_CALL OMI_DebugError_Clear_OtherErrorSourceFormat(
488 _Inout_ OMI_DebugError* self)
489 {
490 return self->__instance.ft->ClearElementAt(
491 (MI_Instance*)&self->__instance,
492 12);
493 }
494
495 MI_INLINE MI_Result MI_CALL OMI_DebugError_Set_CIMStatusCode(
496 _Inout_ OMI_DebugError* self,
497 _In_ MI_Uint32 x)
498 {
499 ((MI_Uint32Field*)&self->CIMStatusCode)->value = x;
500 ((MI_Uint32Field*)&self->CIMStatusCode)->exists = 1;
501 return MI_RESULT_OK;
502 }
503
504 MI_INLINE MI_Result MI_CALL OMI_DebugError_Clear_CIMStatusCode(
505 krisbash 1.1 _Inout_ OMI_DebugError* self)
506 {
507 memset((void*)&self->CIMStatusCode, 0, sizeof(self->CIMStatusCode));
508 return MI_RESULT_OK;
509 }
510
511 MI_INLINE MI_Result MI_CALL OMI_DebugError_Set_CIMStatusCodeDescription(
512 _Inout_ OMI_DebugError* self,
513 _In_z_ const MI_Char* str)
514 {
515 return self->__instance.ft->SetElementAt(
516 (MI_Instance*)&self->__instance,
517 14,
518 (MI_Value*)&str,
519 MI_STRING,
520 0);
521 }
522
523 MI_INLINE MI_Result MI_CALL OMI_DebugError_SetPtr_CIMStatusCodeDescription(
524 _Inout_ OMI_DebugError* self,
525 _In_z_ const MI_Char* str)
526 krisbash 1.1 {
527 return self->__instance.ft->SetElementAt(
528 (MI_Instance*)&self->__instance,
529 14,
530 (MI_Value*)&str,
531 MI_STRING,
532 MI_FLAG_BORROW);
533 }
534
535 MI_INLINE MI_Result MI_CALL OMI_DebugError_Clear_CIMStatusCodeDescription(
536 _Inout_ OMI_DebugError* self)
537 {
538 return self->__instance.ft->ClearElementAt(
539 (MI_Instance*)&self->__instance,
540 14);
541 }
542
543 MI_INLINE MI_Result MI_CALL OMI_DebugError_Set_error_Code(
544 _Inout_ OMI_DebugError* self,
545 _In_ MI_Uint32 x)
546 {
547 krisbash 1.1 ((MI_Uint32Field*)&self->error_Code)->value = x;
548 ((MI_Uint32Field*)&self->error_Code)->exists = 1;
549 return MI_RESULT_OK;
550 }
551
552 MI_INLINE MI_Result MI_CALL OMI_DebugError_Clear_error_Code(
553 _Inout_ OMI_DebugError* self)
554 {
555 memset((void*)&self->error_Code, 0, sizeof(self->error_Code));
556 return MI_RESULT_OK;
557 }
558
559 MI_INLINE MI_Result MI_CALL OMI_DebugError_Set_error_Type(
560 _Inout_ OMI_DebugError* self,
561 _In_z_ const MI_Char* str)
562 {
563 return self->__instance.ft->SetElementAt(
564 (MI_Instance*)&self->__instance,
565 16,
566 (MI_Value*)&str,
567 MI_STRING,
568 krisbash 1.1 0);
569 }
570
571 MI_INLINE MI_Result MI_CALL OMI_DebugError_SetPtr_error_Type(
572 _Inout_ OMI_DebugError* self,
573 _In_z_ const MI_Char* str)
574 {
575 return self->__instance.ft->SetElementAt(
576 (MI_Instance*)&self->__instance,
577 16,
578 (MI_Value*)&str,
579 MI_STRING,
580 MI_FLAG_BORROW);
581 }
582
583 MI_INLINE MI_Result MI_CALL OMI_DebugError_Clear_error_Type(
584 _Inout_ OMI_DebugError* self)
585 {
586 return self->__instance.ft->ClearElementAt(
587 (MI_Instance*)&self->__instance,
588 16);
589 krisbash 1.1 }
590
591 MI_INLINE MI_Result MI_CALL OMI_DebugError_Set_error_Category(
592 _Inout_ OMI_DebugError* self,
593 _In_ MI_Uint16 x)
594 {
595 ((MI_Uint16Field*)&self->error_Category)->value = x;
596 ((MI_Uint16Field*)&self->error_Category)->exists = 1;
597 return MI_RESULT_OK;
598 }
599
600 MI_INLINE MI_Result MI_CALL OMI_DebugError_Clear_error_Category(
601 _Inout_ OMI_DebugError* self)
602 {
603 memset((void*)&self->error_Category, 0, sizeof(self->error_Category));
604 return MI_RESULT_OK;
605 }
606
607 MI_INLINE MI_Result MI_CALL OMI_DebugError_Set_OMI_BackTrace(
608 _Inout_ OMI_DebugError* self,
609 _In_reads_opt_(size) const MI_Char** data,
610 krisbash 1.1 _In_ MI_Uint32 size)
611 {
612 MI_Array arr;
613 arr.data = (void*)data;
614 arr.size = size;
615 return self->__instance.ft->SetElementAt(
616 (MI_Instance*)&self->__instance,
617 18,
618 (MI_Value*)&arr,
619 MI_STRINGA,
620 0);
621 }
622
623 MI_INLINE MI_Result MI_CALL OMI_DebugError_SetPtr_OMI_BackTrace(
624 _Inout_ OMI_DebugError* self,
625 _In_reads_opt_(size) const MI_Char** data,
626 _In_ MI_Uint32 size)
627 {
628 MI_Array arr;
629 arr.data = (void*)data;
630 arr.size = size;
631 krisbash 1.1 return self->__instance.ft->SetElementAt(
632 (MI_Instance*)&self->__instance,
633 18,
634 (MI_Value*)&arr,
635 MI_STRINGA,
636 MI_FLAG_BORROW);
637 }
638
639 MI_INLINE MI_Result MI_CALL OMI_DebugError_Clear_OMI_BackTrace(
640 _Inout_ OMI_DebugError* self)
641 {
642 return self->__instance.ft->ClearElementAt(
643 (MI_Instance*)&self->__instance,
644 18);
645 }
646
647 MI_INLINE MI_Result MI_CALL OMI_DebugError_Set_inner_Error(
648 _Inout_ OMI_DebugError* self,
649 _In_ const MI_Instance* x)
650 {
651 return self->__instance.ft->SetElementAt(
652 krisbash 1.1 (MI_Instance*)&self->__instance,
653 19,
654 (MI_Value*)&x,
655 MI_INSTANCE,
656 0);
657 }
658
659 MI_INLINE MI_Result MI_CALL OMI_DebugError_SetPtr_inner_Error(
660 _Inout_ OMI_DebugError* self,
661 _In_ const MI_Instance* x)
662 {
663 return self->__instance.ft->SetElementAt(
664 (MI_Instance*)&self->__instance,
665 19,
666 (MI_Value*)&x,
667 MI_INSTANCE,
668 MI_FLAG_BORROW);
669 }
670
671 MI_INLINE MI_Result MI_CALL OMI_DebugError_Clear_inner_Error(
672 _Inout_ OMI_DebugError* self)
673 krisbash 1.1 {
674 return self->__instance.ft->ClearElementAt(
675 (MI_Instance*)&self->__instance,
676 19);
677 }
678
679
680 #endif /* _OMI_DebugError_h */
|
Return to
OMI_DebugError.h
CVS log
Up to [OMI] / omi / omiutils