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