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_InstMethodCall_h
 10              #define _CIM_InstMethodCall_h
 11              
 12              #include <MI.h>
 13              #include "CIM_InstIndication.h"
 14              
 15              /*
 16              **==============================================================================
 17              **
 18              ** CIM_InstMethodCall [CIM_InstMethodCall]
 19              **
 20              ** Keys:
 21              **
 22 krisbash 1.1 **==============================================================================
 23              */
 24              
 25              typedef struct _CIM_InstMethodCall /* extends CIM_InstIndication */
 26              {
 27                  MI_Instance __instance;
 28                  /* CIM_Indication properties */
 29                  MI_ConstStringField IndicationIdentifier;
 30                  MI_ConstStringAField CorrelatedIndications;
 31                  MI_ConstDatetimeField IndicationTime;
 32                  MI_ConstUint16Field PerceivedSeverity;
 33                  MI_ConstStringField OtherSeverity;
 34                  MI_ConstStringField IndicationFilterName;
 35                  MI_ConstStringField SequenceContext;
 36                  MI_ConstSint64Field SequenceNumber;
 37                  /* CIM_InstIndication properties */
 38                  MI_ConstReferenceField SourceInstance;
 39                  MI_ConstStringField SourceInstanceModelPath;
 40                  MI_ConstStringField SourceInstanceHost;
 41                  /* CIM_InstMethodCall properties */
 42                  MI_ConstStringField MethodName;
 43 krisbash 1.1     MI_ConstReferenceField MethodParameters;
 44                  MI_ConstStringField ReturnValue;
 45                  MI_ConstBooleanField PreCall;
 46              }
 47              CIM_InstMethodCall;
 48              
 49              typedef struct _CIM_InstMethodCall_Ref
 50              {
 51                  CIM_InstMethodCall* value;
 52                  MI_Boolean exists;
 53                  MI_Uint8 flags;
 54              }
 55              CIM_InstMethodCall_Ref;
 56              
 57              typedef struct _CIM_InstMethodCall_ConstRef
 58              {
 59                  MI_CONST CIM_InstMethodCall* value;
 60                  MI_Boolean exists;
 61                  MI_Uint8 flags;
 62              }
 63              CIM_InstMethodCall_ConstRef;
 64 krisbash 1.1 
 65              typedef struct _CIM_InstMethodCall_Array
 66              {
 67                  struct _CIM_InstMethodCall** data;
 68                  MI_Uint32 size;
 69              }
 70              CIM_InstMethodCall_Array;
 71              
 72              typedef struct _CIM_InstMethodCall_ConstArray
 73              {
 74                  struct _CIM_InstMethodCall MI_CONST* MI_CONST* data;
 75                  MI_Uint32 size;
 76              }
 77              CIM_InstMethodCall_ConstArray;
 78              
 79              typedef struct _CIM_InstMethodCall_ArrayRef
 80              {
 81                  CIM_InstMethodCall_Array value;
 82                  MI_Boolean exists;
 83                  MI_Uint8 flags;
 84              }
 85 krisbash 1.1 CIM_InstMethodCall_ArrayRef;
 86              
 87              typedef struct _CIM_InstMethodCall_ConstArrayRef
 88              {
 89                  CIM_InstMethodCall_ConstArray value;
 90                  MI_Boolean exists;
 91                  MI_Uint8 flags;
 92              }
 93              CIM_InstMethodCall_ConstArrayRef;
 94              
 95              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Set_IndicationIdentifier(
 96                  CIM_InstMethodCall* self,
 97                  const MI_Char* str)
 98              {
 99                  return self->__instance.ft->SetElementAt(
100                      (MI_Instance*)&self->__instance,
101                      0,
102                      (MI_Value*)&str,
103                      MI_STRING,
104                      0);
105              }
106 krisbash 1.1 
107              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_SetPtr_IndicationIdentifier(
108                  CIM_InstMethodCall* self,
109                  const MI_Char* str)
110              {
111                  return self->__instance.ft->SetElementAt(
112                      (MI_Instance*)&self->__instance,
113                      0,
114                      (MI_Value*)&str,
115                      MI_STRING,
116                      MI_FLAG_BORROW);
117              }
118              
119              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Clear_IndicationIdentifier(
120                  CIM_InstMethodCall* self)
121              {
122                  return self->__instance.ft->ClearElementAt(
123                      (MI_Instance*)&self->__instance,
124                      0);
125              }
126              
127 krisbash 1.1 MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Set_CorrelatedIndications(
128                  CIM_InstMethodCall* self,
129                  const MI_Char** data,
130                  MI_Uint32 size)
131              {
132                  MI_Array arr;
133                  arr.data = (void*)data;
134                  arr.size = size;
135                  return self->__instance.ft->SetElementAt(
136                      (MI_Instance*)&self->__instance,
137                      1,
138                      (MI_Value*)&arr,
139                      MI_STRINGA,
140                      0);
141              }
142              
143              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_SetPtr_CorrelatedIndications(
144                  CIM_InstMethodCall* self,
145                  const MI_Char** data,
146                  MI_Uint32 size)
147              {
148 krisbash 1.1     MI_Array arr;
149                  arr.data = (void*)data;
150                  arr.size = size;
151                  return self->__instance.ft->SetElementAt(
152                      (MI_Instance*)&self->__instance,
153                      1,
154                      (MI_Value*)&arr,
155                      MI_STRINGA,
156                      MI_FLAG_BORROW);
157              }
158              
159              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Clear_CorrelatedIndications(
160                  CIM_InstMethodCall* self)
161              {
162                  return self->__instance.ft->ClearElementAt(
163                      (MI_Instance*)&self->__instance,
164                      1);
165              }
166              
167              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Set_IndicationTime(
168                  CIM_InstMethodCall* self,
169 krisbash 1.1     MI_Datetime x)
170              {
171                  ((MI_DatetimeField*)&self->IndicationTime)->value = x;
172                  ((MI_DatetimeField*)&self->IndicationTime)->exists = 1;
173                  return MI_RESULT_OK;
174              }
175              
176              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Clear_IndicationTime(
177                  CIM_InstMethodCall* self)
178              {
179                  memset((void*)&self->IndicationTime, 0, sizeof(self->IndicationTime));
180                  return MI_RESULT_OK;
181              }
182              
183              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Set_PerceivedSeverity(
184                  CIM_InstMethodCall* self,
185                  MI_Uint16 x)
186              {
187                  ((MI_Uint16Field*)&self->PerceivedSeverity)->value = x;
188                  ((MI_Uint16Field*)&self->PerceivedSeverity)->exists = 1;
189                  return MI_RESULT_OK;
190 krisbash 1.1 }
191              
192              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Clear_PerceivedSeverity(
193                  CIM_InstMethodCall* self)
194              {
195                  memset((void*)&self->PerceivedSeverity, 0, sizeof(self->PerceivedSeverity));
196                  return MI_RESULT_OK;
197              }
198              
199              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Set_OtherSeverity(
200                  CIM_InstMethodCall* self,
201                  const MI_Char* str)
202              {
203                  return self->__instance.ft->SetElementAt(
204                      (MI_Instance*)&self->__instance,
205                      4,
206                      (MI_Value*)&str,
207                      MI_STRING,
208                      0);
209              }
210              
211 krisbash 1.1 MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_SetPtr_OtherSeverity(
212                  CIM_InstMethodCall* self,
213                  const MI_Char* str)
214              {
215                  return self->__instance.ft->SetElementAt(
216                      (MI_Instance*)&self->__instance,
217                      4,
218                      (MI_Value*)&str,
219                      MI_STRING,
220                      MI_FLAG_BORROW);
221              }
222              
223              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Clear_OtherSeverity(
224                  CIM_InstMethodCall* self)
225              {
226                  return self->__instance.ft->ClearElementAt(
227                      (MI_Instance*)&self->__instance,
228                      4);
229              }
230              
231              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Set_IndicationFilterName(
232 krisbash 1.1     CIM_InstMethodCall* self,
233                  const MI_Char* str)
234              {
235                  return self->__instance.ft->SetElementAt(
236                      (MI_Instance*)&self->__instance,
237                      5,
238                      (MI_Value*)&str,
239                      MI_STRING,
240                      0);
241              }
242              
243              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_SetPtr_IndicationFilterName(
244                  CIM_InstMethodCall* self,
245                  const MI_Char* str)
246              {
247                  return self->__instance.ft->SetElementAt(
248                      (MI_Instance*)&self->__instance,
249                      5,
250                      (MI_Value*)&str,
251                      MI_STRING,
252                      MI_FLAG_BORROW);
253 krisbash 1.1 }
254              
255              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Clear_IndicationFilterName(
256                  CIM_InstMethodCall* self)
257              {
258                  return self->__instance.ft->ClearElementAt(
259                      (MI_Instance*)&self->__instance,
260                      5);
261              }
262              
263              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Set_SequenceContext(
264                  CIM_InstMethodCall* self,
265                  const MI_Char* str)
266              {
267                  return self->__instance.ft->SetElementAt(
268                      (MI_Instance*)&self->__instance,
269                      6,
270                      (MI_Value*)&str,
271                      MI_STRING,
272                      0);
273              }
274 krisbash 1.1 
275              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_SetPtr_SequenceContext(
276                  CIM_InstMethodCall* self,
277                  const MI_Char* str)
278              {
279                  return self->__instance.ft->SetElementAt(
280                      (MI_Instance*)&self->__instance,
281                      6,
282                      (MI_Value*)&str,
283                      MI_STRING,
284                      MI_FLAG_BORROW);
285              }
286              
287              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Clear_SequenceContext(
288                  CIM_InstMethodCall* self)
289              {
290                  return self->__instance.ft->ClearElementAt(
291                      (MI_Instance*)&self->__instance,
292                      6);
293              }
294              
295 krisbash 1.1 MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Set_SequenceNumber(
296                  CIM_InstMethodCall* self,
297                  MI_Sint64 x)
298              {
299                  ((MI_Sint64Field*)&self->SequenceNumber)->value = x;
300                  ((MI_Sint64Field*)&self->SequenceNumber)->exists = 1;
301                  return MI_RESULT_OK;
302              }
303              
304              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Clear_SequenceNumber(
305                  CIM_InstMethodCall* self)
306              {
307                  memset((void*)&self->SequenceNumber, 0, sizeof(self->SequenceNumber));
308                  return MI_RESULT_OK;
309              }
310              
311              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Set_SourceInstance(
312                  CIM_InstMethodCall* self,
313                  const MI_Instance* x)
314              {
315                  return self->__instance.ft->SetElementAt(
316 krisbash 1.1         (MI_Instance*)&self->__instance,
317                      8,
318                      (MI_Value*)&x,
319                      MI_INSTANCE,
320                      0);
321              }
322              
323              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_SetPtr_SourceInstance(
324                  CIM_InstMethodCall* self,
325                  const MI_Instance* x)
326              {
327                  return self->__instance.ft->SetElementAt(
328                      (MI_Instance*)&self->__instance,
329                      8,
330                      (MI_Value*)&x,
331                      MI_INSTANCE,
332                      MI_FLAG_BORROW);
333              }
334              
335              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Clear_SourceInstance(
336                  CIM_InstMethodCall* self)
337 krisbash 1.1 {
338                  return self->__instance.ft->ClearElementAt(
339                      (MI_Instance*)&self->__instance,
340                      8);
341              }
342              
343              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Set_SourceInstanceModelPath(
344                  CIM_InstMethodCall* self,
345                  const MI_Char* str)
346              {
347                  return self->__instance.ft->SetElementAt(
348                      (MI_Instance*)&self->__instance,
349                      9,
350                      (MI_Value*)&str,
351                      MI_STRING,
352                      0);
353              }
354              
355              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_SetPtr_SourceInstanceModelPath(
356                  CIM_InstMethodCall* self,
357                  const MI_Char* str)
358 krisbash 1.1 {
359                  return self->__instance.ft->SetElementAt(
360                      (MI_Instance*)&self->__instance,
361                      9,
362                      (MI_Value*)&str,
363                      MI_STRING,
364                      MI_FLAG_BORROW);
365              }
366              
367              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Clear_SourceInstanceModelPath(
368                  CIM_InstMethodCall* self)
369              {
370                  return self->__instance.ft->ClearElementAt(
371                      (MI_Instance*)&self->__instance,
372                      9);
373              }
374              
375              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Set_SourceInstanceHost(
376                  CIM_InstMethodCall* self,
377                  const MI_Char* str)
378              {
379 krisbash 1.1     return self->__instance.ft->SetElementAt(
380                      (MI_Instance*)&self->__instance,
381                      10,
382                      (MI_Value*)&str,
383                      MI_STRING,
384                      0);
385              }
386              
387              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_SetPtr_SourceInstanceHost(
388                  CIM_InstMethodCall* self,
389                  const MI_Char* str)
390              {
391                  return self->__instance.ft->SetElementAt(
392                      (MI_Instance*)&self->__instance,
393                      10,
394                      (MI_Value*)&str,
395                      MI_STRING,
396                      MI_FLAG_BORROW);
397              }
398              
399              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Clear_SourceInstanceHost(
400 krisbash 1.1     CIM_InstMethodCall* self)
401              {
402                  return self->__instance.ft->ClearElementAt(
403                      (MI_Instance*)&self->__instance,
404                      10);
405              }
406              
407              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Set_MethodName(
408                  CIM_InstMethodCall* self,
409                  const MI_Char* str)
410              {
411                  return self->__instance.ft->SetElementAt(
412                      (MI_Instance*)&self->__instance,
413                      11,
414                      (MI_Value*)&str,
415                      MI_STRING,
416                      0);
417              }
418              
419              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_SetPtr_MethodName(
420                  CIM_InstMethodCall* self,
421 krisbash 1.1     const MI_Char* str)
422              {
423                  return self->__instance.ft->SetElementAt(
424                      (MI_Instance*)&self->__instance,
425                      11,
426                      (MI_Value*)&str,
427                      MI_STRING,
428                      MI_FLAG_BORROW);
429              }
430              
431              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Clear_MethodName(
432                  CIM_InstMethodCall* self)
433              {
434                  return self->__instance.ft->ClearElementAt(
435                      (MI_Instance*)&self->__instance,
436                      11);
437              }
438              
439              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Set_MethodParameters(
440                  CIM_InstMethodCall* self,
441                  const MI_Instance* x)
442 krisbash 1.1 {
443                  return self->__instance.ft->SetElementAt(
444                      (MI_Instance*)&self->__instance,
445                      12,
446                      (MI_Value*)&x,
447                      MI_INSTANCE,
448                      0);
449              }
450              
451              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_SetPtr_MethodParameters(
452                  CIM_InstMethodCall* self,
453                  const MI_Instance* x)
454              {
455                  return self->__instance.ft->SetElementAt(
456                      (MI_Instance*)&self->__instance,
457                      12,
458                      (MI_Value*)&x,
459                      MI_INSTANCE,
460                      MI_FLAG_BORROW);
461              }
462              
463 krisbash 1.1 MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Clear_MethodParameters(
464                  CIM_InstMethodCall* self)
465              {
466                  return self->__instance.ft->ClearElementAt(
467                      (MI_Instance*)&self->__instance,
468                      12);
469              }
470              
471              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Set_ReturnValue(
472                  CIM_InstMethodCall* self,
473                  const MI_Char* str)
474              {
475                  return self->__instance.ft->SetElementAt(
476                      (MI_Instance*)&self->__instance,
477                      13,
478                      (MI_Value*)&str,
479                      MI_STRING,
480                      0);
481              }
482              
483              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_SetPtr_ReturnValue(
484 krisbash 1.1     CIM_InstMethodCall* self,
485                  const MI_Char* str)
486              {
487                  return self->__instance.ft->SetElementAt(
488                      (MI_Instance*)&self->__instance,
489                      13,
490                      (MI_Value*)&str,
491                      MI_STRING,
492                      MI_FLAG_BORROW);
493              }
494              
495              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Clear_ReturnValue(
496                  CIM_InstMethodCall* self)
497              {
498                  return self->__instance.ft->ClearElementAt(
499                      (MI_Instance*)&self->__instance,
500                      13);
501              }
502              
503              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Set_PreCall(
504                  CIM_InstMethodCall* self,
505 krisbash 1.1     MI_Boolean x)
506              {
507                  ((MI_BooleanField*)&self->PreCall)->value = x;
508                  ((MI_BooleanField*)&self->PreCall)->exists = 1;
509                  return MI_RESULT_OK;
510              }
511              
512              MI_INLINE MI_Result MI_CALL CIM_InstMethodCall_Clear_PreCall(
513                  CIM_InstMethodCall* self)
514              {
515                  memset((void*)&self->PreCall, 0, sizeof(self->PreCall));
516                  return MI_RESULT_OK;
517              }
518              
519              
520              #endif /* _CIM_InstMethodCall_h */