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_Error_h
10 #define _OMI_Error_h
11
12 #include <MI.h>
13 #include "CIM_Error.h"
14
15 /*
16 **==============================================================================
17 **
18 ** OMI_Error [OMI_Error]
19 **
20 ** Keys:
21 **
22 krisbash 1.1 **==============================================================================
23 */
24
25 typedef struct _OMI_Error /* extends CIM_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 OMI_Code;
46 MI_ConstUint16Field OMI_Category;
47 MI_ConstStringField OMI_Type;
48 MI_ConstStringField OMI_ErrorMessage;
49 }
50 OMI_Error;
51
52 typedef struct _OMI_Error_Ref
53 {
54 OMI_Error* value;
55 MI_Boolean exists;
56 MI_Uint8 flags;
57 }
58 OMI_Error_Ref;
59
60 typedef struct _OMI_Error_ConstRef
61 {
62 MI_CONST OMI_Error* value;
63 MI_Boolean exists;
64 krisbash 1.1 MI_Uint8 flags;
65 }
66 OMI_Error_ConstRef;
67
68 typedef struct _OMI_Error_Array
69 {
70 struct _OMI_Error** data;
71 MI_Uint32 size;
72 }
73 OMI_Error_Array;
74
75 typedef struct _OMI_Error_ConstArray
76 {
77 struct _OMI_Error MI_CONST* MI_CONST* data;
78 MI_Uint32 size;
79 }
80 OMI_Error_ConstArray;
81
82 typedef struct _OMI_Error_ArrayRef
83 {
84 OMI_Error_Array value;
85 krisbash 1.1 MI_Boolean exists;
86 MI_Uint8 flags;
87 }
88 OMI_Error_ArrayRef;
89
90 typedef struct _OMI_Error_ConstArrayRef
91 {
92 OMI_Error_ConstArray value;
93 MI_Boolean exists;
94 MI_Uint8 flags;
95 }
96 OMI_Error_ConstArrayRef;
97
98 MI_INLINE MI_Result MI_CALL OMI_Error_Set_ErrorType(
99 OMI_Error* self,
100 MI_Uint16 x)
101 {
102 ((MI_Uint16Field*)&self->ErrorType)->value = x;
103 ((MI_Uint16Field*)&self->ErrorType)->exists = 1;
104 return MI_RESULT_OK;
105 }
106 krisbash 1.1
107 MI_INLINE MI_Result MI_CALL OMI_Error_Clear_ErrorType(
108 OMI_Error* self)
109 {
110 memset((void*)&self->ErrorType, 0, sizeof(self->ErrorType));
111 return MI_RESULT_OK;
112 }
113
114 MI_INLINE MI_Result MI_CALL OMI_Error_Set_OtherErrorType(
115 OMI_Error* self,
116 const MI_Char* str)
117 {
118 return self->__instance.ft->SetElementAt(
119 (MI_Instance*)&self->__instance,
120 1,
121 (MI_Value*)&str,
122 MI_STRING,
123 0);
124 }
125
126 MI_INLINE MI_Result MI_CALL OMI_Error_SetPtr_OtherErrorType(
127 krisbash 1.1 OMI_Error* self,
128 const MI_Char* str)
129 {
130 return self->__instance.ft->SetElementAt(
131 (MI_Instance*)&self->__instance,
132 1,
133 (MI_Value*)&str,
134 MI_STRING,
135 MI_FLAG_BORROW);
136 }
137
138 MI_INLINE MI_Result MI_CALL OMI_Error_Clear_OtherErrorType(
139 OMI_Error* self)
140 {
141 return self->__instance.ft->ClearElementAt(
142 (MI_Instance*)&self->__instance,
143 1);
144 }
145
146 MI_INLINE MI_Result MI_CALL OMI_Error_Set_OwningEntity(
147 OMI_Error* self,
148 krisbash 1.1 const MI_Char* str)
149 {
150 return self->__instance.ft->SetElementAt(
151 (MI_Instance*)&self->__instance,
152 2,
153 (MI_Value*)&str,
154 MI_STRING,
155 0);
156 }
157
158 MI_INLINE MI_Result MI_CALL OMI_Error_SetPtr_OwningEntity(
159 OMI_Error* self,
160 const MI_Char* str)
161 {
162 return self->__instance.ft->SetElementAt(
163 (MI_Instance*)&self->__instance,
164 2,
165 (MI_Value*)&str,
166 MI_STRING,
167 MI_FLAG_BORROW);
168 }
169 krisbash 1.1
170 MI_INLINE MI_Result MI_CALL OMI_Error_Clear_OwningEntity(
171 OMI_Error* self)
172 {
173 return self->__instance.ft->ClearElementAt(
174 (MI_Instance*)&self->__instance,
175 2);
176 }
177
178 MI_INLINE MI_Result MI_CALL OMI_Error_Set_MessageID(
179 OMI_Error* self,
180 const MI_Char* str)
181 {
182 return self->__instance.ft->SetElementAt(
183 (MI_Instance*)&self->__instance,
184 3,
185 (MI_Value*)&str,
186 MI_STRING,
187 0);
188 }
189
190 krisbash 1.1 MI_INLINE MI_Result MI_CALL OMI_Error_SetPtr_MessageID(
191 OMI_Error* self,
192 const MI_Char* str)
193 {
194 return self->__instance.ft->SetElementAt(
195 (MI_Instance*)&self->__instance,
196 3,
197 (MI_Value*)&str,
198 MI_STRING,
199 MI_FLAG_BORROW);
200 }
201
202 MI_INLINE MI_Result MI_CALL OMI_Error_Clear_MessageID(
203 OMI_Error* self)
204 {
205 return self->__instance.ft->ClearElementAt(
206 (MI_Instance*)&self->__instance,
207 3);
208 }
209
210 MI_INLINE MI_Result MI_CALL OMI_Error_Set_Message(
211 krisbash 1.1 OMI_Error* self,
212 const MI_Char* str)
213 {
214 return self->__instance.ft->SetElementAt(
215 (MI_Instance*)&self->__instance,
216 4,
217 (MI_Value*)&str,
218 MI_STRING,
219 0);
220 }
221
222 MI_INLINE MI_Result MI_CALL OMI_Error_SetPtr_Message(
223 OMI_Error* self,
224 const MI_Char* str)
225 {
226 return self->__instance.ft->SetElementAt(
227 (MI_Instance*)&self->__instance,
228 4,
229 (MI_Value*)&str,
230 MI_STRING,
231 MI_FLAG_BORROW);
232 krisbash 1.1 }
233
234 MI_INLINE MI_Result MI_CALL OMI_Error_Clear_Message(
235 OMI_Error* self)
236 {
237 return self->__instance.ft->ClearElementAt(
238 (MI_Instance*)&self->__instance,
239 4);
240 }
241
242 MI_INLINE MI_Result MI_CALL OMI_Error_Set_MessageArguments(
243 OMI_Error* self,
244 const MI_Char** data,
245 MI_Uint32 size)
246 {
247 MI_Array arr;
248 arr.data = (void*)data;
249 arr.size = size;
250 return self->__instance.ft->SetElementAt(
251 (MI_Instance*)&self->__instance,
252 5,
253 krisbash 1.1 (MI_Value*)&arr,
254 MI_STRINGA,
255 0);
256 }
257
258 MI_INLINE MI_Result MI_CALL OMI_Error_SetPtr_MessageArguments(
259 OMI_Error* self,
260 const MI_Char** data,
261 MI_Uint32 size)
262 {
263 MI_Array arr;
264 arr.data = (void*)data;
265 arr.size = size;
266 return self->__instance.ft->SetElementAt(
267 (MI_Instance*)&self->__instance,
268 5,
269 (MI_Value*)&arr,
270 MI_STRINGA,
271 MI_FLAG_BORROW);
272 }
273
274 krisbash 1.1 MI_INLINE MI_Result MI_CALL OMI_Error_Clear_MessageArguments(
275 OMI_Error* self)
276 {
277 return self->__instance.ft->ClearElementAt(
278 (MI_Instance*)&self->__instance,
279 5);
280 }
281
282 MI_INLINE MI_Result MI_CALL OMI_Error_Set_PerceivedSeverity(
283 OMI_Error* self,
284 MI_Uint16 x)
285 {
286 ((MI_Uint16Field*)&self->PerceivedSeverity)->value = x;
287 ((MI_Uint16Field*)&self->PerceivedSeverity)->exists = 1;
288 return MI_RESULT_OK;
289 }
290
291 MI_INLINE MI_Result MI_CALL OMI_Error_Clear_PerceivedSeverity(
292 OMI_Error* self)
293 {
294 memset((void*)&self->PerceivedSeverity, 0, sizeof(self->PerceivedSeverity));
295 krisbash 1.1 return MI_RESULT_OK;
296 }
297
298 MI_INLINE MI_Result MI_CALL OMI_Error_Set_ProbableCause(
299 OMI_Error* self,
300 MI_Uint16 x)
301 {
302 ((MI_Uint16Field*)&self->ProbableCause)->value = x;
303 ((MI_Uint16Field*)&self->ProbableCause)->exists = 1;
304 return MI_RESULT_OK;
305 }
306
307 MI_INLINE MI_Result MI_CALL OMI_Error_Clear_ProbableCause(
308 OMI_Error* self)
309 {
310 memset((void*)&self->ProbableCause, 0, sizeof(self->ProbableCause));
311 return MI_RESULT_OK;
312 }
313
314 MI_INLINE MI_Result MI_CALL OMI_Error_Set_ProbableCauseDescription(
315 OMI_Error* self,
316 krisbash 1.1 const MI_Char* str)
317 {
318 return self->__instance.ft->SetElementAt(
319 (MI_Instance*)&self->__instance,
320 8,
321 (MI_Value*)&str,
322 MI_STRING,
323 0);
324 }
325
326 MI_INLINE MI_Result MI_CALL OMI_Error_SetPtr_ProbableCauseDescription(
327 OMI_Error* self,
328 const MI_Char* str)
329 {
330 return self->__instance.ft->SetElementAt(
331 (MI_Instance*)&self->__instance,
332 8,
333 (MI_Value*)&str,
334 MI_STRING,
335 MI_FLAG_BORROW);
336 }
337 krisbash 1.1
338 MI_INLINE MI_Result MI_CALL OMI_Error_Clear_ProbableCauseDescription(
339 OMI_Error* self)
340 {
341 return self->__instance.ft->ClearElementAt(
342 (MI_Instance*)&self->__instance,
343 8);
344 }
345
346 MI_INLINE MI_Result MI_CALL OMI_Error_Set_RecommendedActions(
347 OMI_Error* self,
348 const MI_Char** data,
349 MI_Uint32 size)
350 {
351 MI_Array arr;
352 arr.data = (void*)data;
353 arr.size = size;
354 return self->__instance.ft->SetElementAt(
355 (MI_Instance*)&self->__instance,
356 9,
357 (MI_Value*)&arr,
358 krisbash 1.1 MI_STRINGA,
359 0);
360 }
361
362 MI_INLINE MI_Result MI_CALL OMI_Error_SetPtr_RecommendedActions(
363 OMI_Error* self,
364 const MI_Char** data,
365 MI_Uint32 size)
366 {
367 MI_Array arr;
368 arr.data = (void*)data;
369 arr.size = size;
370 return self->__instance.ft->SetElementAt(
371 (MI_Instance*)&self->__instance,
372 9,
373 (MI_Value*)&arr,
374 MI_STRINGA,
375 MI_FLAG_BORROW);
376 }
377
378 MI_INLINE MI_Result MI_CALL OMI_Error_Clear_RecommendedActions(
379 krisbash 1.1 OMI_Error* self)
380 {
381 return self->__instance.ft->ClearElementAt(
382 (MI_Instance*)&self->__instance,
383 9);
384 }
385
386 MI_INLINE MI_Result MI_CALL OMI_Error_Set_ErrorSource(
387 OMI_Error* self,
388 const MI_Char* str)
389 {
390 return self->__instance.ft->SetElementAt(
391 (MI_Instance*)&self->__instance,
392 10,
393 (MI_Value*)&str,
394 MI_STRING,
395 0);
396 }
397
398 MI_INLINE MI_Result MI_CALL OMI_Error_SetPtr_ErrorSource(
399 OMI_Error* self,
400 krisbash 1.1 const MI_Char* str)
401 {
402 return self->__instance.ft->SetElementAt(
403 (MI_Instance*)&self->__instance,
404 10,
405 (MI_Value*)&str,
406 MI_STRING,
407 MI_FLAG_BORROW);
408 }
409
410 MI_INLINE MI_Result MI_CALL OMI_Error_Clear_ErrorSource(
411 OMI_Error* self)
412 {
413 return self->__instance.ft->ClearElementAt(
414 (MI_Instance*)&self->__instance,
415 10);
416 }
417
418 MI_INLINE MI_Result MI_CALL OMI_Error_Set_ErrorSourceFormat(
419 OMI_Error* self,
420 MI_Uint16 x)
421 krisbash 1.1 {
422 ((MI_Uint16Field*)&self->ErrorSourceFormat)->value = x;
423 ((MI_Uint16Field*)&self->ErrorSourceFormat)->exists = 1;
424 return MI_RESULT_OK;
425 }
426
427 MI_INLINE MI_Result MI_CALL OMI_Error_Clear_ErrorSourceFormat(
428 OMI_Error* self)
429 {
430 memset((void*)&self->ErrorSourceFormat, 0, sizeof(self->ErrorSourceFormat));
431 return MI_RESULT_OK;
432 }
433
434 MI_INLINE MI_Result MI_CALL OMI_Error_Set_OtherErrorSourceFormat(
435 OMI_Error* self,
436 const MI_Char* str)
437 {
438 return self->__instance.ft->SetElementAt(
439 (MI_Instance*)&self->__instance,
440 12,
441 (MI_Value*)&str,
442 krisbash 1.1 MI_STRING,
443 0);
444 }
445
446 MI_INLINE MI_Result MI_CALL OMI_Error_SetPtr_OtherErrorSourceFormat(
447 OMI_Error* self,
448 const MI_Char* str)
449 {
450 return self->__instance.ft->SetElementAt(
451 (MI_Instance*)&self->__instance,
452 12,
453 (MI_Value*)&str,
454 MI_STRING,
455 MI_FLAG_BORROW);
456 }
457
458 MI_INLINE MI_Result MI_CALL OMI_Error_Clear_OtherErrorSourceFormat(
459 OMI_Error* self)
460 {
461 return self->__instance.ft->ClearElementAt(
462 (MI_Instance*)&self->__instance,
463 krisbash 1.1 12);
464 }
465
466 MI_INLINE MI_Result MI_CALL OMI_Error_Set_CIMStatusCode(
467 OMI_Error* self,
468 MI_Uint32 x)
469 {
470 ((MI_Uint32Field*)&self->CIMStatusCode)->value = x;
471 ((MI_Uint32Field*)&self->CIMStatusCode)->exists = 1;
472 return MI_RESULT_OK;
473 }
474
475 MI_INLINE MI_Result MI_CALL OMI_Error_Clear_CIMStatusCode(
476 OMI_Error* self)
477 {
478 memset((void*)&self->CIMStatusCode, 0, sizeof(self->CIMStatusCode));
479 return MI_RESULT_OK;
480 }
481
482 MI_INLINE MI_Result MI_CALL OMI_Error_Set_CIMStatusCodeDescription(
483 OMI_Error* self,
484 krisbash 1.1 const MI_Char* str)
485 {
486 return self->__instance.ft->SetElementAt(
487 (MI_Instance*)&self->__instance,
488 14,
489 (MI_Value*)&str,
490 MI_STRING,
491 0);
492 }
493
494 MI_INLINE MI_Result MI_CALL OMI_Error_SetPtr_CIMStatusCodeDescription(
495 OMI_Error* self,
496 const MI_Char* str)
497 {
498 return self->__instance.ft->SetElementAt(
499 (MI_Instance*)&self->__instance,
500 14,
501 (MI_Value*)&str,
502 MI_STRING,
503 MI_FLAG_BORROW);
504 }
505 krisbash 1.1
506 MI_INLINE MI_Result MI_CALL OMI_Error_Clear_CIMStatusCodeDescription(
507 OMI_Error* self)
508 {
509 return self->__instance.ft->ClearElementAt(
510 (MI_Instance*)&self->__instance,
511 14);
512 }
513
514 MI_INLINE MI_Result MI_CALL OMI_Error_Set_OMI_Code(
515 OMI_Error* self,
516 MI_Uint32 x)
517 {
518 ((MI_Uint32Field*)&self->OMI_Code)->value = x;
519 ((MI_Uint32Field*)&self->OMI_Code)->exists = 1;
520 return MI_RESULT_OK;
521 }
522
523 MI_INLINE MI_Result MI_CALL OMI_Error_Clear_OMI_Code(
524 OMI_Error* self)
525 {
526 krisbash 1.1 memset((void*)&self->OMI_Code, 0, sizeof(self->OMI_Code));
527 return MI_RESULT_OK;
528 }
529
530 MI_INLINE MI_Result MI_CALL OMI_Error_Set_OMI_Category(
531 OMI_Error* self,
532 MI_Uint16 x)
533 {
534 ((MI_Uint16Field*)&self->OMI_Category)->value = x;
535 ((MI_Uint16Field*)&self->OMI_Category)->exists = 1;
536 return MI_RESULT_OK;
537 }
538
539 MI_INLINE MI_Result MI_CALL OMI_Error_Clear_OMI_Category(
540 OMI_Error* self)
541 {
542 memset((void*)&self->OMI_Category, 0, sizeof(self->OMI_Category));
543 return MI_RESULT_OK;
544 }
545
546 MI_INLINE MI_Result MI_CALL OMI_Error_Set_OMI_Type(
547 krisbash 1.1 OMI_Error* self,
548 const MI_Char* str)
549 {
550 return self->__instance.ft->SetElementAt(
551 (MI_Instance*)&self->__instance,
552 17,
553 (MI_Value*)&str,
554 MI_STRING,
555 0);
556 }
557
558 MI_INLINE MI_Result MI_CALL OMI_Error_SetPtr_OMI_Type(
559 OMI_Error* self,
560 const MI_Char* str)
561 {
562 return self->__instance.ft->SetElementAt(
563 (MI_Instance*)&self->__instance,
564 17,
565 (MI_Value*)&str,
566 MI_STRING,
567 MI_FLAG_BORROW);
568 krisbash 1.1 }
569
570 MI_INLINE MI_Result MI_CALL OMI_Error_Clear_OMI_Type(
571 OMI_Error* self)
572 {
573 return self->__instance.ft->ClearElementAt(
574 (MI_Instance*)&self->__instance,
575 17);
576 }
577
578 MI_INLINE MI_Result MI_CALL OMI_Error_Set_OMI_ErrorMessage(
579 OMI_Error* self,
580 const MI_Char* str)
581 {
582 return self->__instance.ft->SetElementAt(
583 (MI_Instance*)&self->__instance,
584 18,
585 (MI_Value*)&str,
586 MI_STRING,
587 0);
588 }
589 krisbash 1.1
590 MI_INLINE MI_Result MI_CALL OMI_Error_SetPtr_OMI_ErrorMessage(
591 OMI_Error* self,
592 const MI_Char* str)
593 {
594 return self->__instance.ft->SetElementAt(
595 (MI_Instance*)&self->__instance,
596 18,
597 (MI_Value*)&str,
598 MI_STRING,
599 MI_FLAG_BORROW);
600 }
601
602 MI_INLINE MI_Result MI_CALL OMI_Error_Clear_OMI_ErrorMessage(
603 OMI_Error* self)
604 {
605 return self->__instance.ft->ClearElementAt(
606 (MI_Instance*)&self->__instance,
607 18);
608 }
609
610 krisbash 1.1
611 #endif /* _OMI_Error_h */
|
Return to
OMI_Error.h
CVS log
Up to [OMI] / omi / omi_error