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_Error_h
10 #define _CIM_Error_h
11
12 #include <MI.h>
13
14 /*
15 **==============================================================================
16 **
17 ** CIM_Error [CIM_Error]
18 **
19 ** Keys:
20 **
21 **==============================================================================
22 mike 1.1 */
23
24 typedef struct _CIM_Error
25 {
26 MI_Instance __instance;
27 /* CIM_Error properties */
28 MI_ConstUint16Field ErrorType;
29 MI_ConstStringField OtherErrorType;
30 MI_ConstStringField OwningEntity;
31 MI_ConstStringField MessageID;
32 MI_ConstStringField Message;
33 MI_ConstStringAField MessageArguments;
34 MI_ConstUint16Field PerceivedSeverity;
35 MI_ConstUint16Field ProbableCause;
36 MI_ConstStringField ProbableCauseDescription;
37 MI_ConstStringAField RecommendedActions;
38 MI_ConstStringField ErrorSource;
39 MI_ConstUint16Field ErrorSourceFormat;
40 MI_ConstStringField OtherErrorSourceFormat;
41 MI_ConstUint32Field CIMStatusCode;
42 MI_ConstStringField CIMStatusCodeDescription;
43 mike 1.1 }
44 CIM_Error;
45
46 typedef struct _CIM_Error_Ref
47 {
48 CIM_Error* value;
49 MI_Boolean exists;
50 MI_Uint8 flags;
51 }
52 CIM_Error_Ref;
53
54 typedef struct _CIM_Error_ConstRef
55 {
56 MI_CONST CIM_Error* value;
57 MI_Boolean exists;
58 MI_Uint8 flags;
59 }
60 CIM_Error_ConstRef;
61
62 typedef struct _CIM_Error_Array
63 {
64 mike 1.1 struct _CIM_Error** data;
65 MI_Uint32 size;
66 }
67 CIM_Error_Array;
68
69 typedef struct _CIM_Error_ConstArray
70 {
71 struct _CIM_Error MI_CONST* MI_CONST* data;
72 MI_Uint32 size;
73 }
74 CIM_Error_ConstArray;
75
76 typedef struct _CIM_Error_ArrayRef
77 {
78 CIM_Error_Array value;
79 MI_Boolean exists;
80 MI_Uint8 flags;
81 }
82 CIM_Error_ArrayRef;
83
84 typedef struct _CIM_Error_ConstArrayRef
85 mike 1.1 {
86 CIM_Error_ConstArray value;
87 MI_Boolean exists;
88 MI_Uint8 flags;
89 }
90 CIM_Error_ConstArrayRef;
91
92 MI_EXTERN_C MI_CONST MI_ClassDecl CIM_Error_rtti;
93
94
95 /*
96 **==============================================================================
97 **
98 ** CIM_Error_Class
99 **
100 **==============================================================================
101 */
102
103 #ifdef __cplusplus
104 # include <micxx/micxx.h>
105
106 mike 1.1 MI_BEGIN_NAMESPACE
107
108 class CIM_Error_Class : public Instance
109 {
110 public:
111
112 typedef CIM_Error Self;
113
114 CIM_Error_Class() :
115 Instance(&CIM_Error_rtti)
116 {
117 }
118
119 CIM_Error_Class(
120 const CIM_Error* instanceName,
121 bool keysOnly) :
122 Instance(
123 &CIM_Error_rtti,
124 &instanceName->__instance,
125 keysOnly)
126 {
127 mike 1.1 }
128
129 CIM_Error_Class(
130 const MI_ClassDecl* clDecl,
131 const MI_Instance* instance,
132 bool keysOnly) :
133 Instance(clDecl, instance, keysOnly)
134 {
135 }
136
137 CIM_Error_Class(
138 const MI_ClassDecl* clDecl) :
139 Instance(clDecl)
140 {
141 }
142
143 CIM_Error_Class& operator=(
144 const CIM_Error_Class& x)
145 {
146 CopyRef(x);
147 return *this;
148 mike 1.1 }
149
150 CIM_Error_Class(
151 const CIM_Error_Class& x) :
152 Instance(x)
153 {
154 }
155
156 static const MI_ClassDecl* GetClassDecl()
157 {
158 return &CIM_Error_rtti;
159 }
160
161 //
162 // CIM_Error_Class.ErrorType
163 //
164
165 const Field<Uint16>& ErrorType() const
166 {
167 const size_t n = offsetof(Self, ErrorType);
168 return GetField<Uint16>(n);
169 mike 1.1 }
170
171 void ErrorType(const Field<Uint16>& x)
172 {
173 const size_t n = offsetof(Self, ErrorType);
174 GetField<Uint16>(n) = x;
175 }
176
177 const Uint16& ErrorType_value() const
178 {
179 const size_t n = offsetof(Self, ErrorType);
180 return GetField<Uint16>(n).value;
181 }
182
183 void ErrorType_value(const Uint16& x)
184 {
185 const size_t n = offsetof(Self, ErrorType);
186 GetField<Uint16>(n).Set(x);
187 }
188
189 bool ErrorType_exists() const
190 mike 1.1 {
191 const size_t n = offsetof(Self, ErrorType);
192 return GetField<Uint16>(n).exists ? true : false;
193 }
194
195 void ErrorType_clear()
196 {
197 const size_t n = offsetof(Self, ErrorType);
198 GetField<Uint16>(n).Clear();
199 }
200
201 //
202 // CIM_Error_Class.OtherErrorType
203 //
204
205 const Field<String>& OtherErrorType() const
206 {
207 const size_t n = offsetof(Self, OtherErrorType);
208 return GetField<String>(n);
209 }
210
211 mike 1.1 void OtherErrorType(const Field<String>& x)
212 {
213 const size_t n = offsetof(Self, OtherErrorType);
214 GetField<String>(n) = x;
215 }
216
217 const String& OtherErrorType_value() const
218 {
219 const size_t n = offsetof(Self, OtherErrorType);
220 return GetField<String>(n).value;
221 }
222
223 void OtherErrorType_value(const String& x)
224 {
225 const size_t n = offsetof(Self, OtherErrorType);
226 GetField<String>(n).Set(x);
227 }
228
229 bool OtherErrorType_exists() const
230 {
231 const size_t n = offsetof(Self, OtherErrorType);
232 mike 1.1 return GetField<String>(n).exists ? true : false;
233 }
234
235 void OtherErrorType_clear()
236 {
237 const size_t n = offsetof(Self, OtherErrorType);
238 GetField<String>(n).Clear();
239 }
240
241 //
242 // CIM_Error_Class.OwningEntity
243 //
244
245 const Field<String>& OwningEntity() const
246 {
247 const size_t n = offsetof(Self, OwningEntity);
248 return GetField<String>(n);
249 }
250
251 void OwningEntity(const Field<String>& x)
252 {
253 mike 1.1 const size_t n = offsetof(Self, OwningEntity);
254 GetField<String>(n) = x;
255 }
256
257 const String& OwningEntity_value() const
258 {
259 const size_t n = offsetof(Self, OwningEntity);
260 return GetField<String>(n).value;
261 }
262
263 void OwningEntity_value(const String& x)
264 {
265 const size_t n = offsetof(Self, OwningEntity);
266 GetField<String>(n).Set(x);
267 }
268
269 bool OwningEntity_exists() const
270 {
271 const size_t n = offsetof(Self, OwningEntity);
272 return GetField<String>(n).exists ? true : false;
273 }
274 mike 1.1
275 void OwningEntity_clear()
276 {
277 const size_t n = offsetof(Self, OwningEntity);
278 GetField<String>(n).Clear();
279 }
280
281 //
282 // CIM_Error_Class.MessageID
283 //
284
285 const Field<String>& MessageID() const
286 {
287 const size_t n = offsetof(Self, MessageID);
288 return GetField<String>(n);
289 }
290
291 void MessageID(const Field<String>& x)
292 {
293 const size_t n = offsetof(Self, MessageID);
294 GetField<String>(n) = x;
295 mike 1.1 }
296
297 const String& MessageID_value() const
298 {
299 const size_t n = offsetof(Self, MessageID);
300 return GetField<String>(n).value;
301 }
302
303 void MessageID_value(const String& x)
304 {
305 const size_t n = offsetof(Self, MessageID);
306 GetField<String>(n).Set(x);
307 }
308
309 bool MessageID_exists() const
310 {
311 const size_t n = offsetof(Self, MessageID);
312 return GetField<String>(n).exists ? true : false;
313 }
314
315 void MessageID_clear()
316 mike 1.1 {
317 const size_t n = offsetof(Self, MessageID);
318 GetField<String>(n).Clear();
319 }
320
321 //
322 // CIM_Error_Class.Message
323 //
324
325 const Field<String>& Message() const
326 {
327 const size_t n = offsetof(Self, Message);
328 return GetField<String>(n);
329 }
330
331 void Message(const Field<String>& x)
332 {
333 const size_t n = offsetof(Self, Message);
334 GetField<String>(n) = x;
335 }
336
337 mike 1.1 const String& Message_value() const
338 {
339 const size_t n = offsetof(Self, Message);
340 return GetField<String>(n).value;
341 }
342
343 void Message_value(const String& x)
344 {
345 const size_t n = offsetof(Self, Message);
346 GetField<String>(n).Set(x);
347 }
348
349 bool Message_exists() const
350 {
351 const size_t n = offsetof(Self, Message);
352 return GetField<String>(n).exists ? true : false;
353 }
354
355 void Message_clear()
356 {
357 const size_t n = offsetof(Self, Message);
358 mike 1.1 GetField<String>(n).Clear();
359 }
360
361 //
362 // CIM_Error_Class.MessageArguments
363 //
364
365 const Field<StringA>& MessageArguments() const
366 {
367 const size_t n = offsetof(Self, MessageArguments);
368 return GetField<StringA>(n);
369 }
370
371 void MessageArguments(const Field<StringA>& x)
372 {
373 const size_t n = offsetof(Self, MessageArguments);
374 GetField<StringA>(n) = x;
375 }
376
377 const StringA& MessageArguments_value() const
378 {
379 mike 1.1 const size_t n = offsetof(Self, MessageArguments);
380 return GetField<StringA>(n).value;
381 }
382
383 void MessageArguments_value(const StringA& x)
384 {
385 const size_t n = offsetof(Self, MessageArguments);
386 GetField<StringA>(n).Set(x);
387 }
388
389 bool MessageArguments_exists() const
390 {
391 const size_t n = offsetof(Self, MessageArguments);
392 return GetField<StringA>(n).exists ? true : false;
393 }
394
395 void MessageArguments_clear()
396 {
397 const size_t n = offsetof(Self, MessageArguments);
398 GetField<StringA>(n).Clear();
399 }
400 mike 1.1
401 //
402 // CIM_Error_Class.PerceivedSeverity
403 //
404
405 const Field<Uint16>& PerceivedSeverity() const
406 {
407 const size_t n = offsetof(Self, PerceivedSeverity);
408 return GetField<Uint16>(n);
409 }
410
411 void PerceivedSeverity(const Field<Uint16>& x)
412 {
413 const size_t n = offsetof(Self, PerceivedSeverity);
414 GetField<Uint16>(n) = x;
415 }
416
417 const Uint16& PerceivedSeverity_value() const
418 {
419 const size_t n = offsetof(Self, PerceivedSeverity);
420 return GetField<Uint16>(n).value;
421 mike 1.1 }
422
423 void PerceivedSeverity_value(const Uint16& x)
424 {
425 const size_t n = offsetof(Self, PerceivedSeverity);
426 GetField<Uint16>(n).Set(x);
427 }
428
429 bool PerceivedSeverity_exists() const
430 {
431 const size_t n = offsetof(Self, PerceivedSeverity);
432 return GetField<Uint16>(n).exists ? true : false;
433 }
434
435 void PerceivedSeverity_clear()
436 {
437 const size_t n = offsetof(Self, PerceivedSeverity);
438 GetField<Uint16>(n).Clear();
439 }
440
441 //
442 mike 1.1 // CIM_Error_Class.ProbableCause
443 //
444
445 const Field<Uint16>& ProbableCause() const
446 {
447 const size_t n = offsetof(Self, ProbableCause);
448 return GetField<Uint16>(n);
449 }
450
451 void ProbableCause(const Field<Uint16>& x)
452 {
453 const size_t n = offsetof(Self, ProbableCause);
454 GetField<Uint16>(n) = x;
455 }
456
457 const Uint16& ProbableCause_value() const
458 {
459 const size_t n = offsetof(Self, ProbableCause);
460 return GetField<Uint16>(n).value;
461 }
462
463 mike 1.1 void ProbableCause_value(const Uint16& x)
464 {
465 const size_t n = offsetof(Self, ProbableCause);
466 GetField<Uint16>(n).Set(x);
467 }
468
469 bool ProbableCause_exists() const
470 {
471 const size_t n = offsetof(Self, ProbableCause);
472 return GetField<Uint16>(n).exists ? true : false;
473 }
474
475 void ProbableCause_clear()
476 {
477 const size_t n = offsetof(Self, ProbableCause);
478 GetField<Uint16>(n).Clear();
479 }
480
481 //
482 // CIM_Error_Class.ProbableCauseDescription
483 //
484 mike 1.1
485 const Field<String>& ProbableCauseDescription() const
486 {
487 const size_t n = offsetof(Self, ProbableCauseDescription);
488 return GetField<String>(n);
489 }
490
491 void ProbableCauseDescription(const Field<String>& x)
492 {
493 const size_t n = offsetof(Self, ProbableCauseDescription);
494 GetField<String>(n) = x;
495 }
496
497 const String& ProbableCauseDescription_value() const
498 {
499 const size_t n = offsetof(Self, ProbableCauseDescription);
500 return GetField<String>(n).value;
501 }
502
503 void ProbableCauseDescription_value(const String& x)
504 {
505 mike 1.1 const size_t n = offsetof(Self, ProbableCauseDescription);
506 GetField<String>(n).Set(x);
507 }
508
509 bool ProbableCauseDescription_exists() const
510 {
511 const size_t n = offsetof(Self, ProbableCauseDescription);
512 return GetField<String>(n).exists ? true : false;
513 }
514
515 void ProbableCauseDescription_clear()
516 {
517 const size_t n = offsetof(Self, ProbableCauseDescription);
518 GetField<String>(n).Clear();
519 }
520
521 //
522 // CIM_Error_Class.RecommendedActions
523 //
524
525 const Field<StringA>& RecommendedActions() const
526 mike 1.1 {
527 const size_t n = offsetof(Self, RecommendedActions);
528 return GetField<StringA>(n);
529 }
530
531 void RecommendedActions(const Field<StringA>& x)
532 {
533 const size_t n = offsetof(Self, RecommendedActions);
534 GetField<StringA>(n) = x;
535 }
536
537 const StringA& RecommendedActions_value() const
538 {
539 const size_t n = offsetof(Self, RecommendedActions);
540 return GetField<StringA>(n).value;
541 }
542
543 void RecommendedActions_value(const StringA& x)
544 {
545 const size_t n = offsetof(Self, RecommendedActions);
546 GetField<StringA>(n).Set(x);
547 mike 1.1 }
548
549 bool RecommendedActions_exists() const
550 {
551 const size_t n = offsetof(Self, RecommendedActions);
552 return GetField<StringA>(n).exists ? true : false;
553 }
554
555 void RecommendedActions_clear()
556 {
557 const size_t n = offsetof(Self, RecommendedActions);
558 GetField<StringA>(n).Clear();
559 }
560
561 //
562 // CIM_Error_Class.ErrorSource
563 //
564
565 const Field<String>& ErrorSource() const
566 {
567 const size_t n = offsetof(Self, ErrorSource);
568 mike 1.1 return GetField<String>(n);
569 }
570
571 void ErrorSource(const Field<String>& x)
572 {
573 const size_t n = offsetof(Self, ErrorSource);
574 GetField<String>(n) = x;
575 }
576
577 const String& ErrorSource_value() const
578 {
579 const size_t n = offsetof(Self, ErrorSource);
580 return GetField<String>(n).value;
581 }
582
583 void ErrorSource_value(const String& x)
584 {
585 const size_t n = offsetof(Self, ErrorSource);
586 GetField<String>(n).Set(x);
587 }
588
589 mike 1.1 bool ErrorSource_exists() const
590 {
591 const size_t n = offsetof(Self, ErrorSource);
592 return GetField<String>(n).exists ? true : false;
593 }
594
595 void ErrorSource_clear()
596 {
597 const size_t n = offsetof(Self, ErrorSource);
598 GetField<String>(n).Clear();
599 }
600
601 //
602 // CIM_Error_Class.ErrorSourceFormat
603 //
604
605 const Field<Uint16>& ErrorSourceFormat() const
606 {
607 const size_t n = offsetof(Self, ErrorSourceFormat);
608 return GetField<Uint16>(n);
609 }
610 mike 1.1
611 void ErrorSourceFormat(const Field<Uint16>& x)
612 {
613 const size_t n = offsetof(Self, ErrorSourceFormat);
614 GetField<Uint16>(n) = x;
615 }
616
617 const Uint16& ErrorSourceFormat_value() const
618 {
619 const size_t n = offsetof(Self, ErrorSourceFormat);
620 return GetField<Uint16>(n).value;
621 }
622
623 void ErrorSourceFormat_value(const Uint16& x)
624 {
625 const size_t n = offsetof(Self, ErrorSourceFormat);
626 GetField<Uint16>(n).Set(x);
627 }
628
629 bool ErrorSourceFormat_exists() const
630 {
631 mike 1.1 const size_t n = offsetof(Self, ErrorSourceFormat);
632 return GetField<Uint16>(n).exists ? true : false;
633 }
634
635 void ErrorSourceFormat_clear()
636 {
637 const size_t n = offsetof(Self, ErrorSourceFormat);
638 GetField<Uint16>(n).Clear();
639 }
640
641 //
642 // CIM_Error_Class.OtherErrorSourceFormat
643 //
644
645 const Field<String>& OtherErrorSourceFormat() const
646 {
647 const size_t n = offsetof(Self, OtherErrorSourceFormat);
648 return GetField<String>(n);
649 }
650
651 void OtherErrorSourceFormat(const Field<String>& x)
652 mike 1.1 {
653 const size_t n = offsetof(Self, OtherErrorSourceFormat);
654 GetField<String>(n) = x;
655 }
656
657 const String& OtherErrorSourceFormat_value() const
658 {
659 const size_t n = offsetof(Self, OtherErrorSourceFormat);
660 return GetField<String>(n).value;
661 }
662
663 void OtherErrorSourceFormat_value(const String& x)
664 {
665 const size_t n = offsetof(Self, OtherErrorSourceFormat);
666 GetField<String>(n).Set(x);
667 }
668
669 bool OtherErrorSourceFormat_exists() const
670 {
671 const size_t n = offsetof(Self, OtherErrorSourceFormat);
672 return GetField<String>(n).exists ? true : false;
673 mike 1.1 }
674
675 void OtherErrorSourceFormat_clear()
676 {
677 const size_t n = offsetof(Self, OtherErrorSourceFormat);
678 GetField<String>(n).Clear();
679 }
680
681 //
682 // CIM_Error_Class.CIMStatusCode
683 //
684
685 const Field<Uint32>& CIMStatusCode() const
686 {
687 const size_t n = offsetof(Self, CIMStatusCode);
688 return GetField<Uint32>(n);
689 }
690
691 void CIMStatusCode(const Field<Uint32>& x)
692 {
693 const size_t n = offsetof(Self, CIMStatusCode);
694 mike 1.1 GetField<Uint32>(n) = x;
695 }
696
697 const Uint32& CIMStatusCode_value() const
698 {
699 const size_t n = offsetof(Self, CIMStatusCode);
700 return GetField<Uint32>(n).value;
701 }
702
703 void CIMStatusCode_value(const Uint32& x)
704 {
705 const size_t n = offsetof(Self, CIMStatusCode);
706 GetField<Uint32>(n).Set(x);
707 }
708
709 bool CIMStatusCode_exists() const
710 {
711 const size_t n = offsetof(Self, CIMStatusCode);
712 return GetField<Uint32>(n).exists ? true : false;
713 }
714
715 mike 1.1 void CIMStatusCode_clear()
716 {
717 const size_t n = offsetof(Self, CIMStatusCode);
718 GetField<Uint32>(n).Clear();
719 }
720
721 //
722 // CIM_Error_Class.CIMStatusCodeDescription
723 //
724
725 const Field<String>& CIMStatusCodeDescription() const
726 {
727 const size_t n = offsetof(Self, CIMStatusCodeDescription);
728 return GetField<String>(n);
729 }
730
731 void CIMStatusCodeDescription(const Field<String>& x)
732 {
733 const size_t n = offsetof(Self, CIMStatusCodeDescription);
734 GetField<String>(n) = x;
735 }
736 mike 1.1
737 const String& CIMStatusCodeDescription_value() const
738 {
739 const size_t n = offsetof(Self, CIMStatusCodeDescription);
740 return GetField<String>(n).value;
741 }
742
743 void CIMStatusCodeDescription_value(const String& x)
744 {
745 const size_t n = offsetof(Self, CIMStatusCodeDescription);
746 GetField<String>(n).Set(x);
747 }
748
749 bool CIMStatusCodeDescription_exists() const
750 {
751 const size_t n = offsetof(Self, CIMStatusCodeDescription);
752 return GetField<String>(n).exists ? true : false;
753 }
754
755 void CIMStatusCodeDescription_clear()
756 {
757 mike 1.1 const size_t n = offsetof(Self, CIMStatusCodeDescription);
758 GetField<String>(n).Clear();
759 }
760 };
761
762 typedef Array<CIM_Error_Class> CIM_Error_ClassA;
763
764 MI_END_NAMESPACE
765
766 #endif /* __cplusplus */
767
768 #endif /* _CIM_Error_h */
|
Return to
CIM_Error.h
CVS log
Up to [OMI] / omi / base / tests