(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.13 and 1.45

version 1.13, 2001/05/24 00:48:35 version 1.45, 2004/08/25 00:14:24
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2003////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000 The Open Group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002  BMC Software, Hewlett-Packard Development
   // Company, L. P., IBM Corp., The Open Group, Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.;
   // IBM Corp.; EMC Corporation, The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a  // Permission is hereby granted, free of charge, to any person obtaining a copy
 // copy of this software and associated documentation files (the "Software"),  // of this software and associated documentation files (the "Software"), to
 // to deal in the Software without restriction, including without limitation  // deal in the Software without restriction, including without limitation the
 // the rights to use, copy, modify, merge, publish, distribute, sublicense,  // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 // and/or sell copies of the Software, and to permit persons to whom the  // sell copies of the Software, and to permit persons to whom the Software is
 // Software is furnished to do so, subject to the following conditions:  // furnished to do so, subject to the following conditions:
 // //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL  // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING  // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER  // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 // DEALINGS IN THE SOFTWARE.  // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
   // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (mbrasher@bmc.com)  
 //  
 // Modified By:  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #ifndef Pegasus_Method_h #ifndef Pegasus_Method_h
 #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/Linkage.h>
   #include <Pegasus/Common/String.h>
   #include <Pegasus/Common/CIMName.h>
   #include <Pegasus/Common/CIMParameter.h>
   #include <Pegasus/Common/CIMQualifier.h>
   #include <Pegasus/Common/CIMType.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   class Resolver;
 class CIMConstMethod; class CIMConstMethod;
   class CIMMethodRep;
  
 /** Class CIMMethod - This class defines the operations associated with  /** The CIMMethod class is used to represent CIM methods in Pegasus.
     manipulation of the Pegasus implementation of the CIM CIMMethod. Within      A CIMMethod consists of the following entities:
     this class, methods are provides for creation, deletion, and manipulation      <ul>
     of method declarations.          <li>Name of the method, a CIMName.
   
     // ATTN: remove the classOrigin and propagated parameters.          <li>CIM type of the method return value, a CIMType.
   
           <li>Optional qualifiers (see CIMQualifier) for the method.
           A method can contain zero or more CIMQualifier objects.
   
           <li>Optional parameters (see CIMParameter) for the method.
           A CIMMethod may contain zero or more CIMParameter objects.
       </ul>
       In addition, a CIMMethod contains the following internal attributes:
       <ul>
           <li><b>propagated</b> - An attribute defining whether this CIMMethod is
           propagated from a superclass.  Note that this is normally set as part
           of completing the definition of objects (resolving) when they are
           created as part of a CIM schema and is NOT automatically set when
           creating a local object.  It can only be logically set in context of
           the schema in which the CIMMethod is defined.
           <li><b>classOrigin</b> - An attribute defining the class in which
           this CIMMethod was originally defined.  This is normally set within the
           context of the schema in which the CIMMethod is defined.
           This attribute is available from objects retrieved from the CIM
           Server, for example, and provides information on the defintion
           of this method in the class hierarchy.  Together the
           propagated and ClassOrigin attributes can be used to determine if
           methods originated with the current object or were inherited from
           higher levels in the hiearchy.
       </ul>
       A CIMMethod is generally defined in the context of a CIMClass.
   
       CIMMethod uses shared representations, meaning that multiple
       CIMMethod objects may refer to the same copy of data. Assignment and copy
       operators create new references to the same data, not distinct copies.
       A distinct copy may be created using the clone method.
       {@link Shared Classes}
       @see CIMConstMethod
       @see CIMParameter
       @see CIMQualifier
       @see CIMType
       @see CIMClass
 */ */
 class PEGASUS_COMMON_LINKAGE CIMMethod class PEGASUS_COMMON_LINKAGE CIMMethod
 { {
 public: public:
  
     /** Creates and instantiates a CIM method. */      /** Creates a new uninitialized CIMMethod object.
     CIMMethod() : _rep(0)          The only thing that can be done with this object is to copy another
     {          object into it.  Other methods, such as setName, will fail with an
           UninitializedObjectException.  The object has an uninitialized state,
     }          which can be tested with the isUninitialized method.
           @see isUninitialized()
     /** Creates and instantiates a CIM method from another method instance          @see UninitializedObjectException
         @return pointer to the new method instance      */
     */      CIMMethod();
     CIMMethod(const CIMMethod& x)  
     {      /** Creates a new CIMMethod object from another CIMMethod object.
         Inc(_rep = x._rep);          The new CIMMethod object references the same copy of data as the
     }          specified object; no copy is made.
           @param x CIMMethod object from which to create the new CIMMethod object.
     /** Assignment operator */          <p><b>Example:</b>
     CIMMethod& operator=(const CIMMethod& x)          <pre>
     {              CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);
         if (x._rep != _rep)              const CIMMethod cm1(m1);
         {          </pre>
             Dec(_rep);          {@link Shared Classes}
             Inc(_rep = x._rep);      */
         }      CIMMethod(const CIMMethod& x);
         return *this;  
     }      /** Creates a CIMMethod object with the specified attributes.
           @param name CIMName defining the name for the method.
     /**  Creates a CIM method with the specified name, type, and classOrigin  
         @param name for the method          @param type CIMType defining the method return type.
         @param type ATTN  
         @param classOrigin          @param classOrigin (optional) CIMName representing the class origin.
         @param propagated              Note that this should normally not be used.  If not provided set to
         @return  Throws IllegalName if name argument not legal CIM identifier.              CIMName() (Null name).
           @param propagated Optional flag indicating whether the definition of
               the CIM Method is local to the CIM Class (respectively, Instance)
               in which it appears, or was propagated without modification from
               a superclass. Default is false. Note that this attribute is
               normally not set by CIM Clients but is used internally within the
               CIM Server.
           <p><b>Example:</b>
           <pre>
               CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);
           </pre>
     */     */
     CIMMethod(     CIMMethod(
         const String& name,          const CIMName& name,
         CIMType type,         CIMType type,
         const String& classOrigin = String(),          const CIMName& classOrigin = CIMName(),
         Boolean propagated = false)          Boolean propagated = false);
     {  
         _rep = new CIMMethodRep(name, type, classOrigin, propagated);  
     }  
   
     /** Desctructor. */  
     ~CIMMethod()  
     {  
         Dec(_rep);  
     }  
   
     /** CIMMethod getName - Gets the name of the method  
         @return String with the name of the method  
     */  
     const String& getName() const  
     {  
         _checkRep();  
         return _rep->getName();  
     }  
   
     /** CIMMethod setName - Set the method name  
         @param name  
         @exception IllegalName if name argument not legal CIM identifier.  
     */  
     void setName(const String& name)  
     {  
         _checkRep();  
         _rep->setName(name);  
     }  
   
     /** CIMMethod getType - gets the method type  
         @return The CIM method type for this method.  
     */  
     CIMType getType() const  
     {  
         _checkRep();  
         return _rep->getType();  
     }  
   
     /** CIMMethod setType - Sets the method type to the specified CIM method  
         type as defined in CIMType /Ref{TYPE}  
     */  
     void setType(CIMType type)  
     {  
         _checkRep();  
         _rep->setType(type);  
     }  
   
     /** CIMMethod getClassOrigin - Returns the class in which this method  
         was defined.  
         @return ATTN:  
     */  
     const String& getClassOrigin() const  
     {  
         _checkRep();  
         return _rep->getClassOrigin();  
     }  
   
     /** CIMMethod setClassOrigin - ATTN: */  
     void setClassOrigin(const String& classOrigin)  
     {  
         _checkRep();  
         _rep->setClassOrigin(classOrigin);  
     }  
   
     /** method getPropagated - ATTN: */  
     Boolean getPropagated() const  
     {  
         _checkRep();  
         return _rep->getPropagated();  
     }  
   
     /** method setPropagated - ATTN: */  
     void setPropagated(Boolean propagated)  
     {  
         _checkRep();  
         _rep->setPropagated(propagated);  
     }  
   
     /** CIMMethod addQualifier - Adds a Qualifier to the method object.  
         @param CIMQualifier to be added  
         @return Throws AlreadyExists excetpion if the qualifier already exists  
         in the method  
         @exception AlreadyExists exception  
     */  
     CIMMethod& addQualifier(const CIMQualifier& x)  
     {  
         _checkRep();  
         _rep->addQualifier(x);  
         return *this;  
     }  
   
     /** CIMMethod findQualifier - returns the position of the qualifier with  
         the given name.  
         @param name Name of qualifier to be found.  
         @return index of the parameter if found; otherwise PEG_NOT_FOUND.  
     */  
     Uint32 findQualifier(const String& name)  
     {  
         _checkRep();  
         return _rep->findQualifier(name);  
     }  
   
     Uint32 findQualifier(const String& name) const  
     {  
         _checkRep();  
         return _rep->findQualifier(name);  
     }  
   
     /** existsQualifier - returns the position of the qualifier with  
         the given name.  
         @param name Name of qualifier to be found.  
         @return index of the parameter if found; otherwise PEG_NOT_FOUND.  
     */  
     Boolean existsQualifier(const String& name)  
     {  
         _checkRep();  
         return _rep->existsQualifier(name);  
     }  
   
     Boolean existsQualifier(const String& name) const  
     {  
         _checkRep();  
         return _rep->existsQualifier(name);  
     }  
   
   
     /** CIMMethod getQualifier - Gets the CIMQualifier defined by the index  
         input as a parameter.  
         @param Index of the qualifier requested.  
         @return CIMQualifier object or exception  
         @exception OutOfBounds exception if the index is outside the range of  
         parameters available from the CIMMethod.  
     */  
     CIMQualifier getQualifier(Uint32 pos)  
     {  
         _checkRep();  
         return _rep->getQualifier(pos);  
     }  
   
     CIMConstQualifier getQualifier(Uint32 pos) const  
     {  
         _checkRep();  
         return _rep->getQualifier(pos);  
     }  
   
     /** removeQualifier - Removes the CIMQualifier defined by the  
         position input as a parameter.  
         @param Position of the qualifier requested.  
         @return CIMQualifier object or exception  
         @exception OutOfBounds exception if the index is outside the range of  
         parameters available from the CIMMethod.  
     */  
     void removeQualifier(Uint32 pos)  
     {  
         _checkRep();  
         _rep->removeQualifier(pos);  
     }  
   
   
     /** CIMMethod getQualifierCount - Returns the number of Qualifiers attached  
         to this method.  
         @return integer representing number of Qualifiers.  
     */  
     Uint32 getQualifierCount() const  
     {  
         _checkRep();  
         return _rep->getQualifierCount();  
     }  
   
     /** CIMMethod addParameter - Adds the parameter defined by the input  
         to the CIMMethod  
     */  
     CIMMethod& addParameter(const CIMParameter& x)  
     {  
         _checkRep();  
         _rep->addParameter(x);  
         return *this;  
     }  
   
     /** CIMMethod findParameter - Finds the parameter whose name is given  
         by the name parameter.  
         @param name Name of parameter to be found.  
         @return index of the parameter if found; otherwise PEG_NOT_FOUND.  
     */  
     Uint32 findParameter(const String& name)  
     {  
         _checkRep();  
         return _rep->findParameter(name);  
     }  
   
     Uint32 findParameter(const String& name) const  
     {  
         _checkRep();  
         return _rep->findParameter(name);  
     }  
   
     /** CIMMethod getParameter - ATTN: */  
     CIMParameter getParameter(Uint32 pos)  
     {  
         _checkRep();  
         return _rep->getParameter(pos);  
     }  
   
     /** CIMMethod getParameter - Gets the parameter defined by the index  
         input as a parameter.  
         @param index for the parameter to be returned.  
         @return CIMParameter requested.  
         @Exception OutOfBounds exception is thrown if the index is outside the  
         range of available parameters  
     */  
     CIMConstParameter getParameter(Uint32 pos) const  
     {  
         _checkRep();  
         return _rep->getParameter(pos);  
     }  
   
     /** CIMMethod getParameterCount - Gets the count of the numbeer of  
         Parameters attached to the CIMMethod.  
         @retrun - count of the number of parameters attached to the CIMMethod.  
     */  
     Uint32 getParameterCount() const  
     {  
         _checkRep();  
         return _rep->getParameterCount();  
     }  
   
     /** method resolve - ATTN: */  
     void resolve(  
         DeclContext* declContext,  
         const String& nameSpace,  
         const CIMConstMethod& method)  
     {  
         _checkRep();  
         _rep->resolve(declContext, nameSpace, method);  
     }  
   
     /** CIMMethod resolve */  
     void resolve(  
         DeclContext* declContext,  
         const String& nameSpace)  
     {  
         _checkRep();  
         _rep->resolve(declContext, nameSpace);  
     }  
   
     /** Returns zero if CIMMethod refers to a null pointer */  
     operator int() const  
     {  
         return _rep != 0;  
     }  
   
     /** method toXML - placing XML encoding of this object into out arguemnt. */  
     void toXml(Array<Sint8>& out) const  
     {  
         _checkRep();  
         _rep->toXml(out);  
     }  
   
     /** method print - prints this method (in CIM encoded form). */  
     void print(PEGASUS_STD(ostream) &o=PEGASUS_STD(cout)) const  
     {  
         _checkRep();  
         _rep->print(o);  
     }  
  
     /** CIMMethod identical - Returns true if this method is identical to the      /** Destructor for the CIMMethod.  The shared data copy remains valid until
         one given by the argument x.          all referring objects are destructed.
           {@link Shared Classes}
       */
       ~CIMMethod();
   
       /** The assignment operator assigns one CIMMethod to another.
           After the assignment, both CIMMethod objects refer to the same
           data copy; a distinct copy is not created.
           @param x CIMMethod object from which to assign this CIMMethod object.
   
           <p><b>Example:</b>
           <pre>
               CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);
               CIMMethod m2;
               m2 = m1;
           </pre>
       */
       CIMMethod& operator=(const CIMMethod& x);
   
       /** Gets the name of the method.
           @return CIMName with the name of the method.
           <p><b>Example:</b>
           <pre>
               CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);
               assert(m1.getName() == CIMName ("getHostName"));
           </pre>
       */
       const CIMName& getName() const;
   
       /** Sets the method name.
           @param name CIMName for the method name. Replaces any
               previously defined name for this method object.
           <p><b>Example:</b>
           <pre>
               CIMMethod m2(CIMName ("test"), CIMTYPE_STRING);
               m2.setName(CIMName ("getVersion"));
           </pre>
       */
       void setName(const CIMName& name);
   
       /** Gets the method return type.
           @return A CIMType containing the method return type.
           @exception UninitializedObjectException Thrown if the object is not
           initialized.
           <p><b>Example:</b>
           <pre>
               CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);
               assert(m1.getType() == CIMTYPE_STRING);
           </pre>
       */
       CIMType getType() const;
   
       /** Sets the method return type to the specified CIMType.
           This is the type of the CIMValue
           that is returned on a CIM method invocation.
           @param type CIMType to be set into the CIMMethod object.
           @exception UninitializedObjectException Thrown if the object is not
           initialized.
           <p><b>Example:</b>
           <pre>
               CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);
               m1.setName(CIMName ("getVersion"));
               assert(m1.getName() == CIMName ("getVersion"));
           </pre>
       */
       void setType(CIMType type);
   
       /** Gets the class in which this method was defined. This information
           is normally available with methods that are part of a schema
           returned from a CIM Server.
           @return CIMName containing the classOrigin attribute.
       */
       const CIMName& getClassOrigin() const;
   
       /** Sets the classOrigin attribute with the specified class name.
           Normally this method is used internally by a CIM Server when
           defining methods in the context of a schema.
           @param classOrigin CIMName parameter defining the name
           of the origin class.
           @exception UninitializedObjectException Thrown if the object is not
           initialized.
       */
       void setClassOrigin(const CIMName& classOrigin);
   
       /** Tests the propagated attribute of the object.  The propagated
           attribute indicates whether this method was propagated from a
           higher-level class.  Normally this attribute is set as part of
           defining a method in the context of a schema.  It is set in
           methods retrieved from a CIM Server.
           @return True if method is propagated; otherwise, false.
       */
       Boolean getPropagated() const;
   
       /** Sets the propagated attribute.  Normally this is used by a CIM Server
           when defining a method in the context of a schema.
           @param propagated Flag indicating whether the method is propagated
           from a superclass.
           @exception UninitializedObjectException Thrown if the object is not
           initialized.
       */
       void setPropagated(Boolean propagated);
   
       /** Adds the specified qualifier to the CIMMethod object.
           @param x CIMQualifier object representing the qualifier
           to be added.
           @return The CIMMethod object after adding the specified qualifier.
           @exception AlreadyExistsException Thrown if the qualifier already
           exists in this CIMMethod.
           <p><b>Example:</b>
           <pre>
               CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);
               m1.addQualifier(CIMQualifier(CIMName ("stuff"), true));
           </pre>
       */
       CIMMethod& addQualifier(const CIMQualifier& x);
   
       /** Searches for a qualifier with the specified input name.
           @param name CIMName of the qualifier to be found.
           @return Zero origin index of the qualifier found or PEG_NOT_FOUND
           if not found.
           @exception UninitializedObjectException Thrown if the object is not
           initialized.
           <p><b>Example:</b>
           <pre>
               CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);
               m1.addQualifier(CIMQualifier(CIMName ("stuff"), true));
               assert(m1.findQualifier(CIMName ("stuff")) != PEG_NOT_FOUND);
           </pre>
       */
       Uint32 findQualifier(const CIMName& name) const;
   
       /** Gets the CIMQualifier defined by the input parameter.
           @param index Zero origin index of the qualifier requested.
           @return CIMQualifier object representing the qualifier found.
           @exception IndexOutOfBoundsException Thrown if the index is
           outside the range of parameters available from the CIMMethod.
           <p><b>Example:</b>
           <pre>
               CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);
               m1.addQualifier(CIMQualifier(CIMName ("stuff"), true));
               Uint32 posQualifier = m1.findQualifier(CIMName ("stuff"));
               if (posQualifier != PEG_NOT_FOUND)
               {
                   CIMQualifier q = m1.getQualifier(posQualifier);
               }
           </pre>
       */
       CIMQualifier getQualifier(Uint32 index);
   
       /** Gets the CIMQualifier defined by the input parameter.
           @param index Zero origin index of the qualifier requested.
           @return CIMQualifier object representing the qualifier found.
           @exception IndexOutOfBoundsException Thrown if the index is
           outside the range of parameters available from the CIMMethod.
           <p><b>Example:</b>
           <pre>
               CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);
               m1.addQualifier(CIMQualifier(CIMName ("stuff"), true));
               const CIMMethod m2 = m1;
               Uint32 posQualifier = m2.findQualifier(CIMName ("stuff"));
               if (posQualifier != PEG_NOT_FOUND)
               {
                   CIMConstQualifier q = m2.getQualifier(posQualifier);
               }
           </pre>
       */
       CIMConstQualifier getQualifier(Uint32 index) const;
   
       /** Removes the specified qualifier from this method.
           @param index Index of the qualifier to remove.
           @exception IndexOutOfBoundsException Thrown if the index is
               outside the range of parameters available from the CIMMethod.
           <p><b>Example:</b>
           <pre>
               // remove all qualifiers from a class
               Uint32 count = 0;
               while((count = cimClass.getQualifierCount()) > 0)
                   cimClass.removeQualifier(count - 1);
           </pre>
       */
       void removeQualifier(Uint32 index);
   
       /** Returns the number of Qualifiers attached to this CIMMethod object.
           @return The number of qualifiers attached to the CIM Method.
           <p><b>Example:</b>
           <pre>
               CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);
               m1.addQualifier(CIMQualifier(CIMName ("stuff"), true));
               m1.addQualifier(CIMQualifier(CIMName ("stuff2"), true));
               assert(m1.getQualifierCount() == 2);
           </pre>
       */
       Uint32 getQualifierCount() const;
   
       /** Adds the parameter defined by the input to the CIMMethod.
           @param x CIMParameter to be added to the CIM Method.
           @return CIMMethod object after the specified parameter is added.
           <p><b>Example:</b>
           @exception UninitializedObjectException Thrown if the object is not
           initialized.
           @exception AlreadyExistsException Thrown if the parameter already
           exists in this CIMMethod.
           <pre>
               CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);
               m1.addParameter(CIMParameter(CIMName ("ipaddress"), CIMTYPE_STRING));
           </pre>
       */
       CIMMethod& addParameter(const CIMParameter& x);
   
       /** Finds the parameter with the specified name.
           @param name CIMName of parameter to be found.
           @return Index of the parameter object found or PEG_NOT_FOUND
           if the property is not found.
           <p><b>Example:</b>
           <pre>
               Uint32 posParameter;
               posParameter = m1.findParameter(CIMName ("ipaddress"));
               if (posParameter != PEG_NOT_FOUND)
                   ...
           </pre>
       */
       Uint32 findParameter(const CIMName& name) const;
   
       /** Gets the parameter defined by the specified index.
           @param index Index for the parameter to be returned.
           @return CIMParameter object requested.
           @exception IndexOutOfBoundsException Thrown if the index is outside
               the range of available parameters.
           <p><b>Example:</b>
           <pre>
               CIMParameter cp;
               Uint32 parameterIndex = m1.findParameter(CIMName ("ipaddress"));
               if (parameterIndex != PEG_NOT_FOUND)
               {
                   cp = m1.getParameter(parameterIndex);
               }
           </pre>
       */
       CIMParameter getParameter(Uint32 index);
   
       /** Gets the parameter defined by the specified index.
           @param index Index for the parameter to be returned.
           @return CIMParameter object requested.
           @exception IndexOutOfBoundsException Thrown if the index is outside
               the range of available parameters.
           <p><b>Example:</b>
           <pre>
               CIMConstParameter cp;
               Uint32 parameterIndex = m1.findParameter(CIMName ("ipaddress"));
               if (parameterIndex != PEG_NOT_FOUND)
               {
                   cp = m1.getParameter(parameterIndex);
               }
           </pre>
       */
       CIMConstParameter getParameter(Uint32 index) const;
   
       /** Removes the parameter defined by the specified index.
           @param index Index of the parameter to be removed.
           @exception IndexOutOfBoundsException Thrown if the index is outside the
               range of parameters available from the CIMMethod.
       */
       void removeParameter (Uint32 index);
   
       /** Gets the count of Parameters defined in the CIMMethod.
           @return Count of the number of parameters attached to the CIMMethod.
       */
       Uint32 getParameterCount() const;
   
       /** Determines if the object has not been initialized.
           @return True if the object has not been initialized;
                   otherwise, false.
           <p><b>Example:</b>
           <pre>
               CIMMethod m1;
               assert(m1.isUninitialized());
           </pre>
        */
       Boolean isUninitialized() const;
   
       /** Compares with a CIMConstMethod.
           @param x CIMConstMethod object for the method to be compared.
           @return True if this method is identical to the one specified;
                   otherwise, false.
           <p><b>Example:</b>
           <pre>
               CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);
               CIMConstMethod m2(CIMName ("test"), CIMTYPE_STRING);
               assert(!m1.identical(m2));
           </pre>
     */     */
     Boolean identical(const CIMConstMethod& x) const;     Boolean identical(const CIMConstMethod& x) const;
  
     /** CIMMethod clone - makes a distinct replica of this method */      /** Makes a clone (deep copy) of this method. This creates
     CIMMethod clone() const          a new copy of all of the components of the method including
     {          parameters and qualifiers.
         return CIMMethod(_rep->clone());          @return Independent copy of the CIMMethod object.
     }      */
       CIMMethod clone() const;
  
 private: private:
  
     CIMMethod(CIMMethodRep* rep) : _rep(rep)      CIMMethod(CIMMethodRep* rep);
     {  
     }  
  
       /** This method is not implemented.  It is defined to explicitly disallow
           construction of a CIMMethod from a CIMConstMethod.  Because the
           CIMMethod class uses a shared representation model, allowing this
           construction would effectively allow modification of CIMConstMethod
           objects.
       */
     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;      friend class Resolver;
       friend class XmlWriter;
       friend class MofWriter;
       friend class BinaryStreamer;
 }; };
  
   /** The CIMConstMethod class is used to represent CIM methods in the
       same manner as the CIMMethod class except that the const attribute
       is applied to the objects created. This class includes equivalents
       to the methods from CIMMethod that are available in a const object,
       including constructors, accessor methods, and the destructor.
   
       Because the CIMMethod class uses a shared representation model, allowing
       the construction of a 'CIMMethod' from a 'const CIMMethod' would
       effectively allow modification of a 'const CIMMethod'.  The CIMConstMethod
       class is used to represent constant CIMMethod objects.  Since a
       CIMConstMethod cannot be converted to a CIMMethod, its value remains
       constant.
   
       @see CIMMethod()
   */
 class PEGASUS_COMMON_LINKAGE CIMConstMethod class PEGASUS_COMMON_LINKAGE CIMConstMethod
 { {
 public: public:
  
     CIMConstMethod() : _rep(0)      /** Creates a new uninitialized CIMConstMethod object.
     {          The only thing that can be done with this object is to copy another
           object into it.  Other methods, such as getName, will fail with an
     }          UninitializedObjectException.  The object has an uninitialized state,
           which can be tested with the isUninitialized method.
     CIMConstMethod(const CIMConstMethod& x)          @see isUninitialized()
     {          @see UninitializedObjectException
         Inc(_rep = x._rep);      */
     }      CIMConstMethod();
   
     CIMConstMethod(const CIMMethod& x)      /** Creates a new CIMConstMethod object from another CIMConstMethod object.
     {          The new CIMConstMethod object references the same copy of data as the
         Inc(_rep = x._rep);          specified object; no copy is made.
     }          @param x CIMConstMethod object from which to create the new
           CIMConstMethod object.
     CIMConstMethod& operator=(const CIMConstMethod& x)          <p><b>Example:</b>
     {          <pre>
         if (x._rep != _rep)              CIMConstMethod cm1(CIMName ("getHostName"), CIMTYPE_STRING);
         {              CIMConstMethod cm2(m1);
             Dec(_rep);          </pre>
             Inc(_rep = x._rep);          {@link Shared Classes}
         }      */
         return *this;      CIMConstMethod(const CIMConstMethod& x);
     }  
       /** Creates a new CIMConstMethod object from a CIMMethod object.
     CIMConstMethod& operator=(const CIMMethod& x)          The new CIMConstMethod object references the same copy of data as the
     {          specified object; no copy is made.
         if (x._rep != _rep)          @param x CIMMethod object from which to create the new
         {          CIMConstMethod object.
             Dec(_rep);          <p><b>Example:</b>
             Inc(_rep = x._rep);          <pre>
         }              CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);
         return *this;              CIMConstMethod cm1(m1);
     }          </pre>
           {@link Shared Classes}
     // Throws IllegalName if name argument not legal CIM identifier.      */
       CIMConstMethod(const CIMMethod& x);
   
       /** Creates a CIMConstMethod object with the specified attributes.
           @param name CIMName defining the name for the method.
   
           @param type CIMType defining the method return type.
   
           @param classOrigin (optional) CIMName representing the class origin.
               Note that this should normally not be used.  If not provided set to
               CIMName() (Null name).
           @param propagated Optional flag indicating whether the definition of
               the CIM Method is local to the CIM Class (respectively, Instance)
               in which it appears, or was propagated without modification from
               a superclass. Default is false. Note that this attribute is
               normally not set by CIM Clients but is used internally within the
               CIM Server.
           <p><b>Example:</b>
           <pre>
               CIMConstMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);
           </pre>
       */
     CIMConstMethod(     CIMConstMethod(
         const String& name,          const CIMName& name,
         CIMType type,         CIMType type,
         const String& classOrigin = String(),          const CIMName& classOrigin = CIMName(),
         Boolean propagated = false)          Boolean propagated = false);
     {  
         _rep = new CIMMethodRep(name, type, classOrigin, propagated);  
     }  
   
     ~CIMConstMethod()  
     {  
         Dec(_rep);  
     }  
   
     const String& getName() const  
     {  
         _checkRep();  
         return _rep->getName();  
     }  
   
     CIMType getType() const  
     {  
         _checkRep();  
         return _rep->getType();  
     }  
   
     const String& getClassOrigin() const  
     {  
         _checkRep();  
         return _rep->getClassOrigin();  
     }  
   
     Boolean getPropagated() const  
     {  
         _checkRep();  
         return _rep->getPropagated();  
     }  
   
     Uint32 findQualifier(const String& name) const  
     {  
         _checkRep();  
         return _rep->findQualifier(name);  
     }  
   
     Uint32 getQualifier(Uint32 pos) const  
     {  
         _checkRep();  
         return _rep->getQualifier(pos);  
     }  
   
     Uint32 getQualifierCount() const  
     {  
         _checkRep();  
         return _rep->getQualifierCount();  
     }  
  
     Uint32 findParameter(const String& name) const      /** Destructor for the CIMConstMethod.  The shared data copy remains valid
     {          until all referring objects are destructed.
         _checkRep();          {@link Shared Classes}
         return _rep->findParameter(name);      */
     }      ~CIMConstMethod();
   
     CIMConstParameter getParameter(Uint32 pos) const      /** The assignment operator assigns one CIMConstMethod to another.
     {          After the assignment, both CIMConstMethod objects refer to the same
         _checkRep();          data copy; a distinct copy is not created.
         return _rep->getParameter(pos);          @param x CIMConstMethod object from which to assign this
     }          CIMConstMethod object.
   
     Uint32 getParameterCount() const          <p><b>Example:</b>
     {          <pre>
         _checkRep();              CIMConstMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);
         return _rep->getParameterCount();              CIMConstMethod m2;
     }              m2 = m1;
           </pre>
     operator int() const { return _rep != 0; }      */
       CIMConstMethod& operator=(const CIMConstMethod& x);
     void toXml(Array<Sint8>& out) const  
     {      /** The assignment operator assigns a CIMMethod object to a
         _checkRep();          CIMConstMethod.
         _rep->toXml(out);          After the assignment, both objects refer to the same
     }          data copy; a distinct copy is not created.
           @param x CIMConstMethod object from which to assign this
     void print(PEGASUS_STD(ostream) &o=PEGASUS_STD(cout)) const          CIMConstMethod object.
     {  
         _checkRep();          <p><b>Example:</b>
         _rep->print(o);          <pre>
     }              CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);
               CIMConstMethod m2;
     Boolean identical(const CIMConstMethod& x) const              m2 = m1;
     {          </pre>
         x._checkRep();      */
         _checkRep();      CIMConstMethod& operator=(const CIMMethod& x);
         return _rep->identical(x._rep);  
     }      /** Gets the name of the method.
           @return CIMName with the name of the method.
           <p><b>Example:</b>
           <pre>
               CIMConstMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);
               assert(m1.getName() == CIMName ("getHostName"));
           </pre>
       */
       const CIMName& getName() const;
   
       /** Gets the method return type.
           @return A CIMType containing the method return type.
           @exception UninitializedObjectException Thrown if the object is not
           initialized.
           <p><b>Example:</b>
           <pre>
               CIMConstMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);
               assert(m1.getType() == CIMTYPE_STRING);
           </pre>
       */
       CIMType getType() const;
   
       /** Gets the class in which this method was defined. This information
           is normally available with methods that are part of a schema
           returned from a CIM Server.
           @return CIMName containing the classOrigin attribute.
       */
       const CIMName& getClassOrigin() const;
   
       /** Tests the propagated attribute of the object.  The propagated
           attribute indicates whether this method was propagated from a
           higher-level class.  Normally this attribute is set as part of
           defining a method in the context of a schema.  It is set in
           methods retrieved from a CIM Server.
           @return True if method is propagated; otherwise, false.
       */
       Boolean getPropagated() const;
   
       /** Searches for a qualifier with the specified input name.
           @param name CIMName of the qualifier to be found.
           @return Zero origin index of the qualifier found or PEG_NOT_FOUND
           if not found.
           @exception UninitializedObjectException Thrown if the object is not
           initialized.
           <p><b>Example:</b>
           <pre>
               CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);
               m1.addQualifier(CIMQualifier(CIMName ("stuff"), true));
               CIMConstMethod m2(m1);
               assert(m2.findQualifier(CIMName ("stuff")) != PEG_NOT_FOUND);
           </pre>
       */
       Uint32 findQualifier(const CIMName& name) const;
   
       /** Gets the CIMQualifier defined by the input parameter.
           @param index Zero origin index of the qualifier requested.
           @return CIMQualifier object representing the qualifier found.
           @exception IndexOutOfBoundsException Thrown if the index is
           outside the range of parameters available from the CIMMethod.
           <p><b>Example:</b>
           <pre>
               CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);
               m1.addQualifier(CIMQualifier(CIMName ("stuff"), true));
               CIMConstMethod m2(m1);
               Uint32 posQualifier = m2.findQualifier(CIMName ("stuff"));
               if (posQualifier != PEG_NOT_FOUND)
               {
                   CIMQualifier q = m2.getQualifier(posQualifier);
               }
           </pre>
       */
       CIMConstQualifier getQualifier(Uint32 index) const;
   
       /** Returns the number of Qualifiers attached to this CIMConstMethod
           object.
           @return The number of qualifiers attached to the CIM method.
           <p><b>Example:</b>
           <pre>
               CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);
               m1.addQualifier(CIMQualifier(CIMName ("stuff"), true));
               m1.addQualifier(CIMQualifier(CIMName ("stuff2"), true));
               CIMConstMethod m2(m1);
               assert(m2.getQualifierCount() == 2);
           </pre>
       */
       Uint32 getQualifierCount() const;
   
       /** Finds the parameter with the specified name.
           @param name CIMName of parameter to be found.
           @return Index of the parameter object found or PEG_NOT_FOUND
           if the property is not found.
           <p><b>Example:</b>
           <pre>
               Uint32 posParameter;
               posParameter = m1.findParameter(CIMName ("ipaddress"));
               if (posParameter != PEG_NOT_FOUND)
                   ...
           </pre>
       */
       Uint32 findParameter(const CIMName& name) const;
   
       /** Gets the parameter defined by the specified index.
           @param index Index for the parameter to be returned.
           @return CIMConstParameter object requested.
           @exception IndexOutOfBoundsException Thrown if the index is outside
               the range of available parameters.
           <p><b>Example:</b>
           <pre>
               CIMConstParameter cp;
               Uint32 parameterIndex = m1.findParameter(CIMName ("ipaddress"));
               if (parameterIndex != PEG_NOT_FOUND)
               {
                   cp = m1.getParameter(parameterIndex);
               }
           </pre>
       */
       CIMConstParameter getParameter(Uint32 index) const;
   
       /** Gets the count of Parameters defined in the CIMMethod.
           @return Count of the number of parameters attached to the CIMMethod.
       */
       Uint32 getParameterCount() const;
   
       /** Determines if the object has not been initialized.
           @return True if the object has not been initialized;
                   otherwise, false.
           <p><b>Example:</b>
           <pre>
               CIMConstMethod m1;
               assert(m1.isUninitialized());
           </pre>
        */
       Boolean isUninitialized() const;
   
       /** Compares with a CIMConstMethod.
           @param x CIMConstMethod object for the method to be compared.
           @return True if this method is identical to the one specified;
                   otherwise, false.
           <p><b>Example:</b>
           <pre>
               CIMConstMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);
               CIMConstMethod m2(CIMName ("test"), CIMTYPE_STRING);
               assert(!m1.identical(m2));
           </pre>
       */
       Boolean identical(const CIMConstMethod& x) const;
  
     CIMMethod clone() const      /** Makes a clone (deep copy) of this CIMConstMethod. This creates
     {          a new copy of all of the components of the method including
         return CIMMethod(_rep->clone());          parameters and qualifiers.
     }          @return Independent copy of the CIMConstMethod object.  Note that
           the copy is a non-constant CIMMethod.
       */
       CIMMethod clone() const;
  
 private: private:
  
     void _checkRep() const      void _checkRep() const;
     {  
         if (!_rep)  
             ThrowUnitializedHandle();  
     }  
  
     CIMMethodRep* _rep;     CIMMethodRep* _rep;
  
     friend class CIMMethod;     friend class CIMMethod;
     friend class CIMMethodRep;     friend class CIMMethodRep;
       friend class XmlWriter;
       friend class MofWriter;
 }; };
  
 #define PEGASUS_ARRAY_T CIMMethod #define PEGASUS_ARRAY_T CIMMethod
 # include "ArrayInter.h"  # include <Pegasus/Common/ArrayInter.h>
 #undef PEGASUS_ARRAY_T #undef PEGASUS_ARRAY_T
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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