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_ManagedSystemElement_h
10 #define _CIM_ManagedSystemElement_h
11
12 #include <MI.h>
13 #include "CIM_ManagedElement.h"
14
15 /*
16 **==============================================================================
17 **
18 ** CIM_ManagedSystemElement [CIM_ManagedSystemElement]
19 **
20 ** Keys:
21 **
22 mike 1.1 **==============================================================================
23 */
24
25 typedef struct _CIM_ManagedSystemElement /* extends CIM_ManagedElement */
26 {
27 MI_Instance __instance;
28 /* CIM_ManagedElement properties */
29 MI_ConstStringField InstanceID;
30 MI_ConstStringField Caption;
31 MI_ConstStringField Description;
32 MI_ConstStringField ElementName;
33 /* CIM_ManagedSystemElement properties */
34 MI_ConstDatetimeField InstallDate;
35 MI_ConstStringField Name;
36 MI_ConstUint16AField OperationalStatus;
37 MI_ConstStringAField StatusDescriptions;
38 MI_ConstStringField Status;
39 MI_ConstUint16Field HealthState;
40 MI_ConstUint16Field CommunicationStatus;
41 MI_ConstUint16Field DetailedStatus;
42 MI_ConstUint16Field OperatingStatus;
43 mike 1.1 MI_ConstUint16Field PrimaryStatus;
44 }
45 CIM_ManagedSystemElement;
46
47 typedef struct _CIM_ManagedSystemElement_Ref
48 {
49 CIM_ManagedSystemElement* value;
50 MI_Boolean exists;
51 MI_Uint8 flags;
52 }
53 CIM_ManagedSystemElement_Ref;
54
55 typedef struct _CIM_ManagedSystemElement_ConstRef
56 {
57 MI_CONST CIM_ManagedSystemElement* value;
58 MI_Boolean exists;
59 MI_Uint8 flags;
60 }
61 CIM_ManagedSystemElement_ConstRef;
62
63 typedef struct _CIM_ManagedSystemElement_Array
64 mike 1.1 {
65 struct _CIM_ManagedSystemElement** data;
66 MI_Uint32 size;
67 }
68 CIM_ManagedSystemElement_Array;
69
70 typedef struct _CIM_ManagedSystemElement_ConstArray
71 {
72 struct _CIM_ManagedSystemElement MI_CONST* MI_CONST* data;
73 MI_Uint32 size;
74 }
75 CIM_ManagedSystemElement_ConstArray;
76
77 typedef struct _CIM_ManagedSystemElement_ArrayRef
78 {
79 CIM_ManagedSystemElement_Array value;
80 MI_Boolean exists;
81 MI_Uint8 flags;
82 }
83 CIM_ManagedSystemElement_ArrayRef;
84
85 mike 1.1 typedef struct _CIM_ManagedSystemElement_ConstArrayRef
86 {
87 CIM_ManagedSystemElement_ConstArray value;
88 MI_Boolean exists;
89 MI_Uint8 flags;
90 }
91 CIM_ManagedSystemElement_ConstArrayRef;
92
93 MI_EXTERN_C MI_CONST MI_ClassDecl CIM_ManagedSystemElement_rtti;
94
95
96 /*
97 **==============================================================================
98 **
99 ** CIM_ManagedSystemElement_Class
100 **
101 **==============================================================================
102 */
103
104 #ifdef __cplusplus
105 # include <micxx/micxx.h>
106 mike 1.1
107 MI_BEGIN_NAMESPACE
108
109 class CIM_ManagedSystemElement_Class : public CIM_ManagedElement_Class
110 {
111 public:
112
113 typedef CIM_ManagedSystemElement Self;
114
115 CIM_ManagedSystemElement_Class() :
116 CIM_ManagedElement_Class(&CIM_ManagedSystemElement_rtti)
117 {
118 }
119
120 CIM_ManagedSystemElement_Class(
121 const CIM_ManagedSystemElement* instanceName,
122 bool keysOnly) :
123 CIM_ManagedElement_Class(
124 &CIM_ManagedSystemElement_rtti,
125 &instanceName->__instance,
126 keysOnly)
127 mike 1.1 {
128 }
129
130 CIM_ManagedSystemElement_Class(
131 const MI_ClassDecl* clDecl,
132 const MI_Instance* instance,
133 bool keysOnly) :
134 CIM_ManagedElement_Class(clDecl, instance, keysOnly)
135 {
136 }
137
138 CIM_ManagedSystemElement_Class(
139 const MI_ClassDecl* clDecl) :
140 CIM_ManagedElement_Class(clDecl)
141 {
142 }
143
144 CIM_ManagedSystemElement_Class& operator=(
145 const CIM_ManagedSystemElement_Class& x)
146 {
147 CopyRef(x);
148 mike 1.1 return *this;
149 }
150
151 CIM_ManagedSystemElement_Class(
152 const CIM_ManagedSystemElement_Class& x) :
153 CIM_ManagedElement_Class(x)
154 {
155 }
156
157 static const MI_ClassDecl* GetClassDecl()
158 {
159 return &CIM_ManagedSystemElement_rtti;
160 }
161
162 //
163 // CIM_ManagedSystemElement_Class.InstallDate
164 //
165
166 const Field<Datetime>& InstallDate() const
167 {
168 const size_t n = offsetof(Self, InstallDate);
169 mike 1.1 return GetField<Datetime>(n);
170 }
171
172 void InstallDate(const Field<Datetime>& x)
173 {
174 const size_t n = offsetof(Self, InstallDate);
175 GetField<Datetime>(n) = x;
176 }
177
178 const Datetime& InstallDate_value() const
179 {
180 const size_t n = offsetof(Self, InstallDate);
181 return GetField<Datetime>(n).value;
182 }
183
184 void InstallDate_value(const Datetime& x)
185 {
186 const size_t n = offsetof(Self, InstallDate);
187 GetField<Datetime>(n).Set(x);
188 }
189
190 mike 1.1 bool InstallDate_exists() const
191 {
192 const size_t n = offsetof(Self, InstallDate);
193 return GetField<Datetime>(n).exists ? true : false;
194 }
195
196 void InstallDate_clear()
197 {
198 const size_t n = offsetof(Self, InstallDate);
199 GetField<Datetime>(n).Clear();
200 }
201
202 //
203 // CIM_ManagedSystemElement_Class.Name
204 //
205
206 const Field<String>& Name() const
207 {
208 const size_t n = offsetof(Self, Name);
209 return GetField<String>(n);
210 }
211 mike 1.1
212 void Name(const Field<String>& x)
213 {
214 const size_t n = offsetof(Self, Name);
215 GetField<String>(n) = x;
216 }
217
218 const String& Name_value() const
219 {
220 const size_t n = offsetof(Self, Name);
221 return GetField<String>(n).value;
222 }
223
224 void Name_value(const String& x)
225 {
226 const size_t n = offsetof(Self, Name);
227 GetField<String>(n).Set(x);
228 }
229
230 bool Name_exists() const
231 {
232 mike 1.1 const size_t n = offsetof(Self, Name);
233 return GetField<String>(n).exists ? true : false;
234 }
235
236 void Name_clear()
237 {
238 const size_t n = offsetof(Self, Name);
239 GetField<String>(n).Clear();
240 }
241
242 //
243 // CIM_ManagedSystemElement_Class.OperationalStatus
244 //
245
246 const Field<Uint16A>& OperationalStatus() const
247 {
248 const size_t n = offsetof(Self, OperationalStatus);
249 return GetField<Uint16A>(n);
250 }
251
252 void OperationalStatus(const Field<Uint16A>& x)
253 mike 1.1 {
254 const size_t n = offsetof(Self, OperationalStatus);
255 GetField<Uint16A>(n) = x;
256 }
257
258 const Uint16A& OperationalStatus_value() const
259 {
260 const size_t n = offsetof(Self, OperationalStatus);
261 return GetField<Uint16A>(n).value;
262 }
263
264 void OperationalStatus_value(const Uint16A& x)
265 {
266 const size_t n = offsetof(Self, OperationalStatus);
267 GetField<Uint16A>(n).Set(x);
268 }
269
270 bool OperationalStatus_exists() const
271 {
272 const size_t n = offsetof(Self, OperationalStatus);
273 return GetField<Uint16A>(n).exists ? true : false;
274 mike 1.1 }
275
276 void OperationalStatus_clear()
277 {
278 const size_t n = offsetof(Self, OperationalStatus);
279 GetField<Uint16A>(n).Clear();
280 }
281
282 //
283 // CIM_ManagedSystemElement_Class.StatusDescriptions
284 //
285
286 const Field<StringA>& StatusDescriptions() const
287 {
288 const size_t n = offsetof(Self, StatusDescriptions);
289 return GetField<StringA>(n);
290 }
291
292 void StatusDescriptions(const Field<StringA>& x)
293 {
294 const size_t n = offsetof(Self, StatusDescriptions);
295 mike 1.1 GetField<StringA>(n) = x;
296 }
297
298 const StringA& StatusDescriptions_value() const
299 {
300 const size_t n = offsetof(Self, StatusDescriptions);
301 return GetField<StringA>(n).value;
302 }
303
304 void StatusDescriptions_value(const StringA& x)
305 {
306 const size_t n = offsetof(Self, StatusDescriptions);
307 GetField<StringA>(n).Set(x);
308 }
309
310 bool StatusDescriptions_exists() const
311 {
312 const size_t n = offsetof(Self, StatusDescriptions);
313 return GetField<StringA>(n).exists ? true : false;
314 }
315
316 mike 1.1 void StatusDescriptions_clear()
317 {
318 const size_t n = offsetof(Self, StatusDescriptions);
319 GetField<StringA>(n).Clear();
320 }
321
322 //
323 // CIM_ManagedSystemElement_Class.Status
324 //
325
326 const Field<String>& Status() const
327 {
328 const size_t n = offsetof(Self, Status);
329 return GetField<String>(n);
330 }
331
332 void Status(const Field<String>& x)
333 {
334 const size_t n = offsetof(Self, Status);
335 GetField<String>(n) = x;
336 }
337 mike 1.1
338 const String& Status_value() const
339 {
340 const size_t n = offsetof(Self, Status);
341 return GetField<String>(n).value;
342 }
343
344 void Status_value(const String& x)
345 {
346 const size_t n = offsetof(Self, Status);
347 GetField<String>(n).Set(x);
348 }
349
350 bool Status_exists() const
351 {
352 const size_t n = offsetof(Self, Status);
353 return GetField<String>(n).exists ? true : false;
354 }
355
356 void Status_clear()
357 {
358 mike 1.1 const size_t n = offsetof(Self, Status);
359 GetField<String>(n).Clear();
360 }
361
362 //
363 // CIM_ManagedSystemElement_Class.HealthState
364 //
365
366 const Field<Uint16>& HealthState() const
367 {
368 const size_t n = offsetof(Self, HealthState);
369 return GetField<Uint16>(n);
370 }
371
372 void HealthState(const Field<Uint16>& x)
373 {
374 const size_t n = offsetof(Self, HealthState);
375 GetField<Uint16>(n) = x;
376 }
377
378 const Uint16& HealthState_value() const
379 mike 1.1 {
380 const size_t n = offsetof(Self, HealthState);
381 return GetField<Uint16>(n).value;
382 }
383
384 void HealthState_value(const Uint16& x)
385 {
386 const size_t n = offsetof(Self, HealthState);
387 GetField<Uint16>(n).Set(x);
388 }
389
390 bool HealthState_exists() const
391 {
392 const size_t n = offsetof(Self, HealthState);
393 return GetField<Uint16>(n).exists ? true : false;
394 }
395
396 void HealthState_clear()
397 {
398 const size_t n = offsetof(Self, HealthState);
399 GetField<Uint16>(n).Clear();
400 mike 1.1 }
401
402 //
403 // CIM_ManagedSystemElement_Class.CommunicationStatus
404 //
405
406 const Field<Uint16>& CommunicationStatus() const
407 {
408 const size_t n = offsetof(Self, CommunicationStatus);
409 return GetField<Uint16>(n);
410 }
411
412 void CommunicationStatus(const Field<Uint16>& x)
413 {
414 const size_t n = offsetof(Self, CommunicationStatus);
415 GetField<Uint16>(n) = x;
416 }
417
418 const Uint16& CommunicationStatus_value() const
419 {
420 const size_t n = offsetof(Self, CommunicationStatus);
421 mike 1.1 return GetField<Uint16>(n).value;
422 }
423
424 void CommunicationStatus_value(const Uint16& x)
425 {
426 const size_t n = offsetof(Self, CommunicationStatus);
427 GetField<Uint16>(n).Set(x);
428 }
429
430 bool CommunicationStatus_exists() const
431 {
432 const size_t n = offsetof(Self, CommunicationStatus);
433 return GetField<Uint16>(n).exists ? true : false;
434 }
435
436 void CommunicationStatus_clear()
437 {
438 const size_t n = offsetof(Self, CommunicationStatus);
439 GetField<Uint16>(n).Clear();
440 }
441
442 mike 1.1 //
443 // CIM_ManagedSystemElement_Class.DetailedStatus
444 //
445
446 const Field<Uint16>& DetailedStatus() const
447 {
448 const size_t n = offsetof(Self, DetailedStatus);
449 return GetField<Uint16>(n);
450 }
451
452 void DetailedStatus(const Field<Uint16>& x)
453 {
454 const size_t n = offsetof(Self, DetailedStatus);
455 GetField<Uint16>(n) = x;
456 }
457
458 const Uint16& DetailedStatus_value() const
459 {
460 const size_t n = offsetof(Self, DetailedStatus);
461 return GetField<Uint16>(n).value;
462 }
463 mike 1.1
464 void DetailedStatus_value(const Uint16& x)
465 {
466 const size_t n = offsetof(Self, DetailedStatus);
467 GetField<Uint16>(n).Set(x);
468 }
469
470 bool DetailedStatus_exists() const
471 {
472 const size_t n = offsetof(Self, DetailedStatus);
473 return GetField<Uint16>(n).exists ? true : false;
474 }
475
476 void DetailedStatus_clear()
477 {
478 const size_t n = offsetof(Self, DetailedStatus);
479 GetField<Uint16>(n).Clear();
480 }
481
482 //
483 // CIM_ManagedSystemElement_Class.OperatingStatus
484 mike 1.1 //
485
486 const Field<Uint16>& OperatingStatus() const
487 {
488 const size_t n = offsetof(Self, OperatingStatus);
489 return GetField<Uint16>(n);
490 }
491
492 void OperatingStatus(const Field<Uint16>& x)
493 {
494 const size_t n = offsetof(Self, OperatingStatus);
495 GetField<Uint16>(n) = x;
496 }
497
498 const Uint16& OperatingStatus_value() const
499 {
500 const size_t n = offsetof(Self, OperatingStatus);
501 return GetField<Uint16>(n).value;
502 }
503
504 void OperatingStatus_value(const Uint16& x)
505 mike 1.1 {
506 const size_t n = offsetof(Self, OperatingStatus);
507 GetField<Uint16>(n).Set(x);
508 }
509
510 bool OperatingStatus_exists() const
511 {
512 const size_t n = offsetof(Self, OperatingStatus);
513 return GetField<Uint16>(n).exists ? true : false;
514 }
515
516 void OperatingStatus_clear()
517 {
518 const size_t n = offsetof(Self, OperatingStatus);
519 GetField<Uint16>(n).Clear();
520 }
521
522 //
523 // CIM_ManagedSystemElement_Class.PrimaryStatus
524 //
525
526 mike 1.1 const Field<Uint16>& PrimaryStatus() const
527 {
528 const size_t n = offsetof(Self, PrimaryStatus);
529 return GetField<Uint16>(n);
530 }
531
532 void PrimaryStatus(const Field<Uint16>& x)
533 {
534 const size_t n = offsetof(Self, PrimaryStatus);
535 GetField<Uint16>(n) = x;
536 }
537
538 const Uint16& PrimaryStatus_value() const
539 {
540 const size_t n = offsetof(Self, PrimaryStatus);
541 return GetField<Uint16>(n).value;
542 }
543
544 void PrimaryStatus_value(const Uint16& x)
545 {
546 const size_t n = offsetof(Self, PrimaryStatus);
547 mike 1.1 GetField<Uint16>(n).Set(x);
548 }
549
550 bool PrimaryStatus_exists() const
551 {
552 const size_t n = offsetof(Self, PrimaryStatus);
553 return GetField<Uint16>(n).exists ? true : false;
554 }
555
556 void PrimaryStatus_clear()
557 {
558 const size_t n = offsetof(Self, PrimaryStatus);
559 GetField<Uint16>(n).Clear();
560 }
561 };
562
563 typedef Array<CIM_ManagedSystemElement_Class> CIM_ManagedSystemElement_ClassA;
564
565 MI_END_NAMESPACE
566
567 #endif /* __cplusplus */
568 mike 1.1
569 #endif /* _CIM_ManagedSystemElement_h */
|
Return to
CIM_ManagedSystemElement.h
CVS log
Up to [OMI] / omi / base / tests