1 mike 1.1 /* @migen@ */
2 /*
3 **==============================================================================
4 **
5 ** WARNING: THIS FILE WAS AUTOMATICALLY GENERATED. PLEASE DO NOT EDIT.
6 **
7 **==============================================================================
8 */
9 #ifndef _CIM_Process_h
10 #define _CIM_Process_h
11
12 #include <MI.h>
13 #include "CIM_EnabledLogicalElement.h"
14 #include "CIM_ConcreteJob.h"
15
16 /*
17 **==============================================================================
18 **
19 ** CIM_Process [CIM_Process]
20 **
21 ** Keys:
22 mike 1.1 ** CSCreationClassName
23 ** CSName
24 ** OSCreationClassName
25 ** OSName
26 ** CreationClassName
27 ** Handle
28 **
29 **==============================================================================
30 */
31
32 typedef struct _CIM_Process /* extends CIM_EnabledLogicalElement */
33 {
34 MI_Instance __instance;
35 /* CIM_ManagedElement properties */
36 MI_ConstStringField InstanceID;
37 MI_ConstStringField Caption;
38 MI_ConstStringField Description;
39 MI_ConstStringField ElementName;
40 /* CIM_ManagedSystemElement properties */
41 MI_ConstDatetimeField InstallDate;
42 MI_ConstStringField Name;
43 mike 1.1 MI_ConstUint16AField OperationalStatus;
44 MI_ConstStringAField StatusDescriptions;
45 MI_ConstStringField Status;
46 MI_ConstUint16Field HealthState;
47 MI_ConstUint16Field CommunicationStatus;
48 MI_ConstUint16Field DetailedStatus;
49 MI_ConstUint16Field OperatingStatus;
50 MI_ConstUint16Field PrimaryStatus;
51 /* CIM_LogicalElement properties */
52 /* CIM_EnabledLogicalElement properties */
53 MI_ConstUint16Field EnabledState;
54 MI_ConstStringField OtherEnabledState;
55 MI_ConstUint16Field RequestedState;
56 MI_ConstUint16Field EnabledDefault;
57 MI_ConstDatetimeField TimeOfLastStateChange;
58 MI_ConstUint16AField AvailableRequestedStates;
59 MI_ConstUint16Field TransitioningToState;
60 /* CIM_Process properties */
61 /*KEY*/ MI_ConstStringField CSCreationClassName;
62 /*KEY*/ MI_ConstStringField CSName;
63 /*KEY*/ MI_ConstStringField OSCreationClassName;
64 mike 1.1 /*KEY*/ MI_ConstStringField OSName;
65 /*KEY*/ MI_ConstStringField CreationClassName;
66 /*KEY*/ MI_ConstStringField Handle;
67 MI_ConstUint32Field Priority;
68 MI_ConstUint16Field ExecutionState;
69 MI_ConstStringField OtherExecutionDescription;
70 MI_ConstDatetimeField CreationDate;
71 MI_ConstDatetimeField TerminationDate;
72 MI_ConstUint64Field KernelModeTime;
73 MI_ConstUint64Field UserModeTime;
74 MI_ConstUint64Field WorkingSetSize;
75 }
76 CIM_Process;
77
78 typedef struct _CIM_Process_Ref
79 {
80 CIM_Process* value;
81 MI_Boolean exists;
82 MI_Uint8 flags;
83 }
84 CIM_Process_Ref;
85 mike 1.1
86 typedef struct _CIM_Process_ConstRef
87 {
88 MI_CONST CIM_Process* value;
89 MI_Boolean exists;
90 MI_Uint8 flags;
91 }
92 CIM_Process_ConstRef;
93
94 typedef struct _CIM_Process_Array
95 {
96 struct _CIM_Process** data;
97 MI_Uint32 size;
98 }
99 CIM_Process_Array;
100
101 typedef struct _CIM_Process_ConstArray
102 {
103 struct _CIM_Process MI_CONST* MI_CONST* data;
104 MI_Uint32 size;
105 }
106 mike 1.1 CIM_Process_ConstArray;
107
108 typedef struct _CIM_Process_ArrayRef
109 {
110 CIM_Process_Array value;
111 MI_Boolean exists;
112 MI_Uint8 flags;
113 }
114 CIM_Process_ArrayRef;
115
116 typedef struct _CIM_Process_ConstArrayRef
117 {
118 CIM_Process_ConstArray value;
119 MI_Boolean exists;
120 MI_Uint8 flags;
121 }
122 CIM_Process_ConstArrayRef;
123
124 MI_EXTERN_C MI_CONST MI_ClassDecl CIM_Process_rtti;
125
126 /*
127 mike 1.1 **==============================================================================
128 **
129 ** CIM_Process.RequestStateChange()
130 **
131 **==============================================================================
132 */
133
134 typedef struct _CIM_Process_RequestStateChange
135 {
136 MI_Instance __instance;
137 /*OUT*/ MI_ConstUint32Field MIReturn;
138 /*IN*/ MI_ConstUint16Field RequestedState;
139 /*OUT*/ CIM_ConcreteJob_ConstRef Job;
140 /*IN*/ MI_ConstDatetimeField TimeoutPeriod;
141 }
142 CIM_Process_RequestStateChange;
143
144
145 /*
146 **==============================================================================
147 **
148 mike 1.1 ** CIM_Process_Class
149 **
150 **==============================================================================
151 */
152
153 #ifdef __cplusplus
154 # include <micxx/micxx.h>
155
156 MI_BEGIN_NAMESPACE
157
158 class CIM_Process_Class : public CIM_EnabledLogicalElement_Class
159 {
160 public:
161
162 typedef CIM_Process Self;
163
164 CIM_Process_Class() :
165 CIM_EnabledLogicalElement_Class(&CIM_Process_rtti)
166 {
167 }
168
169 mike 1.1 CIM_Process_Class(
170 const CIM_Process* instanceName,
171 bool keysOnly) :
172 CIM_EnabledLogicalElement_Class(
173 &CIM_Process_rtti,
174 &instanceName->__instance,
175 keysOnly)
176 {
177 }
178
179 CIM_Process_Class(
180 const MI_ClassDecl* clDecl,
181 const MI_Instance* instance,
182 bool keysOnly) :
183 CIM_EnabledLogicalElement_Class(clDecl, instance, keysOnly)
184 {
185 }
186
187 CIM_Process_Class(
188 const MI_ClassDecl* clDecl) :
189 CIM_EnabledLogicalElement_Class(clDecl)
190 mike 1.1 {
191 }
192
193 CIM_Process_Class& operator=(
194 const CIM_Process_Class& x)
195 {
196 CopyRef(x);
197 return *this;
198 }
199
200 CIM_Process_Class(
201 const CIM_Process_Class& x) :
202 CIM_EnabledLogicalElement_Class(x)
203 {
204 }
205
206 static const MI_ClassDecl* GetClassDecl()
207 {
208 return &CIM_Process_rtti;
209 }
210
211 mike 1.1 //
212 // CIM_Process_Class.CSCreationClassName
213 //
214
215 const Field<String>& CSCreationClassName() const
216 {
217 const size_t n = offsetof(Self, CSCreationClassName);
218 return GetField<String>(n);
219 }
220
221 void CSCreationClassName(const Field<String>& x)
222 {
223 const size_t n = offsetof(Self, CSCreationClassName);
224 GetField<String>(n) = x;
225 }
226
227 const String& CSCreationClassName_value() const
228 {
229 const size_t n = offsetof(Self, CSCreationClassName);
230 return GetField<String>(n).value;
231 }
232 mike 1.1
233 void CSCreationClassName_value(const String& x)
234 {
235 const size_t n = offsetof(Self, CSCreationClassName);
236 GetField<String>(n).Set(x);
237 }
238
239 bool CSCreationClassName_exists() const
240 {
241 const size_t n = offsetof(Self, CSCreationClassName);
242 return GetField<String>(n).exists ? true : false;
243 }
244
245 void CSCreationClassName_clear()
246 {
247 const size_t n = offsetof(Self, CSCreationClassName);
248 GetField<String>(n).Clear();
249 }
250
251 //
252 // CIM_Process_Class.CSName
253 mike 1.1 //
254
255 const Field<String>& CSName() const
256 {
257 const size_t n = offsetof(Self, CSName);
258 return GetField<String>(n);
259 }
260
261 void CSName(const Field<String>& x)
262 {
263 const size_t n = offsetof(Self, CSName);
264 GetField<String>(n) = x;
265 }
266
267 const String& CSName_value() const
268 {
269 const size_t n = offsetof(Self, CSName);
270 return GetField<String>(n).value;
271 }
272
273 void CSName_value(const String& x)
274 mike 1.1 {
275 const size_t n = offsetof(Self, CSName);
276 GetField<String>(n).Set(x);
277 }
278
279 bool CSName_exists() const
280 {
281 const size_t n = offsetof(Self, CSName);
282 return GetField<String>(n).exists ? true : false;
283 }
284
285 void CSName_clear()
286 {
287 const size_t n = offsetof(Self, CSName);
288 GetField<String>(n).Clear();
289 }
290
291 //
292 // CIM_Process_Class.OSCreationClassName
293 //
294
295 mike 1.1 const Field<String>& OSCreationClassName() const
296 {
297 const size_t n = offsetof(Self, OSCreationClassName);
298 return GetField<String>(n);
299 }
300
301 void OSCreationClassName(const Field<String>& x)
302 {
303 const size_t n = offsetof(Self, OSCreationClassName);
304 GetField<String>(n) = x;
305 }
306
307 const String& OSCreationClassName_value() const
308 {
309 const size_t n = offsetof(Self, OSCreationClassName);
310 return GetField<String>(n).value;
311 }
312
313 void OSCreationClassName_value(const String& x)
314 {
315 const size_t n = offsetof(Self, OSCreationClassName);
316 mike 1.1 GetField<String>(n).Set(x);
317 }
318
319 bool OSCreationClassName_exists() const
320 {
321 const size_t n = offsetof(Self, OSCreationClassName);
322 return GetField<String>(n).exists ? true : false;
323 }
324
325 void OSCreationClassName_clear()
326 {
327 const size_t n = offsetof(Self, OSCreationClassName);
328 GetField<String>(n).Clear();
329 }
330
331 //
332 // CIM_Process_Class.OSName
333 //
334
335 const Field<String>& OSName() const
336 {
337 mike 1.1 const size_t n = offsetof(Self, OSName);
338 return GetField<String>(n);
339 }
340
341 void OSName(const Field<String>& x)
342 {
343 const size_t n = offsetof(Self, OSName);
344 GetField<String>(n) = x;
345 }
346
347 const String& OSName_value() const
348 {
349 const size_t n = offsetof(Self, OSName);
350 return GetField<String>(n).value;
351 }
352
353 void OSName_value(const String& x)
354 {
355 const size_t n = offsetof(Self, OSName);
356 GetField<String>(n).Set(x);
357 }
358 mike 1.1
359 bool OSName_exists() const
360 {
361 const size_t n = offsetof(Self, OSName);
362 return GetField<String>(n).exists ? true : false;
363 }
364
365 void OSName_clear()
366 {
367 const size_t n = offsetof(Self, OSName);
368 GetField<String>(n).Clear();
369 }
370
371 //
372 // CIM_Process_Class.CreationClassName
373 //
374
375 const Field<String>& CreationClassName() const
376 {
377 const size_t n = offsetof(Self, CreationClassName);
378 return GetField<String>(n);
379 mike 1.1 }
380
381 void CreationClassName(const Field<String>& x)
382 {
383 const size_t n = offsetof(Self, CreationClassName);
384 GetField<String>(n) = x;
385 }
386
387 const String& CreationClassName_value() const
388 {
389 const size_t n = offsetof(Self, CreationClassName);
390 return GetField<String>(n).value;
391 }
392
393 void CreationClassName_value(const String& x)
394 {
395 const size_t n = offsetof(Self, CreationClassName);
396 GetField<String>(n).Set(x);
397 }
398
399 bool CreationClassName_exists() const
400 mike 1.1 {
401 const size_t n = offsetof(Self, CreationClassName);
402 return GetField<String>(n).exists ? true : false;
403 }
404
405 void CreationClassName_clear()
406 {
407 const size_t n = offsetof(Self, CreationClassName);
408 GetField<String>(n).Clear();
409 }
410
411 //
412 // CIM_Process_Class.Handle
413 //
414
415 const Field<String>& Handle() const
416 {
417 const size_t n = offsetof(Self, Handle);
418 return GetField<String>(n);
419 }
420
421 mike 1.1 void Handle(const Field<String>& x)
422 {
423 const size_t n = offsetof(Self, Handle);
424 GetField<String>(n) = x;
425 }
426
427 const String& Handle_value() const
428 {
429 const size_t n = offsetof(Self, Handle);
430 return GetField<String>(n).value;
431 }
432
433 void Handle_value(const String& x)
434 {
435 const size_t n = offsetof(Self, Handle);
436 GetField<String>(n).Set(x);
437 }
438
439 bool Handle_exists() const
440 {
441 const size_t n = offsetof(Self, Handle);
442 mike 1.1 return GetField<String>(n).exists ? true : false;
443 }
444
445 void Handle_clear()
446 {
447 const size_t n = offsetof(Self, Handle);
448 GetField<String>(n).Clear();
449 }
450
451 //
452 // CIM_Process_Class.Priority
453 //
454
455 const Field<Uint32>& Priority() const
456 {
457 const size_t n = offsetof(Self, Priority);
458 return GetField<Uint32>(n);
459 }
460
461 void Priority(const Field<Uint32>& x)
462 {
463 mike 1.1 const size_t n = offsetof(Self, Priority);
464 GetField<Uint32>(n) = x;
465 }
466
467 const Uint32& Priority_value() const
468 {
469 const size_t n = offsetof(Self, Priority);
470 return GetField<Uint32>(n).value;
471 }
472
473 void Priority_value(const Uint32& x)
474 {
475 const size_t n = offsetof(Self, Priority);
476 GetField<Uint32>(n).Set(x);
477 }
478
479 bool Priority_exists() const
480 {
481 const size_t n = offsetof(Self, Priority);
482 return GetField<Uint32>(n).exists ? true : false;
483 }
484 mike 1.1
485 void Priority_clear()
486 {
487 const size_t n = offsetof(Self, Priority);
488 GetField<Uint32>(n).Clear();
489 }
490
491 //
492 // CIM_Process_Class.ExecutionState
493 //
494
495 const Field<Uint16>& ExecutionState() const
496 {
497 const size_t n = offsetof(Self, ExecutionState);
498 return GetField<Uint16>(n);
499 }
500
501 void ExecutionState(const Field<Uint16>& x)
502 {
503 const size_t n = offsetof(Self, ExecutionState);
504 GetField<Uint16>(n) = x;
505 mike 1.1 }
506
507 const Uint16& ExecutionState_value() const
508 {
509 const size_t n = offsetof(Self, ExecutionState);
510 return GetField<Uint16>(n).value;
511 }
512
513 void ExecutionState_value(const Uint16& x)
514 {
515 const size_t n = offsetof(Self, ExecutionState);
516 GetField<Uint16>(n).Set(x);
517 }
518
519 bool ExecutionState_exists() const
520 {
521 const size_t n = offsetof(Self, ExecutionState);
522 return GetField<Uint16>(n).exists ? true : false;
523 }
524
525 void ExecutionState_clear()
526 mike 1.1 {
527 const size_t n = offsetof(Self, ExecutionState);
528 GetField<Uint16>(n).Clear();
529 }
530
531 //
532 // CIM_Process_Class.OtherExecutionDescription
533 //
534
535 const Field<String>& OtherExecutionDescription() const
536 {
537 const size_t n = offsetof(Self, OtherExecutionDescription);
538 return GetField<String>(n);
539 }
540
541 void OtherExecutionDescription(const Field<String>& x)
542 {
543 const size_t n = offsetof(Self, OtherExecutionDescription);
544 GetField<String>(n) = x;
545 }
546
547 mike 1.1 const String& OtherExecutionDescription_value() const
548 {
549 const size_t n = offsetof(Self, OtherExecutionDescription);
550 return GetField<String>(n).value;
551 }
552
553 void OtherExecutionDescription_value(const String& x)
554 {
555 const size_t n = offsetof(Self, OtherExecutionDescription);
556 GetField<String>(n).Set(x);
557 }
558
559 bool OtherExecutionDescription_exists() const
560 {
561 const size_t n = offsetof(Self, OtherExecutionDescription);
562 return GetField<String>(n).exists ? true : false;
563 }
564
565 void OtherExecutionDescription_clear()
566 {
567 const size_t n = offsetof(Self, OtherExecutionDescription);
568 mike 1.1 GetField<String>(n).Clear();
569 }
570
571 //
572 // CIM_Process_Class.CreationDate
573 //
574
575 const Field<Datetime>& CreationDate() const
576 {
577 const size_t n = offsetof(Self, CreationDate);
578 return GetField<Datetime>(n);
579 }
580
581 void CreationDate(const Field<Datetime>& x)
582 {
583 const size_t n = offsetof(Self, CreationDate);
584 GetField<Datetime>(n) = x;
585 }
586
587 const Datetime& CreationDate_value() const
588 {
589 mike 1.1 const size_t n = offsetof(Self, CreationDate);
590 return GetField<Datetime>(n).value;
591 }
592
593 void CreationDate_value(const Datetime& x)
594 {
595 const size_t n = offsetof(Self, CreationDate);
596 GetField<Datetime>(n).Set(x);
597 }
598
599 bool CreationDate_exists() const
600 {
601 const size_t n = offsetof(Self, CreationDate);
602 return GetField<Datetime>(n).exists ? true : false;
603 }
604
605 void CreationDate_clear()
606 {
607 const size_t n = offsetof(Self, CreationDate);
608 GetField<Datetime>(n).Clear();
609 }
610 mike 1.1
611 //
612 // CIM_Process_Class.TerminationDate
613 //
614
615 const Field<Datetime>& TerminationDate() const
616 {
617 const size_t n = offsetof(Self, TerminationDate);
618 return GetField<Datetime>(n);
619 }
620
621 void TerminationDate(const Field<Datetime>& x)
622 {
623 const size_t n = offsetof(Self, TerminationDate);
624 GetField<Datetime>(n) = x;
625 }
626
627 const Datetime& TerminationDate_value() const
628 {
629 const size_t n = offsetof(Self, TerminationDate);
630 return GetField<Datetime>(n).value;
631 mike 1.1 }
632
633 void TerminationDate_value(const Datetime& x)
634 {
635 const size_t n = offsetof(Self, TerminationDate);
636 GetField<Datetime>(n).Set(x);
637 }
638
639 bool TerminationDate_exists() const
640 {
641 const size_t n = offsetof(Self, TerminationDate);
642 return GetField<Datetime>(n).exists ? true : false;
643 }
644
645 void TerminationDate_clear()
646 {
647 const size_t n = offsetof(Self, TerminationDate);
648 GetField<Datetime>(n).Clear();
649 }
650
651 //
652 mike 1.1 // CIM_Process_Class.KernelModeTime
653 //
654
655 const Field<Uint64>& KernelModeTime() const
656 {
657 const size_t n = offsetof(Self, KernelModeTime);
658 return GetField<Uint64>(n);
659 }
660
661 void KernelModeTime(const Field<Uint64>& x)
662 {
663 const size_t n = offsetof(Self, KernelModeTime);
664 GetField<Uint64>(n) = x;
665 }
666
667 const Uint64& KernelModeTime_value() const
668 {
669 const size_t n = offsetof(Self, KernelModeTime);
670 return GetField<Uint64>(n).value;
671 }
672
673 mike 1.1 void KernelModeTime_value(const Uint64& x)
674 {
675 const size_t n = offsetof(Self, KernelModeTime);
676 GetField<Uint64>(n).Set(x);
677 }
678
679 bool KernelModeTime_exists() const
680 {
681 const size_t n = offsetof(Self, KernelModeTime);
682 return GetField<Uint64>(n).exists ? true : false;
683 }
684
685 void KernelModeTime_clear()
686 {
687 const size_t n = offsetof(Self, KernelModeTime);
688 GetField<Uint64>(n).Clear();
689 }
690
691 //
692 // CIM_Process_Class.UserModeTime
693 //
694 mike 1.1
695 const Field<Uint64>& UserModeTime() const
696 {
697 const size_t n = offsetof(Self, UserModeTime);
698 return GetField<Uint64>(n);
699 }
700
701 void UserModeTime(const Field<Uint64>& x)
702 {
703 const size_t n = offsetof(Self, UserModeTime);
704 GetField<Uint64>(n) = x;
705 }
706
707 const Uint64& UserModeTime_value() const
708 {
709 const size_t n = offsetof(Self, UserModeTime);
710 return GetField<Uint64>(n).value;
711 }
712
713 void UserModeTime_value(const Uint64& x)
714 {
715 mike 1.1 const size_t n = offsetof(Self, UserModeTime);
716 GetField<Uint64>(n).Set(x);
717 }
718
719 bool UserModeTime_exists() const
720 {
721 const size_t n = offsetof(Self, UserModeTime);
722 return GetField<Uint64>(n).exists ? true : false;
723 }
724
725 void UserModeTime_clear()
726 {
727 const size_t n = offsetof(Self, UserModeTime);
728 GetField<Uint64>(n).Clear();
729 }
730
731 //
732 // CIM_Process_Class.WorkingSetSize
733 //
734
735 const Field<Uint64>& WorkingSetSize() const
736 mike 1.1 {
737 const size_t n = offsetof(Self, WorkingSetSize);
738 return GetField<Uint64>(n);
739 }
740
741 void WorkingSetSize(const Field<Uint64>& x)
742 {
743 const size_t n = offsetof(Self, WorkingSetSize);
744 GetField<Uint64>(n) = x;
745 }
746
747 const Uint64& WorkingSetSize_value() const
748 {
749 const size_t n = offsetof(Self, WorkingSetSize);
750 return GetField<Uint64>(n).value;
751 }
752
753 void WorkingSetSize_value(const Uint64& x)
754 {
755 const size_t n = offsetof(Self, WorkingSetSize);
756 GetField<Uint64>(n).Set(x);
757 mike 1.1 }
758
759 bool WorkingSetSize_exists() const
760 {
761 const size_t n = offsetof(Self, WorkingSetSize);
762 return GetField<Uint64>(n).exists ? true : false;
763 }
764
765 void WorkingSetSize_clear()
766 {
767 const size_t n = offsetof(Self, WorkingSetSize);
768 GetField<Uint64>(n).Clear();
769 }
770 };
771
772 typedef Array<CIM_Process_Class> CIM_Process_ClassA;
773
774 MI_END_NAMESPACE
775
776 #endif /* __cplusplus */
777
778 mike 1.1 #endif /* _CIM_Process_h */
|
Return to
CIM_Process.h
CVS log
Up to [OMI] / omi / base / tests