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*/