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_InstIndication_h
 10              #define _CIM_InstIndication_h
 11              
 12              #include <MI.h>
 13              #include "CIM_Indication.h"
 14              
 15              /*
 16              **==============================================================================
 17              **
 18              ** CIM_InstIndication [CIM_InstIndication]
 19              **
 20              ** Keys:
 21              **
 22 krisbash 1.1 **==============================================================================
 23              */
 24              
 25              typedef struct _CIM_InstIndication /* extends CIM_Indication */
 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              }
 42              CIM_InstIndication;
 43 krisbash 1.1 
 44              typedef struct _CIM_InstIndication_Ref
 45              {
 46                  CIM_InstIndication* value;
 47                  MI_Boolean exists;
 48                  MI_Uint8 flags;
 49              }
 50              CIM_InstIndication_Ref;
 51              
 52              typedef struct _CIM_InstIndication_ConstRef
 53              {
 54                  MI_CONST CIM_InstIndication* value;
 55                  MI_Boolean exists;
 56                  MI_Uint8 flags;
 57              }
 58              CIM_InstIndication_ConstRef;
 59              
 60              typedef struct _CIM_InstIndication_Array
 61              {
 62                  struct _CIM_InstIndication** data;
 63                  MI_Uint32 size;
 64 krisbash 1.1 }
 65              CIM_InstIndication_Array;
 66              
 67              typedef struct _CIM_InstIndication_ConstArray
 68              {
 69                  struct _CIM_InstIndication MI_CONST* MI_CONST* data;
 70                  MI_Uint32 size;
 71              }
 72              CIM_InstIndication_ConstArray;
 73              
 74              typedef struct _CIM_InstIndication_ArrayRef
 75              {
 76                  CIM_InstIndication_Array value;
 77                  MI_Boolean exists;
 78                  MI_Uint8 flags;
 79              }
 80              CIM_InstIndication_ArrayRef;
 81              
 82              typedef struct _CIM_InstIndication_ConstArrayRef
 83              {
 84                  CIM_InstIndication_ConstArray value;
 85 krisbash 1.1     MI_Boolean exists;
 86                  MI_Uint8 flags;
 87              }
 88              CIM_InstIndication_ConstArrayRef;
 89              
 90              MI_INLINE MI_Result MI_CALL CIM_InstIndication_Set_IndicationIdentifier(
 91                  CIM_InstIndication* self,
 92                  const MI_Char* str)
 93              {
 94                  return self->__instance.ft->SetElementAt(
 95                      (MI_Instance*)&self->__instance,
 96                      0,
 97                      (MI_Value*)&str,
 98                      MI_STRING,
 99                      0);
100              }
101              
102              MI_INLINE MI_Result MI_CALL CIM_InstIndication_SetPtr_IndicationIdentifier(
103                  CIM_InstIndication* self,
104                  const MI_Char* str)
105              {
106 krisbash 1.1     return self->__instance.ft->SetElementAt(
107                      (MI_Instance*)&self->__instance,
108                      0,
109                      (MI_Value*)&str,
110                      MI_STRING,
111                      MI_FLAG_BORROW);
112              }
113              
114              MI_INLINE MI_Result MI_CALL CIM_InstIndication_Clear_IndicationIdentifier(
115                  CIM_InstIndication* self)
116              {
117                  return self->__instance.ft->ClearElementAt(
118                      (MI_Instance*)&self->__instance,
119                      0);
120              }
121              
122              MI_INLINE MI_Result MI_CALL CIM_InstIndication_Set_CorrelatedIndications(
123                  CIM_InstIndication* self,
124                  const MI_Char** data,
125                  MI_Uint32 size)
126              {
127 krisbash 1.1     MI_Array arr;
128                  arr.data = (void*)data;
129                  arr.size = size;
130                  return self->__instance.ft->SetElementAt(
131                      (MI_Instance*)&self->__instance,
132                      1,
133                      (MI_Value*)&arr,
134                      MI_STRINGA,
135                      0);
136              }
137              
138              MI_INLINE MI_Result MI_CALL CIM_InstIndication_SetPtr_CorrelatedIndications(
139                  CIM_InstIndication* self,
140                  const MI_Char** data,
141                  MI_Uint32 size)
142              {
143                  MI_Array arr;
144                  arr.data = (void*)data;
145                  arr.size = size;
146                  return self->__instance.ft->SetElementAt(
147                      (MI_Instance*)&self->__instance,
148 krisbash 1.1         1,
149                      (MI_Value*)&arr,
150                      MI_STRINGA,
151                      MI_FLAG_BORROW);
152              }
153              
154              MI_INLINE MI_Result MI_CALL CIM_InstIndication_Clear_CorrelatedIndications(
155                  CIM_InstIndication* self)
156              {
157                  return self->__instance.ft->ClearElementAt(
158                      (MI_Instance*)&self->__instance,
159                      1);
160              }
161              
162              MI_INLINE MI_Result MI_CALL CIM_InstIndication_Set_IndicationTime(
163                  CIM_InstIndication* self,
164                  MI_Datetime x)
165              {
166                  ((MI_DatetimeField*)&self->IndicationTime)->value = x;
167                  ((MI_DatetimeField*)&self->IndicationTime)->exists = 1;
168                  return MI_RESULT_OK;
169 krisbash 1.1 }
170              
171              MI_INLINE MI_Result MI_CALL CIM_InstIndication_Clear_IndicationTime(
172                  CIM_InstIndication* self)
173              {
174                  memset((void*)&self->IndicationTime, 0, sizeof(self->IndicationTime));
175                  return MI_RESULT_OK;
176              }
177              
178              MI_INLINE MI_Result MI_CALL CIM_InstIndication_Set_PerceivedSeverity(
179                  CIM_InstIndication* self,
180                  MI_Uint16 x)
181              {
182                  ((MI_Uint16Field*)&self->PerceivedSeverity)->value = x;
183                  ((MI_Uint16Field*)&self->PerceivedSeverity)->exists = 1;
184                  return MI_RESULT_OK;
185              }
186              
187              MI_INLINE MI_Result MI_CALL CIM_InstIndication_Clear_PerceivedSeverity(
188                  CIM_InstIndication* self)
189              {
190 krisbash 1.1     memset((void*)&self->PerceivedSeverity, 0, sizeof(self->PerceivedSeverity));
191                  return MI_RESULT_OK;
192              }
193              
194              MI_INLINE MI_Result MI_CALL CIM_InstIndication_Set_OtherSeverity(
195                  CIM_InstIndication* self,
196                  const MI_Char* str)
197              {
198                  return self->__instance.ft->SetElementAt(
199                      (MI_Instance*)&self->__instance,
200                      4,
201                      (MI_Value*)&str,
202                      MI_STRING,
203                      0);
204              }
205              
206              MI_INLINE MI_Result MI_CALL CIM_InstIndication_SetPtr_OtherSeverity(
207                  CIM_InstIndication* self,
208                  const MI_Char* str)
209              {
210                  return self->__instance.ft->SetElementAt(
211 krisbash 1.1         (MI_Instance*)&self->__instance,
212                      4,
213                      (MI_Value*)&str,
214                      MI_STRING,
215                      MI_FLAG_BORROW);
216              }
217              
218              MI_INLINE MI_Result MI_CALL CIM_InstIndication_Clear_OtherSeverity(
219                  CIM_InstIndication* self)
220              {
221                  return self->__instance.ft->ClearElementAt(
222                      (MI_Instance*)&self->__instance,
223                      4);
224              }
225              
226              MI_INLINE MI_Result MI_CALL CIM_InstIndication_Set_IndicationFilterName(
227                  CIM_InstIndication* self,
228                  const MI_Char* str)
229              {
230                  return self->__instance.ft->SetElementAt(
231                      (MI_Instance*)&self->__instance,
232 krisbash 1.1         5,
233                      (MI_Value*)&str,
234                      MI_STRING,
235                      0);
236              }
237              
238              MI_INLINE MI_Result MI_CALL CIM_InstIndication_SetPtr_IndicationFilterName(
239                  CIM_InstIndication* self,
240                  const MI_Char* str)
241              {
242                  return self->__instance.ft->SetElementAt(
243                      (MI_Instance*)&self->__instance,
244                      5,
245                      (MI_Value*)&str,
246                      MI_STRING,
247                      MI_FLAG_BORROW);
248              }
249              
250              MI_INLINE MI_Result MI_CALL CIM_InstIndication_Clear_IndicationFilterName(
251                  CIM_InstIndication* self)
252              {
253 krisbash 1.1     return self->__instance.ft->ClearElementAt(
254                      (MI_Instance*)&self->__instance,
255                      5);
256              }
257              
258              MI_INLINE MI_Result MI_CALL CIM_InstIndication_Set_SequenceContext(
259                  CIM_InstIndication* self,
260                  const MI_Char* str)
261              {
262                  return self->__instance.ft->SetElementAt(
263                      (MI_Instance*)&self->__instance,
264                      6,
265                      (MI_Value*)&str,
266                      MI_STRING,
267                      0);
268              }
269              
270              MI_INLINE MI_Result MI_CALL CIM_InstIndication_SetPtr_SequenceContext(
271                  CIM_InstIndication* self,
272                  const MI_Char* str)
273              {
274 krisbash 1.1     return self->__instance.ft->SetElementAt(
275                      (MI_Instance*)&self->__instance,
276                      6,
277                      (MI_Value*)&str,
278                      MI_STRING,
279                      MI_FLAG_BORROW);
280              }
281              
282              MI_INLINE MI_Result MI_CALL CIM_InstIndication_Clear_SequenceContext(
283                  CIM_InstIndication* self)
284              {
285                  return self->__instance.ft->ClearElementAt(
286                      (MI_Instance*)&self->__instance,
287                      6);
288              }
289              
290              MI_INLINE MI_Result MI_CALL CIM_InstIndication_Set_SequenceNumber(
291                  CIM_InstIndication* self,
292                  MI_Sint64 x)
293              {
294                  ((MI_Sint64Field*)&self->SequenceNumber)->value = x;
295 krisbash 1.1     ((MI_Sint64Field*)&self->SequenceNumber)->exists = 1;
296                  return MI_RESULT_OK;
297              }
298              
299              MI_INLINE MI_Result MI_CALL CIM_InstIndication_Clear_SequenceNumber(
300                  CIM_InstIndication* self)
301              {
302                  memset((void*)&self->SequenceNumber, 0, sizeof(self->SequenceNumber));
303                  return MI_RESULT_OK;
304              }
305              
306              MI_INLINE MI_Result MI_CALL CIM_InstIndication_Set_SourceInstance(
307                  CIM_InstIndication* self,
308                  const MI_Instance* x)
309              {
310                  return self->__instance.ft->SetElementAt(
311                      (MI_Instance*)&self->__instance,
312                      8,
313                      (MI_Value*)&x,
314                      MI_INSTANCE,
315                      0);
316 krisbash 1.1 }
317              
318              MI_INLINE MI_Result MI_CALL CIM_InstIndication_SetPtr_SourceInstance(
319                  CIM_InstIndication* self,
320                  const MI_Instance* x)
321              {
322                  return self->__instance.ft->SetElementAt(
323                      (MI_Instance*)&self->__instance,
324                      8,
325                      (MI_Value*)&x,
326                      MI_INSTANCE,
327                      MI_FLAG_BORROW);
328              }
329              
330              MI_INLINE MI_Result MI_CALL CIM_InstIndication_Clear_SourceInstance(
331                  CIM_InstIndication* self)
332              {
333                  return self->__instance.ft->ClearElementAt(
334                      (MI_Instance*)&self->__instance,
335                      8);
336              }
337 krisbash 1.1 
338              MI_INLINE MI_Result MI_CALL CIM_InstIndication_Set_SourceInstanceModelPath(
339                  CIM_InstIndication* self,
340                  const MI_Char* str)
341              {
342                  return self->__instance.ft->SetElementAt(
343                      (MI_Instance*)&self->__instance,
344                      9,
345                      (MI_Value*)&str,
346                      MI_STRING,
347                      0);
348              }
349              
350              MI_INLINE MI_Result MI_CALL CIM_InstIndication_SetPtr_SourceInstanceModelPath(
351                  CIM_InstIndication* self,
352                  const MI_Char* str)
353              {
354                  return self->__instance.ft->SetElementAt(
355                      (MI_Instance*)&self->__instance,
356                      9,
357                      (MI_Value*)&str,
358 krisbash 1.1         MI_STRING,
359                      MI_FLAG_BORROW);
360              }
361              
362              MI_INLINE MI_Result MI_CALL CIM_InstIndication_Clear_SourceInstanceModelPath(
363                  CIM_InstIndication* self)
364              {
365                  return self->__instance.ft->ClearElementAt(
366                      (MI_Instance*)&self->__instance,
367                      9);
368              }
369              
370              MI_INLINE MI_Result MI_CALL CIM_InstIndication_Set_SourceInstanceHost(
371                  CIM_InstIndication* self,
372                  const MI_Char* str)
373              {
374                  return self->__instance.ft->SetElementAt(
375                      (MI_Instance*)&self->__instance,
376                      10,
377                      (MI_Value*)&str,
378                      MI_STRING,
379 krisbash 1.1         0);
380              }
381              
382              MI_INLINE MI_Result MI_CALL CIM_InstIndication_SetPtr_SourceInstanceHost(
383                  CIM_InstIndication* self,
384                  const MI_Char* str)
385              {
386                  return self->__instance.ft->SetElementAt(
387                      (MI_Instance*)&self->__instance,
388                      10,
389                      (MI_Value*)&str,
390                      MI_STRING,
391                      MI_FLAG_BORROW);
392              }
393              
394              MI_INLINE MI_Result MI_CALL CIM_InstIndication_Clear_SourceInstanceHost(
395                  CIM_InstIndication* self)
396              {
397                  return self->__instance.ft->ClearElementAt(
398                      (MI_Instance*)&self->__instance,
399                      10);
400 krisbash 1.1 }
401              
402              
403              #endif /* _CIM_InstIndication_h */