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