(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.36 and 1.37

version 1.36, 2002/05/01 04:34:14 version 1.37, 2002/05/03 05:16:16
Line 31 
Line 31 
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <Pegasus/Common/CIMObject.h> #include <Pegasus/Common/CIMObject.h>
 #include <Pegasus/Common/CIMClassRep.h>  #include <Pegasus/Common/CIMMethod.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 class CIMConstClass; class CIMConstClass;
 class CIMObject;  class CIMClassRep;
 class CIMConstObject;  class DeclContext;
  
 // REVIEW: redocument. // REVIEW: redocument.
  
Line 64 
Line 64 
         unitialized handle is used         unitialized handle is used
         /REF(HPEGASUS_HANDLES)         /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);  
     }  
  
     PEGASUS_EXPLICIT CIMClass(const CIMObject& x);     PEGASUS_EXPLICIT CIMClass(const CIMObject& x);
  
     PEGASUS_EXPLICIT CIMClass(const CIMObject& x, NoThrow&);     PEGASUS_EXPLICIT CIMClass(const CIMObject& x, NoThrow&);
  
     /** Assignment operator.  
     */  
     CIMClass& operator=(const CIMClass& x)  
     {  
         if (x._rep != _rep)  
         {  
             Dec(_rep);  
             Inc(_rep = x._rep);  
         }  
         return *this;  
     }  
   
     /** Constructor - Creates a Class from inputs of a classname and     /** Constructor - Creates a Class from inputs of a classname and
         SuperClassName         SuperClassName
         @param className CIMReference representing name of the class being created         @param className CIMReference representing name of the class being created
Line 104 
Line 87 
     */     */
     CIMClass(     CIMClass(
         const CIMReference& reference,         const CIMReference& reference,
         const String& superClassName = String())          const String& superClassName = String::EMPTY);
     {  
         _rep = new CIMClassRep(reference, 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 124 
Line 105 
         @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();  
     }  
  
     /** isAbstract Test if the CIMClass is abstract.     /** isAbstract Test if the CIMClass is abstract.
         @return - True if the CIMClass Object is abstract         @return - True if the CIMClass Object is abstract
         SeeAlso: Abstract         SeeAlso: Abstract
     */     */
     Boolean isAbstract() const      Boolean isAbstract() const;
     {  
         _checkRep();  
         return _rep->isAbstract();  
     }  
  
     /** 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.         ATTN: COMMENT. Why not just get name so we have common method for all.
         @return Returns string with the class name.         @return Returns string with the class name.
     */     */
     const String& getClassName() const      const String& getClassName() const;
     {  
         _checkRep();  
         return _rep->getClassName();  
     }  
  
     /** equalClassName compares Name of the class with a String. This test performs      /** equalClassName compares Name of the class with a String. This test
         a comparison of the classname component of the object          performs a comparison of the classname component of the object
         with a String.  Note that this function was included specifically         with a String.  Note that this function was included specifically
         because the equality compare is not just a straight comparison         because the equality compare is not just a straight comparison
         because classnames are case independent.         because classnames are case independent.
Line 159 
Line 128 
         @return True if it is the same class name (equalNoCase compare passes)         @return True if it is the same class name (equalNoCase compare passes)
         or false if not.         or false if not.
     */     */
     const Boolean equalClassName(const String& classname) const      const Boolean equalClassName(const String& classname) const;
     {  
         _checkRep();  
         return _rep->equalClassName(classname);  
   
     }  
  
     const CIMReference& getPath() const      const CIMReference& getPath() const;
     {  
         _checkRep();  
         return _rep->getPath();  
     }  
  
     /** getSuperClassName - Gets the name of the Parent     /** getSuperClassName - Gets the name of the Parent
         @return String with parent class name.         @return String with parent class name.
     */     */
     const String& getSuperClassName() const      const String& getSuperClassName() const;
     {  
         _checkRep();  
         return _rep->getSuperClassName();  
     }  
  
     /** setSuperClassName - Sets the name of the parent class from     /** setSuperClassName - Sets the name of the parent class from
         the input parameter. \REF{CLASSNAME}. ATTN: Define legal classnames         the input parameter. \REF{CLASSNAME}. ATTN: Define legal classnames
Line 189 
Line 145 
         @exception throws IllegalName if the name is not correct. See         @exception throws IllegalName if the name is not correct. See
         \URL[ClassNames]{DefinitionofTerms.html#CLASSNAME}         \URL[ClassNames]{DefinitionofTerms.html#CLASSNAME}
     */     */
     void setSuperClassName(const String& superClassName)      void setSuperClassName(const String& superClassName);
     {  
         _checkRep();  
         _rep->setSuperClassName(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 203 
Line 155 
         @return Returns handle of the class object         @return Returns handle of the class object
         @exception Throws AlreadyExists.         @exception Throws AlreadyExists.
     */     */
     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 217 
Line 164 
         @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 String& 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     /** existsQualifier - Returns true if the qualifier with the
     specified name exists in the class     specified name exists in the class
     @param name String name of the qualifier object being tested.     @param name String name of the qualifier object being tested.
     @return True if the qualifier exits.  Otherwise false is returned.     @return True if the qualifier exits.  Otherwise false is returned.
     */     */
     Boolean existsQualifier(const String& name)      Boolean existsQualifier(const String& name) const;
     {  
         _checkRep();  
         return _rep->existsQualifier(name);  
     }  
     ///  
     Boolean existsQualifier(const String& name) const  
     {  
         _checkRep();  
         return _rep->existsQualifier(name);  
     }  
  
     /** isTrueQualifier - Determines if the qualifier defined by     /** isTrueQualifier - Determines if the qualifier defined by
         the input parameter exists for the class, is Boolean, and         the input parameter exists for the class, is Boolean, and
Line 253 
Line 181 
         @param String containing the qualifier  name.         @param String containing the qualifier  name.
         @return Boolean True if the qualifier exists,         @return Boolean True if the qualifier exists,
     */     */
     Boolean isTrueQualifier(const String& name) const      Boolean isTrueQualifier(const String& name) const;
     {  
         _checkRep();  
         return _rep->isTrueQualifier(name);  
     }  
  
 /**     getQualifier - Gets the CIMQualifier object defined /**     getQualifier - Gets the CIMQualifier object defined
         by the input parameter         by the input parameter
Line 266 
Line 190 
         @return CIMQualifier object representing the qualifier found. On error,         @return CIMQualifier object representing the qualifier found. On error,
             CIMQualifier handle will be null.             CIMQualifier handle will be null.
     */     */
     CIMQualifier getQualifier(Uint32 pos)      CIMQualifier getQualifier(Uint32 pos);
     {  
         _checkRep();  
         return _rep->getQualifier(pos);  
     }  
  
     /** getQualifier - Gets the qualifier defined by the input parameter     /** getQualifier - Gets the qualifier defined by the input parameter
                 from the qualifier list for this CIMClass.                 from the qualifier list for this CIMClass.
         */         */
     CIMConstQualifier getQualifier(Uint32 pos) const      CIMConstQualifier getQualifier(Uint32 pos) const;
     {  
         _checkRep();  
         return _rep->getQualifier(pos);  
     }  
  
     /** removeQualifier - Removes the qualifier defined by the     /** removeQualifier - Removes the qualifier defined by the
     index parameter.     index parameter.
Line 288 
Line 204 
     @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)      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 ATTN:
     */     */
     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;  
     }  
  
     /** 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.
Line 320 
Line 223 
         @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 String& name) const;
     {  
         _checkRep();  
         return _rep->findProperty(name);  
     }  
  
     Uint32 findProperty(const String& name) const      /** existsProperty - Determines if a property object with the
     {  
         _checkRep();  
         return _rep->findProperty(name);  
     }  
   
     /** existsPropery - Determines if a property object with the  
         name defined by the input parameter exists in the class.         name defined by the input parameter exists in the class.
         @parm String parameter with the property name.         @parm String parameter with the property name.
         @return True if the property object exists.         @return True if the property object exists.
     */     */
     Boolean existsProperty(const String& name)      Boolean existsProperty(const String& name) const;
     {  
         _checkRep();  
         return _rep->existsProperty(name);  
     }  
   
         Boolean existsProperty(const String& name) const  
     {  
        _checkRep();  
        return _rep->existsProperty(name);  
     }  
  
     /** getProperty - Returns a property representing the property     /** getProperty - Returns a property representing the property
         defined by the input parameter         defined by the input parameter
Line 356 
Line 239 
         @return CIMProperty object         @return CIMProperty object
         ATTN: what is error return?         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 368 
Line 247 
         @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 380 
Line 255 
         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
Line 404 
Line 271 
         @exception Throws AlreadyExists if the method already exists and throws         @exception Throws AlreadyExists if the method already exists and throws
         UnitializedHandle if the handle is not initialized         UnitializedHandle if the handle 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
Line 417 
Line 279 
         @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 String& 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      /** existsMethod - Determine if the method object defined by the
         name input exists         name input exists
         @param String representing the name of the method to be found         @param String representing the name of the method to be found
         @return True if the method exists         @return True if the method exists
     */     */
     Boolean existsMethod(const String& name)      Boolean existsMethod(const String& name) const;
     {  
         _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.
Line 453 
Line 295 
         @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 476 
Line 310 
     @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)      void removeMethod(Uint32 pos);
     {  
         _checkRep();  
         _rep->removeMethod(pos);  
     }  
  
     /** 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      /** Get names of all keys of this class. */
         qualifiers. Make sure the superClass really exists and is consistent      void getKeyNames(Array<String>& keyNames) const;
         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:      Boolean hasKeys() const;
     operator int() const { return _rep != 0; }  
       /** Makes a deep copy (clone) of the given object. */
       CIMClass clone() const;
   
       /** identical -  Compares with another class
           ATTN: Clarify exactly what identical means
           @param Class object for the class to be compared
           @return True if the classes are identical
       */
       Boolean identical(const CIMConstClass& x) const;
  
     /** toXML  - prepares an XML representation of the CIMClass object     /** toXML  - prepares an XML representation of the CIMClass object
         in the provided Sint8 variable.         in the provided Sint8 variable.
         @param out Sint8 array for the XML representation         @param out Sint8 array for the XML representation
     */     */
     void toXml(Array<Sint8>& out) const      void toXml(Array<Sint8>& out) const;
     {  
         _checkRep();  
         _rep->toXml(out);  
     }  
   
     /** print -  Prints the toXML output to cout  
     */  
     void print(PEGASUS_STD(ostream) &o=PEGASUS_STD(cout)) const  
     {  
         _checkRep();  
         _rep->print(o);  
     }  
  
     /** toMof  - prepares a MOF representation of the CIMClass object     /** toMof  - prepares a MOF representation of the CIMClass object
         in the provided Sint8 variable.         in the provided Sint8 variable.
         @param out Sint8 array for the XML representation         @param out Sint8 array for the XML representation
     */     */
     void toMof(Array<Sint8>& out) const      void toMof(Array<Sint8>& out) const;
     {  
         _checkRep();  
         _rep->toMof(out);  
     }  
     /** printMof -  Prints the toMof output to cout  
     */  
     void printMof(PEGASUS_STD(ostream) &o=PEGASUS_STD(cout)) const  
     {  
         _checkRep();  
         _rep->printMof(o);  
     }  
  
     /** identical -  Compares with another class      /** print -  Prints the toXML output to cout
         ATTN: Clarify exactly what identical means  
         @param Class object for the class to be compared  
         @return True if the classes are identical  
     */     */
     Boolean identical(const CIMConstClass& x) const;      void print(PEGASUS_STD(ostream)& o=PEGASUS_STD(cout)) const;
  
     /** Makes a deep copy (clone) of the given object. */  #ifdef PEGASUS_INTERNALONLY
     CIMClass clone() const      /** Resolve -  Resolve the class: inherit any properties and
     {          qualifiers. Make sure the superClass really exists and is consistent
         return CIMClass((CIMClassRep*)(_rep->clone()));          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);
  
     /** Get names of all keys of this class. */      /// operator - ATTN:
     void getKeyNames(Array<String>& keyNames) const      operator int() const;
     {  
         _checkRep();  
         _rep->getKeyNames(keyNames);  
     }  
  
     Boolean hasKeys() const      /** printMof -  Prints the toMof output to cout
     {      */
         _checkRep();      void printMof(PEGASUS_STD(ostream)& o=PEGASUS_STD(cout)) const;
         return _rep->hasKeys();  #endif
     }  
  
 private: private:
  
     CIMClass(CIMClassRep* rep) : _rep(rep)      CIMClassRep* _rep;
     {  
     }  
  
     void _checkRep() const  #ifdef PEGASUS_INTERNALONLY
     {      CIMClass(CIMClassRep* rep);
         if (!_rep)  
             ThrowUnitializedHandle();      void _checkRep() const;
     }  
  
     CIMClassRep* _rep;  
     friend class CIMConstClass;     friend class CIMConstClass;
     friend class CIMObject;     friend class CIMObject;
     friend class CIMConstObject;     friend class CIMConstObject;
   #endif
 }; };
  
 #define PEGASUS_ARRAY_T CIMClass #define PEGASUS_ARRAY_T CIMClass
Line 598 
Line 393 
 { {
 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);  
     }  
  
     PEGASUS_EXPLICIT CIMConstClass(const CIMObject& x);     PEGASUS_EXPLICIT CIMConstClass(const CIMObject& x);
  
Line 620 
Line 407 
  
     PEGASUS_EXPLICIT CIMConstClass(const CIMConstObject& x, NoThrow&);     PEGASUS_EXPLICIT CIMConstClass(const CIMConstObject& x, NoThrow&);
  
     CIMConstClass& operator=(const CIMConstClass& x)  
     {  
         if (x._rep != _rep)  
         {  
             Dec(_rep);  
             Inc(_rep = x._rep);  
         }  
         return *this;  
     }  
   
     CIMConstClass& operator=(const CIMClass& x)  
     {  
         if (x._rep != _rep)  
         {  
             Dec(_rep);  
             Inc(_rep = x._rep);  
         }  
         return *this;  
     }  
   
     // Throws IllegalName if className argument not legal CIM identifier.     // Throws IllegalName if className argument not legal CIM identifier.
   
     CIMConstClass(     CIMConstClass(
         const CIMReference& reference,         const CIMReference& reference,
         const String& superClassName = String())          const String& superClassName = String::EMPTY);
     {  
         _rep = new CIMClassRep(reference, 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 Boolean equalClassName(const String& classname) const      Boolean isAbstract() const;
     {  
         _checkRep();  
         return _rep->equalClassName(classname);  
  
     }      const String& getClassName() const;
  
     const CIMReference& getPath() const      const Boolean equalClassName(const String& classname) const;
     {  
         _checkRep();  
         return _rep->getPath();  
     }  
  
     const String& getSuperClassName() const      const CIMReference& getPath() const;
     {  
         _checkRep();  
         return _rep->getSuperClassName();  
     }  
  
     Uint32 findQualifier(const String& name) const      const String& getSuperClassName() const;
     {  
         _checkRep();  
         return _rep->findQualifier(name);  
     }  
  
     CIMConstQualifier getQualifier(Uint32 pos) const      Uint32 findQualifier(const String& name) const;
     {  
         _checkRep();  
         return _rep->getQualifier(pos);  
     }  
  
     Boolean isTrueQualifier(const String& name) const      CIMConstQualifier getQualifier(Uint32 pos) const;
     {  
         _checkRep();  
         return _rep->isTrueQualifier(name);  
     }  
  
     Uint32 getQualifierCount() const      Boolean isTrueQualifier(const String& name) const;
     {  
         _checkRep();  
         return _rep->getQualifierCount();  
     }  
  
     Uint32 findProperty(const String& name) const      Uint32 getQualifierCount() const;
     {  
         _checkRep();  
         return _rep->findProperty(name);  
     }  
  
     CIMConstProperty getProperty(Uint32 pos) const      Uint32 findProperty(const String& name) const;
     {  
         _checkRep();  
         return _rep->getProperty(pos);  
     }  
  
     Uint32 getPropertyCount() const      CIMConstProperty getProperty(Uint32 pos) const;
     {  
         _checkRep();  
         return _rep->getPropertyCount();  
     }  
  
     Uint32 findMethod(const String& name) const      Uint32 getPropertyCount() const;
     {  
         _checkRep();  
         return _rep->findMethod(name);  
     }  
  
     CIMConstMethod getMethod(Uint32 pos) const      Uint32 findMethod(const String& name) const;
     {  
         _checkRep();  
         return _rep->getMethod(pos);  
     }  
  
     Uint32 getMethodCount() const      CIMConstMethod getMethod(Uint32 pos) const;
     {  
         _checkRep();  
         return _rep->getMethodCount();  
     }  
  
     operator int() const { return _rep != 0; }      Uint32 getMethodCount() const;
  
     void toXml(Array<Sint8>& out) const      void getKeyNames(Array<String>& keyNames) const;
     {  
         _checkRep();  
         _rep->toXml(out);  
     }  
  
     void print(PEGASUS_STD(ostream) &o=PEGASUS_STD(cout)) const      Boolean hasKeys() const;
     {  
         _checkRep();  
         _rep->print(o);  
     }  
  
     Boolean identical(const CIMConstClass& x) const      CIMClass clone() const;
     {  
         x._checkRep();  
         _checkRep();  
         return _rep->identical(x._rep);  
     }  
  
     CIMClass clone() const      Boolean identical(const CIMConstClass& x) const;
     {  
         return CIMClass((CIMClassRep*)(_rep->clone()));  
     }  
  
     void getKeyNames(Array<String>& keyNames) const  #ifdef PEGASUS_INTERNALONLY
     {      operator int() const;
         _checkRep();  
         _rep->getKeyNames(keyNames);  
     }  
  
     Boolean hasKeys() const      void toXml(Array<Sint8>& out) const;
     {  
         _checkRep();  
         return _rep->hasKeys();  
     }  
  
 private:      void print(PEGASUS_STD(ostream)& o=PEGASUS_STD(cout)) const;
   #endif
  
     void _checkRep() const  private:
     {  
         if (!_rep)  
             ThrowUnitializedHandle();  
     }  
  
     CIMClassRep* _rep;     CIMClassRep* _rep;
  
   #ifdef PEGASUS_INTERNALONLY
       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 CIMObject;
     friend class CIMConstObject;     friend class CIMConstObject;
   #endif
 }; };
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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