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_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 krisbash 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 krisbash 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 krisbash 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 krisbash 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 krisbash 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 krisbash 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 krisbash 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 krisbash 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 krisbash 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 krisbash 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 krisbash 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 krisbash 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 krisbash 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 krisbash 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 krisbash 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 krisbash 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 krisbash 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 krisbash 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 krisbash 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 krisbash 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 krisbash 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 krisbash 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 krisbash 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 krisbash 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 krisbash 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 krisbash 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 krisbash 1.1 
569              #endif /* _CIM_ManagedSystemElement_h */