(file) Return to CIMClass.h CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/CIMClass.h between version 1.22 and 1.58

version 1.22, 2001/06/17 04:20:32 version 1.58, 2002/08/20 17:39:37
Line 1 
Line 1 
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,
   // The Open Group, Tivoli Systems
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 22 
Line 23 
 // //
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By:  // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
   //              Carol Ann Krug Graves, Hewlett-Packard Company
   //                  (carolann_graves@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 30 
Line 33 
 #define Pegasus_CIMClass_h #define Pegasus_CIMClass_h
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <Pegasus/Common/CIMClassRep.h>  #include <Pegasus/Common/Linkage.h>
   #include <Pegasus/Common/CIMName.h>
   #include <Pegasus/Common/CIMObject.h>
   #include <Pegasus/Common/CIMMethod.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 class CIMConstClass; class CIMConstClass;
   class CIMClassRep;
   class Resolver;
   
   // REVIEW: redocument.
  
 /** The CIMClass class is used to represent CIM classes in Pegasus.  In CIM, /** The CIMClass class is used to represent CIM classes in Pegasus.  In CIM,
     a class object may be a class or an associator.  A CIM class must contain a     a class object may be a class or an associator.  A CIM class must contain a
Line 43 
Line 53 
     instances, all of which support a common type (for example, a set of     instances, all of which support a common type (for example, a set of
     properties, methods, and associations).     properties, methods, and associations).
 */ */
   
 class PEGASUS_COMMON_LINKAGE CIMClass class PEGASUS_COMMON_LINKAGE CIMClass
 { {
 public: public:
Line 56 
Line 65 
  
         Use one of the other constructors to create an initiated new CIM class         Use one of the other constructors to create an initiated new CIM class
         object.         object.
         @exception Throws an exception "unitialized handle" if this          @exception "unitialized handle" if this
         unitialized handle is used         unitialized handle is used
         /REF(HPEGASUS_HANDLES)  
     */     */
     CIMClass() : _rep(0)      CIMClass();
     {  
   
     }  
  
     /** Constructor - Creates a class from a previous class     /** Constructor - Creates a class from a previous class
     */     */
     CIMClass(const CIMClass& x)      CIMClass(const CIMClass& x);
     {  
         Inc(_rep = x._rep);  
     }  
  
     /// Operator = Assigns the CIM Class constructor.      PEGASUS_EXPLICIT CIMClass(const CIMObject& x)
     CIMClass& operator=(const CIMClass& x)          throw(DynamicCastFailedException);
     {  
         if (x._rep != _rep)  
         {  
             Dec(_rep);  
             Inc(_rep = x._rep);  
         }  
         return *this;  
     }  
  
       // ATTN define what makes up a legal CIM class name
     /**  Constructor - Creates a Class from inputs of a classname and     /**  Constructor - Creates a Class from inputs of a classname and
         SuperClassName         SuperClassName
         @param className String representing name of the class being created          @param className CIMName representing name of the class being created
         @param superClassName String representing name of the SuperClass          @param superClassName CIMName representing name of the SuperClass
         ATTN: Define what makes up legal name.  
         @return Throws IllegalName if className argument illegal CIM identifier.  
         <pre>         <pre>
             CIMClass NewCass("MyClass", "YourClass");              CIMClass NewClass("MyClass", "YourClass");
         </pre>         </pre>
  
     */     */
     CIMClass(     CIMClass(
         const String& className,          const CIMName& className,
         const String& superClassName = String())          const CIMName& superClassName = CIMName());
     {  
         _rep = new CIMClassRep(className, superClassName);      /** Assignment operator.
     }      */
       CIMClass& operator=(const CIMClass& x);
  
     /// Destructor     /// Destructor
     ~CIMClass()      ~CIMClass();
     {  
         Dec(_rep);  
     }  
  
     /** isAssociation - Identifies whether or not this CIM class     /** isAssociation - Identifies whether or not this CIM class
         is an association. An association is a relationship between two         is an association. An association is a relationship between two
Line 116 
Line 107 
         @return  Boolean True if this CIM class belongs to an association;         @return  Boolean True if this CIM class belongs to an association;
         otherwise, false.         otherwise, false.
     */     */
     Boolean isAssociation() const      Boolean isAssociation() const;
     {  
         _checkRep();  
         return _rep->isAssociation();  
     }  
  
     ///  CIMMethod isAbstract      /** isAbstract Test if the CIMClass is abstract.
     Boolean isAbstract() const          @return - True if the CIMClass Object is abstract
     {          SeeAlso: Abstract
         _checkRep();      */
         return _rep->isAbstract();      Boolean isAbstract() const;
     }  
  
       // ATTN: COMMENT. Why not just get name so we have common method for all.
     /** getClassName Gets the name of the class     /** getClassName Gets the name of the class
         ATTN: COMMENT. Why not just get name so we have common method for all.          @return Returns CIMName with the class name.
         @return Returns string with the class name.  
     */     */
     const String& getClassName() const      const CIMName& getClassName() const;
     {  
         _checkRep();      const CIMObjectPath& getPath() const;
         return _rep->getClassName();  
     }  
  
     /** CIMMethod getSuperClassName - Gets the name of the Parent      /**
         @return String with parent class name.        Sets the object path for the class
         @param  path  CIMObjectPath containing the object path
     */     */
     const String& getSuperClassName() const      void setPath (const CIMObjectPath & path);
     {  
         _checkRep();      /** getSuperClassName - Gets the name of the Parent
         return _rep->getSuperClassName();          @return CIMName with parent class name.
     }  
   
     /** CIMMethod setSuperClassName - Sets the name of the parent class from  
         the input parameter. \REF{CLASSNAME}. ATTN: Define legal classnames  
         @param String defining parent name.  
         @return Throws IllegalName if superClassName argument not legal CIM  
         identifier  
         @exception throws IllegalName if the name is not correct. See  
         \URL[ClassNames]{DefinitionofTerms.html#CLASSNAME}  
     */     */
     void setSuperClassName(const String& superClassName)      const CIMName& getSuperClassName() const;
     {  
         _checkRep();      /** setSuperClassName - Sets the name of the parent class from
         _rep->setSuperClassName(superClassName);          the input parameter. \REF{CLASSNAME}.
     }          @param CIMName defining parent name.
       */
       void setSuperClassName(const CIMName& superClassName);
  
     /** addQualifier - Adds the specified qualifier to the class     /** addQualifier - Adds the specified qualifier to the class
         and increments the qualifier count. It is illegal to add the same         and increments the qualifier count. It is illegal to add the same
Line 168 
Line 146 
         @param qualifier CIMQualifier object representing the qualifier to be         @param qualifier CIMQualifier object representing the qualifier to be
         added         added
         @return Returns handle of the class object         @return Returns handle of the class object
         @exception Throws AlreadyExists.          @exception AlreadyExistsException.
     */     */
     CIMClass& addQualifier(const CIMQualifier& qualifier)      CIMClass& addQualifier(const CIMQualifier& qualifier);
     {  
         _checkRep();  
         _rep->addQualifier(qualifier);  
         return *this;  
     }  
  
     /** findQualifier - Searches for a qualifier with the specified `     /** findQualifier - Searches for a qualifier with the specified `
         input name if it exists in the class         input name if it exists in the class
Line 184 
Line 157 
         @return Returns index of the qualifier found or PEG_NOT_FOUND         @return Returns index of the qualifier found or PEG_NOT_FOUND
         if not found.         if not found.
     */     */
     Uint32 findQualifier(const String& name)      Uint32 findQualifier(const CIMName& name) const;
     {  
         _checkRep();  
         return _rep->findQualifier(name);  
     }  
     ///  
     Uint32 findQualifier(const String& name) const  
     {  
         _checkRep();  
         return _rep->findQualifier(name);  
     }  
     /** existsQualifier - Returns true if the qualifier with the  
     specified name exists in the class  
     @param name String name of the qualifier object being tested.  
     @return True if the qualifier exits.  Otherwise false is returned.  
     */  
     Boolean existsQualifier(const String& name)  
     {  
         _checkRep();  
         return _rep->existsQualifier(name);  
     }  
     ///  
     Boolean existsQualifier(const String& name) const  
     {  
         _checkRep();  
         return _rep->existsQualifier(name);  
     }  
  
     /** getQualifier - Gets the CIMQualifier object defined     /** getQualifier - Gets the CIMQualifier object defined
         by the input parameter         by the input parameter
         @param pos defines the position of the qualifier in the class from the         @param pos defines the position of the qualifier in the class from the
         findQualifier method         findQualifier method
         @return CIMQualifier object representing the qualifier found.          @return CIMQualifier object representing the qualifier found. On error,
         ATTN: what is error return here?              CIMQualifier handle will be null.
     */     */
     CIMQualifier getQualifier(Uint32 pos)      CIMQualifier getQualifier(Uint32 pos);
     {  
         _checkRep();  
         return _rep->getQualifier(pos);  
     }  
  
     /// getQualifier - ATTN:      /** getQualifier - Gets the qualifier defined by the input parameter
     CIMConstQualifier getQualifier(Uint32 pos) const          from the qualifier list for this CIMClass.
     {      */
         _checkRep();      CIMConstQualifier getQualifier(Uint32 pos) const;
         return _rep->getQualifier(pos);  
     }  
  
     /** removeQualifier - Removes the qualifier defined by the     /** removeQualifier - Removes the qualifier defined by the
     index parameter.     index parameter.
Line 239 
Line 180 
     @exception Throw OutOfBound exception if the index is outside     @exception Throw OutOfBound exception if the index is outside
     the range of existing qualifier objects for this class     the range of existing qualifier objects for this class
     */     */
     void removeQualifier(Uint32 pos) const      void removeQualifier(Uint32 pos);
     {  
         _checkRep();  
         _rep->removeQualifier(pos);  
     }  
  
     /** getQualifierCount - Returns the number of qualifiers     /** getQualifierCount - Returns the number of qualifiers
         in the class.         in the class.
         @return ATTN:          @return the number of qualifiers on the class definition (not
           those on properties or methods)
     */     */
     Uint32 getQualifierCount() const      Uint32 getQualifierCount() const;
     {  
         _checkRep();  
         return _rep->getQualifierCount();  
     }  
  
     /** addProperty - Adds the specified property object to the     /** addProperty - Adds the specified property object to the
         properties in the CIM class         properties in the CIM class
     */     */
     CIMClass& addProperty(const CIMProperty& x)      CIMClass& addProperty(const CIMProperty& x);
     {  
         _checkRep();  
         _rep->addProperty(x);  
         return *this;  
     }  
   
   
  
     /** CIMMethod findProperty - Finds the property object with the      /** findProperty - Finds the property object with the
         name defined by the input parameter in the class.         name defined by the input parameter in the class.
         @param String parameter with the property name.          @param CIMName parameter with the property name.
         @return position representing the property object found or         @return position representing the property object found or
         PEG_NOT_FOUND if the property is not found.         PEG_NOT_FOUND if the property is not found.
     */     */
     Uint32 findProperty(const String& name)      Uint32 findProperty(const CIMName& name) const;
     {  
         _checkRep();  
         return _rep->findProperty(name);  
     }  
   
     Uint32 findProperty(const String& name) const  
     {  
         _checkRep();  
         return _rep->findProperty(name);  
     }  
   
     /** existsPropery - Determines if a property object with the  
         name defined by the input parameter exists in the class.  
         @parm String parameter with the property name.  
         @return True if the property object exists.  
     */  
     Boolean existsProperty(const String& name)  
     {  
         _checkRep();  
         return _rep->existsProperty(name);  
     }  
     Boolean existsProperty(const String& name) const  
     {  
        _checkRep();  
        return _rep->existsProperty(name);  
     }  
  
       // ATTN: Should we not use something like handle for position???
       // ATTN: what is error return?
     /** getProperty - Returns a property representing the property     /** getProperty - Returns a property representing the property
         defined by the input parameter         defined by the input parameter
         @param position for this property         @param position for this property
         ATTN: Should we not use something like handle for position???  
         @return CIMProperty object         @return CIMProperty object
         ATTN: what is error return?  
     */     */
     CIMProperty getProperty(Uint32 pos)      CIMProperty getProperty(Uint32 pos);
     {  
         _checkRep();  
         return _rep->getProperty(pos);  
     }  
  
     /**getProperty Gets a property object from the CIMClass     /**getProperty Gets a property object from the CIMClass
         @param pos The index of the property object to get.         @param pos The index of the property object to get.
Line 320 
Line 217 
         @exception Throws OutofBounds if the size field is greather than the         @exception Throws OutofBounds if the size field is greather than the
         bunber of properties in the class.         bunber of properties in the class.
     */     */
     CIMConstProperty getProperty(Uint32 pos) const      CIMConstProperty getProperty(Uint32 pos) const;
     {  
         _checkRep();  
         return _rep->getProperty(pos);  
     }  
  
     /** removeProperty - Removes the property represented     /** removeProperty - Removes the property represented
         by the position input parameter from the class         by the position input parameter from the class
Line 332 
Line 225 
         findPropety method         findPropety method
         @exception Throws OutofBounds if index is not a property object         @exception Throws OutofBounds if index is not a property object
     */     */
     void removeProperty(Uint32 pos)      void removeProperty(Uint32 pos);
     {  
         _checkRep();  
         _rep->removeProperty(pos);  
     }  
  
     /** getPropertyCount -   Gets the count of the number of properties     /** getPropertyCount -   Gets the count of the number of properties
         defined in the class.         defined in the class.
         @return count of number of proerties in the class         @return count of number of proerties in the class
     */     */
     Uint32 getPropertyCount() const      Uint32 getPropertyCount() const;
     {  
         _checkRep();  
         return _rep->getPropertyCount();  
     }  
  
     /** addMethod - Adds the method object defined by the input     /** addMethod - Adds the method object defined by the input
         parameter to the class and increments the count of the number of         parameter to the class and increments the count of the number of
         methods in the class         methods in the class
         @param method object representing the method to be added         @param method object representing the method to be added
         @return Returns the CIMClass object to which the method was added.         @return Returns the CIMClass object to which the method was added.
         @exception Throws AlreadyExists if the method already exists and throws          @exception AlreadyExistsException if the method already exists
         UnitializedHandle if the handle is not initialized          @exception UninitializedObjectException if the object is not initialized
     */     */
     CIMClass& addMethod(const CIMMethod& x)      CIMClass& addMethod(const CIMMethod& x);
     {  
         _checkRep();  
         _rep->addMethod(x);  
         return *this;  
     }  
  
     /** findMethod - Locate the method object defined by the     /** findMethod - Locate the method object defined by the
         name input         name input
         @param String representing the name of the method to be found          @param CIMName representing the name of the method to be found
         @return Position of the method object in the class to be used in         @return Position of the method object in the class to be used in
         subsequent getmethod, etc. operations         subsequent getmethod, etc. operations
     */     */
     Uint32 findMethod(const String& name)      Uint32 findMethod(const CIMName& name) const;
     {  
         _checkRep();  
         return _rep->findMethod(name);  
     }  
   
     Uint32 findMethod(const String& name) const  
     {  
         _checkRep();  
         return _rep->findMethod(name);  
     }  
   
      /** existsMethod - Determine if the method object defined by the  
         name input exists  
         @param String representing the name of the method to be found  
         @return True if the method exists  
     */  
     Boolean existsMethod(const String& name)  
     {  
         _checkRep();  
         return _rep->existsMethod(name);  
     }  
   
     Boolean existsMethod(const String& name) const  
     {  
         _checkRep();  
         return _rep->existsMethod(name);  
     }  
   
  
     /** getMethod - Gets the method object defined by the     /** getMethod - Gets the method object defined by the
         input parameter.         input parameter.
         @param pos Index to the CIMMethod object to get          @param pos Index to the method object to get
         @return Returns handle of the CIMMethod requested          @return Returns handle of the method requested
         @exception Throws OutofBounds if the index represented by pos is greater         @exception Throws OutofBounds if the index represented by pos is greater
         than the number of methods defined in the class object         than the number of methods defined in the class object
     */     */
     CIMMethod getMethod(Uint32 pos)      CIMMethod getMethod(Uint32 pos);
     {  
         _checkRep();  
         return _rep->getMethod(pos);  
     }  
  
     /** getMethod Gets the method object defined by the input     /** getMethod Gets the method object defined by the input
     parameter. This is the const version.     parameter. This is the const version.
     */     */
  
     CIMConstMethod getMethod(Uint32 pos) const      CIMConstMethod getMethod(Uint32 pos) const;
     {  
         _checkRep();  
         return _rep->getMethod(pos);  
     }  
  
     /** removeMethod - Removes the method defined by the     /** removeMethod - Removes the method defined by the
     index parameter.     index parameter.
Line 429 
Line 273 
     @exception Throw OutOfBound exception if the index is outside     @exception Throw OutOfBound exception if the index is outside
     the range of existing method objects for this class     the range of existing method objects for this class
     */     */
     void removeMethod(Uint32 pos) const      void removeMethod(Uint32 pos);
     {  
         _checkRep();  
         _rep->removeMethod(pos);  
     }  
  
     /** CIMMethod getMethodCount - Count of the number of methods in the class      /** getMethodCount - Count of the number of methods in the class
         @return integer representing the number of methods in the class object.         @return integer representing the number of methods in the class object.
     */     */
     Uint32 getMethodCount() const      Uint32 getMethodCount() const;
     {  
         _checkRep();  
         return _rep->getMethodCount();  
     }  
   
     /** Resolve -  Resolve the class: inherit any properties and  
         qualifiers. Make sure the superClass really exists and is consistent  
         with this class. Also set the propagated flag class-origin for each  
         class feature.  
         ATTN: explain why this here  
     */  
     void resolve(  
         DeclContext* declContext,  
         const String& nameSpace)  
     {  
         _checkRep();  
         _rep->resolve(declContext, nameSpace);  
     }  
  
     /// operator - ATTN:      /** Get names of all keys of this class. */
     operator int() const { return _rep != 0; }      void getKeyNames(Array<CIMName>& keyNames) const;
  
     /// CIMMethod toXML      Boolean hasKeys() const;
     void toXml(Array<Sint8>& out) const  
     {  
         _checkRep();  
         _rep->toXml(out);  
     }  
  
     /// CIMMethod print      /** Makes a deep copy (clone) of the given object. */
     void print(PEGASUS_STD(ostream) &o=PEGASUS_STD(cout)) const      CIMClass clone() const;
     {  
         _checkRep();  
         _rep->print(o);  
     }  
  
     /** CIMMethod identical -  Compares with another class      // ATTN: Clarify exactly what identical means
         ATTN: Clarify exactly what identical means      /** identical -  Compares with another class
         @param Class object for the class to be compared         @param Class object for the class to be compared
         @return True if the classes are identical         @return True if the classes are identical
     */     */
     Boolean identical(const CIMConstClass& x) const;     Boolean identical(const CIMConstClass& x) const;
  
     /** Makes a deep copy (clone) of the given object. */      /**
     CIMClass clone() const          Determines if the object has not been initialized.
     {  
         return CIMClass(_rep->clone());  
     }  
  
     /** Get names of all keys of this class. */          @return  True if the object has not been initialized,
     void getKeyNames(Array<String>& keyNames) const                   False otherwise
     {       */
         _checkRep();      Boolean isUninitialized() const;
         _rep->getKeyNames(keyNames);  
     }  
   
     Boolean hasKeys() const  
     {  
         _checkRep();  
         return _rep->hasKeys();  
     }  
  
 private: private:
  
     CIMClass(CIMClassRep* rep) : _rep(rep)      CIMClassRep* _rep;
     {  
     }  
  
     void _checkRep() const      CIMClass(CIMClassRep* rep);
     {  
         if (!_rep)      void _checkRep() const;
             ThrowUnitializedHandle();  
     }  
  
     CIMClassRep* _rep;  
     friend class CIMConstClass;     friend class CIMConstClass;
       friend class CIMObject;
       friend class CIMConstObject;
       friend class Resolver;
       friend class XmlWriter;
       friend class MofWriter;
 }; };
  
 #define PEGASUS_ARRAY_T CIMClass #define PEGASUS_ARRAY_T CIMClass
 # include "ArrayInter.h"  #include <Pegasus/Common/ArrayInter.h>
 #undef PEGASUS_ARRAY_T #undef PEGASUS_ARRAY_T
  
 /** CIMConstClass - ATTN: define this.  // ATTN document this
   /** CIMConstClass
 */ */
 class PEGASUS_COMMON_LINKAGE CIMConstClass class PEGASUS_COMMON_LINKAGE CIMConstClass
 { {
 public: public:
  
     CIMConstClass() : _rep(0)      CIMConstClass();
     {  
   
     }  
  
     CIMConstClass(const CIMConstClass& x)      CIMConstClass(const CIMConstClass& x);
     {  
         Inc(_rep = x._rep);  
     }  
  
     CIMConstClass(const CIMClass& x)      CIMConstClass(const CIMClass& x);
     {  
         Inc(_rep = x._rep);  
     }  
  
     CIMConstClass& operator=(const CIMConstClass& x)      PEGASUS_EXPLICIT CIMConstClass(const CIMObject& x)
     {          throw(DynamicCastFailedException);
         if (x._rep != _rep)  
         {  
             Dec(_rep);  
             Inc(_rep = x._rep);  
         }  
         return *this;  
     }  
  
     CIMConstClass& operator=(const CIMClass& x)      PEGASUS_EXPLICIT CIMConstClass(const CIMConstObject& x)
     {          throw(DynamicCastFailedException);
         if (x._rep != _rep)  
         {  
             Dec(_rep);  
             Inc(_rep = x._rep);  
         }  
         return *this;  
     }  
   
     // Throws IllegalName if className argument not legal CIM identifier.  
  
     CIMConstClass(     CIMConstClass(
         const String& className,          const CIMName& className,
         const String& superClassName = String())          const CIMName& superClassName = CIMName());
     {  
         _rep = new CIMClassRep(className, superClassName);  
     }  
  
     ~CIMConstClass()      CIMConstClass& operator=(const CIMConstClass& x);
     {  
         Dec(_rep);  
     }  
  
     Boolean isAssociation() const      CIMConstClass& operator=(const CIMClass& x);
     {  
         _checkRep();  
         return _rep->isAssociation();  
     }  
  
     Boolean isAbstract() const      ~CIMConstClass();
     {  
         _checkRep();  
         return _rep->isAbstract();  
     }  
  
     const String& getClassName() const      Boolean isAssociation() const;
     {  
         _checkRep();  
         return _rep->getClassName();  
     }  
  
     const String& getSuperClassName() const      Boolean isAbstract() const;
     {  
         _checkRep();  
         return _rep->getSuperClassName();  
     }  
  
     Uint32 findQualifier(const String& name) const      const CIMName& getClassName() const;
     {  
         _checkRep();  
         return _rep->findQualifier(name);  
     }  
  
     CIMConstQualifier getQualifier(Uint32 pos) const      const CIMObjectPath& getPath() const;
     {  
         _checkRep();  
         return _rep->getQualifier(pos);  
     }  
  
     Uint32 getQualifierCount() const      const CIMName& getSuperClassName() const;
     {  
         _checkRep();  
         return _rep->getQualifierCount();  
     }  
  
     Uint32 findProperty(const String& name) const      Uint32 findQualifier(const CIMName& name) const;
     {  
         _checkRep();  
         return _rep->findProperty(name);  
     }  
  
     CIMConstProperty getProperty(Uint32 pos) const      CIMConstQualifier getQualifier(Uint32 pos) const;
     {  
         _checkRep();  
         return _rep->getProperty(pos);  
     }  
  
     Uint32 getPropertyCount() const      Uint32 getQualifierCount() const;
     {  
         _checkRep();  
         return _rep->getPropertyCount();  
     }  
  
     Uint32 findMethod(const String& name) const      Uint32 findProperty(const CIMName& name) const;
     {  
         _checkRep();  
         return _rep->findMethod(name);  
     }  
  
     CIMConstMethod getMethod(Uint32 pos) const      CIMConstProperty getProperty(Uint32 pos) const;
     {  
         _checkRep();  
         return _rep->getMethod(pos);  
     }  
  
     Uint32 getMethodCount() const      Uint32 getPropertyCount() const;
     {  
         _checkRep();  
         return _rep->getMethodCount();  
     }  
  
     operator int() const { return _rep != 0; }      Uint32 findMethod(const CIMName& name) const;
  
     void toXml(Array<Sint8>& out) const      CIMConstMethod getMethod(Uint32 pos) const;
     {  
         _checkRep();  
         _rep->toXml(out);  
     }  
  
     void print(PEGASUS_STD(ostream) &o=PEGASUS_STD(cout)) const      Uint32 getMethodCount() const;
     {  
         _checkRep();  
         _rep->print(o);  
     }  
  
     Boolean identical(const CIMConstClass& x) const      void getKeyNames(Array<CIMName>& keyNames) const;
     {  
         x._checkRep();  
         _checkRep();  
         return _rep->identical(x._rep);  
     }  
  
     CIMClass clone() const      Boolean hasKeys() const;
     {  
         return CIMClass(_rep->clone());  
     }  
  
     void getKeyNames(Array<String>& keyNames) const      CIMClass clone() const;
     {  
         _checkRep();  
         _rep->getKeyNames(keyNames);  
     }  
  
     Boolean hasKeys() const      Boolean identical(const CIMConstClass& x) const;
     {  
         _checkRep();  
         return _rep->hasKeys();  
     }  
  
 private:      Boolean isUninitialized() const;
  
     void _checkRep() const  private:
     {  
         if (!_rep)  
             ThrowUnitializedHandle();  
     }  
  
     CIMClassRep* _rep;     CIMClassRep* _rep;
  
       void _checkRep() const;
   
     friend class CIMClassRep;     friend class CIMClassRep;
     friend class CIMClass;     friend class CIMClass;
     friend class CIMInstanceRep;     friend class CIMInstanceRep;
       friend class CIMObject;
       friend class CIMConstObject;
       friend class XmlWriter;
       friend class MofWriter;
 }; };
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

Legend:
Removed from v.1.22  
changed lines
  Added in v.1.58
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2