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

Diff for /pegasus/src/Pegasus/Common/CIMMethod.h between version 1.19 and 1.20

version 1.19, 2002/03/24 13:33:07 version 1.20, 2002/05/06 23:21:58
Line 22 
Line 22 
 // //
 // 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)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 30 
Line 30 
 #define Pegasus_Method_h #define Pegasus_Method_h
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <Pegasus/Common/CIMMethodRep.h>  #include <Pegasus/Common/String.h>
   #include <Pegasus/Common/CIMParameter.h>
   #include <Pegasus/Common/CIMQualifier.h>
   #include <Pegasus/Common/CIMType.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   class DeclContext;
 class CIMConstMethod; class CIMConstMethod;
   class CIMMethodRep;
  
 /** Class CIMMethod - This class defines the operations associated with /** Class CIMMethod - This class defines the operations associated with
     manipulation of the Pegasus implementation of the CIM CIMMethod. Within     manipulation of the Pegasus implementation of the CIM CIMMethod. Within
Line 48 
Line 53 
 public: public:
  
     /** Creates and instantiates a CIM method. */     /** Creates and instantiates a CIM method. */
     CIMMethod() : _rep(0)      CIMMethod();
     {  
   
     }  
  
     /** Creates and instantiates a CIM method from another method instance     /** Creates and instantiates a CIM method from another method instance
         @return pointer to the new method instance         @return pointer to the new method instance
     */     */
     CIMMethod(const CIMMethod& x)      CIMMethod(const CIMMethod& x);
     {  
         Inc(_rep = x._rep);  
     }  
   
     /** Assignment operator */  
     CIMMethod& operator=(const CIMMethod& x)  
     {  
         if (x._rep != _rep)  
         {  
             Dec(_rep);  
             Inc(_rep = x._rep);  
         }  
         return *this;  
     }  
  
     /** Creates a CIM method with the specified name, type, and classOrigin     /** Creates a CIM method with the specified name, type, and classOrigin
         @param name for the method         @param name for the method
Line 82 
Line 70 
     CIMMethod(     CIMMethod(
         const String& name,         const String& name,
         CIMType type,         CIMType type,
         const String& classOrigin = String(),          const String& classOrigin = String::EMPTY,
         Boolean propagated = false)          Boolean propagated = false);
     {  
         _rep = new CIMMethodRep(name, type, classOrigin, propagated);  
     }  
  
     /** Desctructor. */     /** Desctructor. */
     ~CIMMethod()      ~CIMMethod();
     {  
         Dec(_rep);      /** Assignment operator */
     }      CIMMethod& operator=(const CIMMethod& x);
  
     /** getName - Gets the name of the method     /** getName - Gets the name of the method
         @return String with the name of the method         @return String with the name of the method
     */     */
     const String& getName() const      const String& getName() const;
     {  
         _checkRep();  
         return _rep->getName();  
     }  
  
     /** setName - Set the method name     /** setName - Set the method name
         @param name         @param name
         @exception IllegalName if name argument not legal CIM identifier.         @exception IllegalName if name argument not legal CIM identifier.
     */     */
     void setName(const String& name)      void setName(const String& name);
     {  
         _checkRep();  
         _rep->setName(name);  
     }  
  
     /** getType - gets the method type     /** getType - gets the method type
         @return The CIM method type for this method.         @return The CIM method type for this method.
     */     */
     CIMType getType() const      CIMType getType() const;
     {  
         _checkRep();  
         return _rep->getType();  
     }  
  
     /** setType - Sets the method type to the specified CIM method     /** setType - Sets the method type to the specified CIM method
         type as defined in CIMType /Ref{TYPE}         type as defined in CIMType /Ref{TYPE}
     */     */
     void setType(CIMType type)      void setType(CIMType type);
     {  
         _checkRep();  
         _rep->setType(type);  
     }  
  
     /** getClassOrigin - Returns the class in which this method     /** getClassOrigin - Returns the class in which this method
         was defined.         was defined.
         @return String containing the classOrigin field.         @return String containing the classOrigin field.
     */     */
     const String& getClassOrigin() const      const String& getClassOrigin() const;
     {  
         _checkRep();  
         return _rep->getClassOrigin();  
     }  
  
     /** setClassOrigin - Set the ClassOrigin attribute with     /** setClassOrigin - Set the ClassOrigin attribute with
                 the classname defined on input                 the classname defined on input
                 @param classOrigin - String parameter defining the name                 @param classOrigin - String parameter defining the name
                 of the class origin                 of the class origin
         */         */
     void setClassOrigin(const String& classOrigin)      void setClassOrigin(const String& classOrigin);
     {  
         _checkRep();  
         _rep->setClassOrigin(classOrigin);  
     }  
  
     /** getPropagated - Tests the propogated qualifier     /** getPropagated - Tests the propogated qualifier
         @return - returns True if method is propogated         @return - returns True if method is propogated
         */         */
     Boolean getPropagated() const      Boolean getPropagated() const;
     {  
         _checkRep();  
         return _rep->getPropagated();  
     }  
  
     /** setPropagated - Sets the Propagaged Qualifier */     /** setPropagated - Sets the Propagaged Qualifier */
     void setPropagated(Boolean propagated)      void setPropagated(Boolean propagated);
     {  
         _checkRep();  
         _rep->setPropagated(propagated);  
     }  
  
     /** addQualifier - Adds a Qualifier to the method object.     /** addQualifier - Adds a Qualifier to the method object.
         @param CIMQualifier to be added         @param CIMQualifier to be added
Line 174 
Line 127 
         in the method         in the method
         @exception AlreadyExists exception         @exception AlreadyExists exception
     */     */
     CIMMethod& addQualifier(const CIMQualifier& x)      CIMMethod& addQualifier(const CIMQualifier& x);
     {  
         _checkRep();  
         _rep->addQualifier(x);  
         return *this;  
     }  
  
     /** findQualifier - returns the position of the qualifier with     /** findQualifier - returns the position of the qualifier with
         the given name.         the given name.
         @param name Name of qualifier to be found.         @param name Name of qualifier to be found.
         @return index of the parameter if found; otherwise PEG_NOT_FOUND.         @return index of the parameter if found; otherwise PEG_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 the position of the qualifier with     /** existsQualifier - returns the position of the qualifier with
         the given name.         the given name.
         @param name Name of qualifier to be found.         @param name Name of qualifier to be found.
         @return index of the parameter if found; otherwise PEG_NOT_FOUND.         @return index of the parameter if found; otherwise PEG_NOT_FOUND.
     */     */
     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);  
     }  
   
  
     /** getQualifier - Gets the CIMQualifier defined by the index     /** getQualifier - Gets the CIMQualifier defined by the index
         input as a parameter.         input as a parameter.
Line 223 
Line 150 
         @exception OutOfBounds exception if the index is outside the range of         @exception OutOfBounds exception if the index is outside the range of
         parameters available from the CIMMethod.         parameters available from the CIMMethod.
     */     */
     CIMQualifier getQualifier(Uint32 pos)      CIMQualifier getQualifier(Uint32 pos);
     {  
         _checkRep();  
         return _rep->getQualifier(pos);  
     }  
  
     CIMConstQualifier getQualifier(Uint32 pos) const      CIMConstQualifier getQualifier(Uint32 pos) const;
     {  
         _checkRep();  
         return _rep->getQualifier(pos);  
     }  
  
     /** removeQualifier - Removes the CIMQualifier defined by the     /** removeQualifier - Removes the CIMQualifier defined by the
         position input as a parameter.         position input as a parameter.
Line 242 
Line 161 
         @exception OutOfBounds exception if the index is outside the range of         @exception OutOfBounds exception if the index is outside the range of
         parameters available from the CIMMethod.         parameters available from the CIMMethod.
     */     */
     void removeQualifier(Uint32 pos)      void removeQualifier(Uint32 pos);
     {  
         _checkRep();  
         _rep->removeQualifier(pos);  
     }  
   
  
     /** getQualifierCount - Returns the number of Qualifiers attached     /** getQualifierCount - Returns the number of Qualifiers attached
         to this CIMmethod object.          to this CIMMethod object.
         @return integer representing number of Qualifiers.         @return integer representing number of Qualifiers.
     */     */
     Uint32 getQualifierCount() const      Uint32 getQualifierCount() const;
     {  
         _checkRep();  
         return _rep->getQualifierCount();  
     }  
  
     /** addParameter - Adds the parameter defined by the input     /** addParameter - Adds the parameter defined by the input
         to the CIMMethod         to the CIMMethod
     */     */
     CIMMethod& addParameter(const CIMParameter& x)      CIMMethod& addParameter(const CIMParameter& x);
     {  
         _checkRep();  
         _rep->addParameter(x);  
         return *this;  
     }  
  
     /** findParameter - Finds the parameter whose name is given     /** findParameter - Finds the parameter whose name is given
         by the name parameter.         by the name parameter.
         @param name Name of parameter to be found.         @param name Name of parameter to be found.
         @return index of the parameter if found; otherwise PEG_NOT_FOUND.         @return index of the parameter if found; otherwise PEG_NOT_FOUND.
     */     */
     Uint32 findParameter(const String& name)      Uint32 findParameter(const String& name) const;
     {  
         _checkRep();  
         return _rep->findParameter(name);  
     }  
   
     Uint32 findParameter(const String& name) const  
     {  
         _checkRep();  
         return _rep->findParameter(name);  
     }  
  
     /** getParameter - ATTN: */     /** getParameter - ATTN: */
     CIMParameter getParameter(Uint32 pos)      CIMParameter getParameter(Uint32 pos);
     {  
         _checkRep();  
         return _rep->getParameter(pos);  
     }  
  
     /** getParameter - Gets the parameter defined by the index     /** getParameter - Gets the parameter defined by the index
         input as a parameter.         input as a parameter.
Line 300 
Line 191 
         @Exception OutOfBounds exception is thrown if the index is outside the         @Exception OutOfBounds exception is thrown if the index is outside the
         range of available parameters         range of available parameters
     */     */
     CIMConstParameter getParameter(Uint32 pos) const      CIMConstParameter getParameter(Uint32 pos) const;
     {  
         _checkRep();  
         return _rep->getParameter(pos);  
     }  
  
     /** getParameterCount - Gets the count of the numbeer of     /** getParameterCount - Gets the count of the numbeer of
         Parameters attached to the CIMMethod.         Parameters attached to the CIMMethod.
         @retrun - count of the number of parameters attached to the CIMMethod.         @retrun - count of the number of parameters attached to the CIMMethod.
     */     */
     Uint32 getParameterCount() const      Uint32 getParameterCount() const;
     {  
         _checkRep();  
         return _rep->getParameterCount();  
     }  
  
   #ifdef PEGASUS_INTERNALONLY
     /** resolve - resolves and completes the CIMMethod */     /** resolve - resolves and completes the CIMMethod */
     void resolve(     void resolve(
         DeclContext* declContext,         DeclContext* declContext,
         const String& nameSpace,         const String& nameSpace,
         const CIMConstMethod& method)          const CIMConstMethod& method);
     {  
         _checkRep();  
         _rep->resolve(declContext, nameSpace, method);  
     }  
  
     /** resolve - Resolves and completes the CIMMethod */     /** resolve - Resolves and completes the CIMMethod */
     void resolve(     void resolve(
         DeclContext* declContext,         DeclContext* declContext,
         const String& nameSpace)          const String& nameSpace);
     {  
         _checkRep();  
         _rep->resolve(declContext, nameSpace);  
     }  
  
     /** Returns zero if CIMMethod refers to a null pointer */     /** Returns zero if CIMMethod refers to a null pointer */
     operator int() const      operator int() const;
     {  #endif
         return _rep != 0;  
     }  
  
     /** toXML - puts XML encoding of this CIMMethod object into out     /** toXML - puts XML encoding of this CIMMethod object into out
         arguemnt.          argument.
     */     */
     void toXml(Array<Sint8>& out) const      void toXml(Array<Sint8>& out) const;
     {  
         _checkRep();  
         _rep->toXml(out);  
     }  
  
     /** print - formats and prints this CIMmethod (in CIM XML encoded form).     /** print - formats and prints this CIMmethod (in CIM XML encoded form).
     */     */
     void print(PEGASUS_STD(ostream) &o=PEGASUS_STD(cout)) const      void print(PEGASUS_STD(ostream)& o=PEGASUS_STD(cout)) const;
     {  
         _checkRep();  
         _rep->print(o);  
     }  
  
     /** toMof - puts MOF encoding of this object into out arguemnt.     /** toMof - puts MOF encoding of this object into out arguemnt.
     */     */
     void toMof(Array<Sint8>& out) const      void toMof(Array<Sint8>& out) const;
     {  
         _checkRep();  
         _rep->toMof(out);  
     }  
  
     /** identical - Returns true if this method is identical to the     /** identical - Returns true if this method is identical to the
         one given by the argument x.         one given by the argument x.
Line 372 
Line 234 
     Boolean identical(const CIMConstMethod& x) const;     Boolean identical(const CIMConstMethod& x) const;
  
     /** CIMMethod clone - makes a distinct replica of this method */     /** CIMMethod clone - makes a distinct replica of this method */
     CIMMethod clone() const      CIMMethod clone() const;
     {  
         return CIMMethod(_rep->clone());  
     }  
  
 private: private:
  
     CIMMethod(CIMMethodRep* rep) : _rep(rep)      CIMMethod(CIMMethodRep* rep);
     {  
     }  
  
     PEGASUS_EXPLICIT CIMMethod(const CIMConstMethod& x);     PEGASUS_EXPLICIT CIMMethod(const CIMConstMethod& x);
  
     void _checkRep() const      void _checkRep() const;
     {  
         if (!_rep)  
             ThrowUnitializedHandle();  
     }  
  
     CIMMethodRep* _rep;     CIMMethodRep* _rep;
     friend class CIMConstMethod;     friend class CIMConstMethod;
     friend class CIMClassRep;  
 }; };
  
 class PEGASUS_COMMON_LINKAGE CIMConstMethod class PEGASUS_COMMON_LINKAGE CIMConstMethod
 { {
 public: public:
  
     CIMConstMethod() : _rep(0)      CIMConstMethod();
     {  
   
     }  
  
     CIMConstMethod(const CIMConstMethod& x)      CIMConstMethod(const CIMConstMethod& x);
     {  
         Inc(_rep = x._rep);  
     }  
   
     CIMConstMethod(const CIMMethod& x)  
     {  
         Inc(_rep = x._rep);  
     }  
   
     CIMConstMethod& operator=(const CIMConstMethod& x)  
     {  
         if (x._rep != _rep)  
         {  
             Dec(_rep);  
             Inc(_rep = x._rep);  
         }  
         return *this;  
     }  
  
     CIMConstMethod& operator=(const CIMMethod& x)      CIMConstMethod(const CIMMethod& x);
     {  
         if (x._rep != _rep)  
         {  
             Dec(_rep);  
             Inc(_rep = x._rep);  
         }  
         return *this;  
     }  
  
     // Throws IllegalName if name argument not legal CIM identifier.     // Throws IllegalName if name argument not legal CIM identifier.
   
     CIMConstMethod(     CIMConstMethod(
         const String& name,         const String& name,
         CIMType type,         CIMType type,
         const String& classOrigin = String(),          const String& classOrigin = String::EMPTY,
         Boolean propagated = false)          Boolean propagated = false);
     {  
         _rep = new CIMMethodRep(name, type, classOrigin, propagated);  
     }  
  
     ~CIMConstMethod()      ~CIMConstMethod();
     {  
         Dec(_rep);  
     }  
  
     const String& getName() const      CIMConstMethod& operator=(const CIMConstMethod& x);
     {  
         _checkRep();  
         return _rep->getName();  
     }  
  
     CIMType getType() const      CIMConstMethod& operator=(const CIMMethod& x);
     {  
         _checkRep();  
         return _rep->getType();  
     }  
  
     const String& getClassOrigin() const      const String& getName() const;
     {  
         _checkRep();  
         return _rep->getClassOrigin();  
     }  
  
     Boolean getPropagated() const      CIMType getType() const;
     {  
         _checkRep();  
         return _rep->getPropagated();  
     }  
  
     Uint32 findQualifier(const String& name) const      const String& getClassOrigin() const;
     {  
         _checkRep();  
         return _rep->findQualifier(name);  
     }  
  
     Uint32 getQualifier(Uint32 pos) const      Boolean getPropagated() const;
     {  
         _checkRep();  
         return _rep->getQualifier(pos);  
     }  
  
     Uint32 getQualifierCount() const      Uint32 findQualifier(const String& name) const;
     {  
         _checkRep();  
         return _rep->getQualifierCount();  
     }  
  
     Uint32 findParameter(const String& name) const      Uint32 getQualifier(Uint32 pos) const;
     {  
         _checkRep();  
         return _rep->findParameter(name);  
     }  
  
     CIMConstParameter getParameter(Uint32 pos) const      Uint32 getQualifierCount() const;
     {  
         _checkRep();  
         return _rep->getParameter(pos);  
     }  
  
     Uint32 getParameterCount() const      Uint32 findParameter(const String& name) const;
     {  
         _checkRep();  
         return _rep->getParameterCount();  
     }  
  
     operator int() const { return _rep != 0; }      CIMConstParameter getParameter(Uint32 pos) const;
  
     void toXml(Array<Sint8>& out) const      Uint32 getParameterCount() const;
     {  
         _checkRep();  
         _rep->toXml(out);  
     }  
  
     void print(PEGASUS_STD(ostream) &o=PEGASUS_STD(cout)) const  #ifdef PEGASUS_INTERNALONLY
     {      operator int() const;
         _checkRep();  
         _rep->print(o);  
     }  
  
     Boolean identical(const CIMConstMethod& x) const      void toXml(Array<Sint8>& out) const;
     {  
         x._checkRep();  
         _checkRep();  
         return _rep->identical(x._rep);  
     }  
  
     CIMMethod clone() const      void print(PEGASUS_STD(ostream)& o=PEGASUS_STD(cout)) const;
     {  #endif
         return CIMMethod(_rep->clone());  
     }      Boolean identical(const CIMConstMethod& x) const;
   
       CIMMethod clone() const;
  
 private: private:
  
     void _checkRep() const      void _checkRep() const;
     {  
         if (!_rep)  
             ThrowUnitializedHandle();  
     }  
  
     CIMMethodRep* _rep;     CIMMethodRep* _rep;
  

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