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