(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.17 and 1.65

version 1.17, 2001/05/24 00:48:34 version 1.65, 2004/06/30 21:07:54
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) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By:  // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
   //              Carol Ann Krug Graves, Hewlett-Packard Company
   //                  (carolann_graves@hp.com)
   //              Adriann Schuur (schuur@de.ibm.com) PEP 164
   //              Karl Schopmeyer k.schopmeyer@opengroup.org (PEP 157)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 29 
Line 37 
 #define Pegasus_CIMClass_h #define Pegasus_CIMClass_h
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <Pegasus/Common/CIMClassRep.h>  #include <Pegasus/Common/Linkage.h>
   #include <Pegasus/Common/CIMName.h>
   #include <Pegasus/Common/CIMObject.h>
   #include <Pegasus/Common/CIMMethod.h>
   #include <Pegasus/common/CIMInstance.h>
   #include <Pegasus/Common/CIMPropertyList.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 class CIMConstClass; class CIMConstClass;
   class CIMClassRep;
   class Resolver;
  
 /** The CIMClass class is used to represent CIM classes in Pegasus.  In CIM,  
     a class object may be a class or an associator.  A CIM class must contain a  
     name and may contain methods, properties, and qualifiers.  It is a template  
     for creating a CIM instance.  A CIM class represents a collection of CIM  
     instances, all of which support a common type (for example, a set of  
     properties, methods, and associations).  
 */  
  
   /** The CIMClass class is used to represent CIM classes in Pegasus.
   */
 class PEGASUS_COMMON_LINKAGE CIMClass class PEGASUS_COMMON_LINKAGE CIMClass
 { {
 public: public:
  
     /** Constructor - Creates an uninitiated a new CIM object      /** Creates an uninitialized new CIM object representing a CIM class.
         reprenting a CIM class. The class object created by this          The class object created by this constructor can only be used
         constructor can only be used in an operation such as the          in an operation such as the copy constructor. It cannot be used
         copy constructor.  It cannot be used to create a class by          to create a class by appending names, properties, etc. since it
         appending names, properties, etc. since it is unitiated.          is uninitialized.
   
         Use one of the other constructors to create an initiated new CIM class          Use one of the other constructors to create an initialized new
         object.          CIM class object.
         @exception Throws an exception "unitialized handle" if this          @exception UninitializedObjectException if an attempt is made to
         unitialized handle is used          use the unitialized object.
         /REF(HPEGASUS_HANDLES)      */
     */      CIMClass();
     CIMClass() : _rep(0)  
     {      /** Creates a new CIM object representing a CIMClass from the given
           CIMClass object.
     }          @param x  CIMClass Object from which to create the CIMClass
       */
     /** Constructor - Creates a class from a previous class      CIMClass(const CIMClass& x);
     */  
     CIMClass(const CIMClass& x)      /** Creates a new CIMClass object representing a CIMClass from the given
     {          CIMObject Object.
         Inc(_rep = x._rep);          @param x  CIMObject object from which to create the CIMClass object.
     }          @exception DynamicCastFailedException If a CIMClass can not be
           created from the given CIMObject.
     /// Operator = Assigns the CIM Class constructor.      */
     CIMClass& operator=(const CIMClass& x)      PEGASUS_EXPLICIT CIMClass(const CIMObject& x);
     {  
         if (x._rep != _rep)      /** Creates a new CIM object representing a CIMClass from inputs
         {          of a classname and SuperClassName.
             Dec(_rep);          @param className  CIMName representing name of the class being created.
             Inc(_rep = x._rep);          @param superClassName CIMName representing name of the SuperClass.
         }  
         return *this;  
     }  
   
     /**  Constructor - Creates a Class from inputs of a classname and  
         SuperClassName  
         @param className String representing name of the class being created  
         @param superClassName String representing name of the SuperClass  
         ATTN: Define what makes up legal name.  
         @return Throws IllegalName if className argument illegal CIM identifier.  
         <pre>         <pre>
             CIMClass NewCass("MyClass", "YourClass");              CIMClass NewClass("MyClass", "YourClass");
         </pre>         </pre>
   
     */     */
     CIMClass(     CIMClass(
         const String& className,          const CIMName& className,
         const String& superClassName = String())          const CIMName& superClassName = CIMName());
     {  
         _rep = new CIMClassRep(className, superClassName);      ///
     }      CIMClass& operator=(const CIMClass& x);
  
     /// Destructor     /// Destructor
     ~CIMClass()      ~CIMClass();
     {  
         Dec(_rep);  
     }  
  
     /** isAssociation - Identifies whether or not this CIM class      /** Identifies whether or not this CIM class is an association. An
         is an association. An association is a relationship between two          association is a relationship between two (or more) classes or
         (or more) classes or instances of two classes.  The properties of an          instances of two classes. The properties of an association class
         association class include pointers, or references, to the two (or          include pointers, or references, to the two (or more) instances.
         more) instances. All CIM classes can be included in one or more          All CIM classes can be included in one or more associations.
         associations.          @return  true if this CIM class is an association, false
         ATTN: Move the association definition elsewhere          otherwise.
         @return  Boolean True if this CIM class belongs to an association;  
         otherwise, false.  
     */     */
     Boolean isAssociation() const      Boolean isAssociation() const;
     {  
         _checkRep();  
         return _rep->isAssociation();  
     }  
  
     ///  CIMMethod isAbstract      /** Tests if the CIMClass is abstract.
     Boolean isAbstract() const          @return true if the CIMClass Object is abstract, false otherwise.
     {  
         _checkRep();  
         return _rep->isAbstract();  
     }  
   
     /** getClassName Gets the name of the class  
         ATTN: COMMENT. Why not just get name so we have common method for all.  
         @return Returns string with the class name.  
     */     */
     const String& getClassName() const      Boolean isAbstract() const;
     {  
         _checkRep();  
         return _rep->getClassName();  
     }  
  
     /** CIMMethod getSuperClassName - Gets the name of the Parent  
         @return String with parent class name.      /** Gets the name of the class represented by this CIM object.
     */          @return CIMName with the class name.
     const String& getSuperClassName() const  
     {  
         _checkRep();  
         return _rep->getSuperClassName();  
     }  
   
     /** CIMMethod setSuperClassName - Sets the name of the parent class from  
         the input parameter. \REF{CLASSNAME}. ATTN: Define legal classnames  
         @param String defining parent name.  
         @return Throws IllegalName if superClassName argument not legal CIM  
         identifier  
         @exception throws IllegalName if the name is not correct. See  
         \URL[ClassNames]{DefinitionofTerms.html#CLASSNAME}  
     */  
     void setSuperClassName(const String& superClassName)  
     {  
         _checkRep();  
         _rep->setSuperClassName(superClassName);  
     }  
   
     /** addQualifier - Adds the specified qualifier to the class  
         and increments the qualifier count. It is illegal to add the same  
         qualifier more than one time.  
         @param qualifier CIMQualifier object representing the qualifier to be  
         added  
         @return Returns handle of the class object  
         @exception Throws AlreadyExists.  
     */  
     CIMClass& addQualifier(const CIMQualifier& qualifier)  
     {  
         _checkRep();  
         _rep->addQualifier(qualifier);  
         return *this;  
     }  
   
     /** findQualifier - Searches for a qualifier with the specified `  
         input name if it exists in the class  
         @param name CIMName of the qualifier  
         to be found @return Position of the qualifier in the Class.  
         @return Returns index of the qualifier found or PEG_NOT_FOUND  
         if 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 true if the qualifier with the  
     specified name exists in the class  
     @param name String name of the qualifier object being tested.  
     @return True if the qualifier exits.  Otherwise false is returned.  
     */     */
     Boolean existsQualifier(const String& name)      const CIMName& getClassName() const;
     {  
         _checkRep();  
         return _rep->existsQualifier(name);  
     }  
     ///     ///
     Boolean existsQualifier(const String& name) const      const CIMObjectPath& getPath() const;
     {  
         _checkRep();  
         return _rep->existsQualifier(name);  
     }  
   
     /** getQualifier - Gets the CIMQualifier object defined  
         by the input parameter  
         @param pos defines the position of the qualifier in the class from the  
         findQualifier method  
         @return CIMQualifier object representing the qualifier found.  
         ATTN: what is error return here?  
     */  
     CIMQualifier getQualifier(Uint32 pos)  
     {  
         _checkRep();  
         return _rep->getQualifier(pos);  
     }  
  
     /// getQualifier - ATTN:      /** Sets the object path for the class.
     CIMConstQualifier getQualifier(Uint32 pos) const          @param  path  CIMObjectPath containing the object path.
     {  
         _checkRep();  
         return _rep->getQualifier(pos);  
     }  
   
     /** removeQualifier - Removes the qualifier defined by the  
     index parameter.  
     @param Defines the index of the qualifier to be removed.  
     @return There is no return.  
     @exception Throw OutOfBound exception if the index is outside  
     the range of existing qualifier objects for this class  
     */     */
     void removeQualifier(Uint32 pos) const      void setPath (const CIMObjectPath & path);
     {  
         _checkRep();      /** Gets the name of the Parent class of this CIM Object.
         _rep->removeQualifier(pos);          @return CIMName with parent class name.
     }  
   
     /** getQualifierCount - Returns the number of qualifiers  
         in the class.  
         @return ATTN:  
     */     */
     Uint32 getQualifierCount() const      const CIMName& getSuperClassName() const;
     {  
         _checkRep();  
         return _rep->getQualifierCount();  
     }  
  
     /** addProperty - Adds the specified property object to the      /** Sets the name of the parent class from the input
         properties in the CIM class          parameter.
           @param superClassName - CIMName defining parent class name.
     */     */
     CIMClass& addProperty(const CIMProperty& x)      void setSuperClassName(const CIMName& superClassName);
     {  
         _checkRep();  
         _rep->addProperty(x);  
         return *this;  
     }  
  
       /** Adds the specified qualifier to the class and increments the
           qualifier count. It is illegal to add the same qualifier more
           than one time.
           @param qualifier  CIMQualifier object representing the qualifier
           to be added.
           @return the CIMClass object.
           @exception AlreadyExistsException if the qualifier already exists.
       */
       CIMClass& addQualifier(const CIMQualifier& qualifier);
  
       /** Searches for a qualifier with the specified input name if it
           exists in the class.
           @param name  CIMName of the qualifier to be found
           @return Index of the qualifier found or PEG_NOT_FOUND
           if not found.
       */
       Uint32 findQualifier(const CIMName& name) const;
  
     /** CIMMethod findProperty - Finds the property object with the      /** Gets the CIMQualifier object defined by the input parameter.
         name defined by the input parameter in the class.          @param index  Index of the qualifier in the class from the
         @param String parameter with the property name.          findQualifier method.
         @return position representing the property object found or          @return CIMQualifier object representing the qualifier found.
           On error, CIMQualifier object will be null.
           @exception IndexOutOfBoundsException exception if the index is
           outside the range of parameters available from the CIMClass.
       */
       CIMQualifier getQualifier(Uint32 index);
   
       /** Gets the qualifier defined by the input parameter from the
           qualifier list for this CIMClass.
           @param index  Index of the qualifier in the CIM class.
           @return CIMConstQualifier object representing the qualifier
           found. On error, CIMConstQualifier object will be null.
           @exception IndexOutOfBoundsException exception if the index is
           outside the range of parameters available from the CIMClass.
       */
       CIMConstQualifier getQualifier(Uint32 index) const;
   
       /** Removes the qualifier defined by the index parameter.
           @param index  Defines the index of the qualifier to be removed.
           @exception IndexOutOfBoundsException if the index is outside
           the range of existing qualifier objects for this class.
       */
       void removeQualifier(Uint32 index);
   
       /** Gets the count of the number of qualifiers defined in the class.
           @return the number of qualifiers in the class definition (not
           those on properties or methods)
       */
       Uint32 getQualifierCount() const;
   
       /** Adds the specified property object to the properties in
           the CIM class
           @param x  CIMProperty to be added to the CIM Class.
           @return CIMClass object after the specified property is added.
       */
       CIMClass& addProperty(const CIMProperty& x);
   
       /** Finds the property object with the name defined by the
           input parameter in the class.
           @param name  CIMName with the property name to be found.
           @return Index of the property object found or
         PEG_NOT_FOUND if the property is not found.         PEG_NOT_FOUND if the property is not found.
     */     */
     Uint32 findProperty(const String& name)      Uint32 findProperty(const CIMName& name) const;
     {  
         _checkRep();  
         return _rep->findProperty(name);  
     }  
  
     Uint32 findProperty(const String& name) const      /** Gets a property object from the CIMClass.
     {          @param index  Index for the property object to get.
         _checkRep();          @return CIMProperty object requested.
         return _rep->findProperty(name);          @exception IndexOutOfBoundsException if the index is outside
     }          the range of properties in this class.
   
     /** existsPropery - Determines if a property object with the  
         name defined by the input parameter exists in the class.  
         @parm String parameter with the property name.  
         @return True if the property object exists.  
     */     */
     Boolean existsProperty(const String& name)      CIMProperty getProperty(Uint32 index);
     {  
         _checkRep();      /** Gets a property object from the CIMClass.
         return _rep->existsProperty(name);          @param index  Index for the property object to get.
     }          @return CIMProperty object requested.
     Boolean existsProperty(const String& name) const          @exception IndexOutOfBoundsException if the index is outside
     {          the range of properties in this class.
        _checkRep();  
        return _rep->existsProperty(name);  
     }  
   
     /** getProperty - Returns a property representing the property  
         defined by the input parameter  
         @param position for this property  
         ATTN: Should we not use something like handle for position???  
         @return CIMProperty object  
         ATTN: what is error return?  
     */  
     CIMProperty getProperty(Uint32 pos)  
     {  
         _checkRep();  
         return _rep->getProperty(pos);  
     }  
   
     /**getProperty Gets a property object from the CIMClass  
         @param pos The index of the property object to get.  
         @return Returns handle of the property object requested  
         @exception Throws OutofBounds if the size field is greather than the  
         bunber of properties in the class.  
     */  
     CIMConstProperty getProperty(Uint32 pos) const  
     {  
         _checkRep();  
         return _rep->getProperty(pos);  
     }  
   
     /** removeProperty - Removes the property represented  
         by the position input parameter from the class  
         @param pos Index to the property to be removed from the  
         findPropety method  
         @exception Throws OutofBounds if index is not a property object  
     */  
     void removeProperty(Uint32 pos)  
     {  
         _checkRep();  
         _rep->removeProperty(pos);  
     }  
   
     /** getPropertyCount -   Gets the count of the number of properties  
         defined in the class.  
         @return count of number of proerties in the class  
     */  
     Uint32 getPropertyCount() const  
     {  
         _checkRep();  
         return _rep->getPropertyCount();  
     }  
   
     /** addMethod - Adds the method object defined by the input  
         parameter to the class and increments the count of the number of  
         methods in the class  
         @param method object representing the method to be added  
         @return Returns the CIMClass object to which the method was added.  
         @exception Throws AlreadyExists if the method already exists and throws  
         UnitializedHandle if the handle is not initialized  
     */     */
     CIMClass& addMethod(const CIMMethod& x)      CIMConstProperty getProperty(Uint32 index) const;
     {  
         _checkRep();      /** Removes the specified property from the class.
         _rep->addMethod(x);          @param index  Index of the property to be removed.
         return *this;          @exception IndexOutOfBoundsException if the index is outside
     }          the range of properties in this class.
   
     /** findMethod - Locate the method object defined by the  
         name input  
         @param String representing the name of the method to be found  
         @return Position of the method object in the class to be used in  
         subsequent getmethod, etc. operations  
     */     */
     Uint32 findMethod(const String& name)      void removeProperty(Uint32 index);
     {  
         _checkRep();  
         return _rep->findMethod(name);  
     }  
  
     Uint32 findMethod(const String& name) const      /** Gets the count of the number of properties defined in the class.
     {          @return count of number of properties in the class.
         _checkRep();  
         return _rep->findMethod(name);  
     }  
   
      /** existsMethod - Determine if the method object defined by the  
         name input exists  
         @param String representing the name of the method to be found  
         @return True if the method exists  
     */     */
     Boolean existsMethod(const String& name)      Uint32 getPropertyCount() const;
     {  
         _checkRep();  
         return _rep->existsMethod(name);  
     }  
  
     Boolean existsMethod(const String& name) const      /** Adds the method object defined by the input parameter to the
     {          class and increments the count of the number of methods in the class.
         _checkRep();          @param name  CIMMethod object representing the method to be added.
         return _rep->existsMethod(name);          @return the CIMClass object to which the method was added.
     }          @exception AlreadyExistsException if the method already exists.
           @exception UninitializedObjectException if the object is not initialized.
       */
       CIMClass& addMethod(const CIMMethod& x);
  
       /** Locate the method object defined by the input parameter.
           @param name  CIMName representing the name of the method to be found.
           @return Position of the method object in the class.
       */
       Uint32 findMethod(const CIMName& name) const;
  
     /** getMethod - Gets the method object defined by the      /** Gets the method object defined by the input parameter.
         input parameter.          @param index  Index to the method object to get.
         @param pos Index to the CIMMethod object to get          @return CIMMethod object of the method requested.
         @return Returns handle of the CIMMethod requested          @exception IndexOutOfBoundsException if the index is outside
         @exception Throws OutofBounds if the index represented by pos is greater          the range of methods in this class.
         than the number of methods defined in the class object  
     */     */
     CIMMethod getMethod(Uint32 pos)      CIMMethod getMethod(Uint32 index);
     {  
         _checkRep();  
         return _rep->getMethod(pos);  
     }  
  
     /** getMethod Gets the method object defined by the input      /** Gets the method object defined by the input parameter.
     parameter. This is the const version.          @param index  Index to the method object to get.
           @return CIMConstMethod object of the method requested.
           @exception IndexOutOfBoundsException if the index is outside
           the range of methods in this class.
     */     */
       CIMConstMethod getMethod(Uint32 index) const;
  
     CIMConstMethod getMethod(Uint32 pos) const      /** Removes the method defined by the index parameter.
     {          @param index  Defines the index of the method to be removed.
         _checkRep();          @exception IndexOutOfBoundsException if the index is outside
         return _rep->getMethod(pos);          the range of methods in this class.
     }  
   
     /** removeMethod - Removes the method defined by the  
     index parameter.  
     @param Defines the index of the method to be removed.  
     @return There is no return.  
     @exception Throw OutOfBound exception if the index is outside  
     the range of existing method objects for this class  
     */     */
     void removeMethod(Uint32 pos) const      void removeMethod(Uint32 index);
     {  
         _checkRep();  
         _rep->removeMethod(pos);  
     }  
  
     /** CIMMethod getMethodCount - Count of the number of methods in the class      /** Gets the count of the number of methods in the class.
         @return integer representing the number of methods in the class object.          @return the count of the number of methods in the class object.
     */     */
     Uint32 getMethodCount() const      Uint32 getMethodCount() const;
     {  
         _checkRep();  
         return _rep->getMethodCount();  
     }  
   
     /** Resolve -  Resolve the class: inherit any properties and  
         qualifiers. Make sure the superClass really exists and is consistent  
         with this class. Also set the propagated flag class-origin for each  
         class feature.  
         ATTN: explain why this here  
     */  
     void resolve(  
         DeclContext* declContext,  
         const String& nameSpace)  
     {  
         _checkRep();  
         _rep->resolve(declContext, nameSpace);  
     }  
  
     /// operator - ATTN:      /// Get names of all keys of this class.
     operator int() const { return _rep != 0; }      void getKeyNames(Array<CIMName>& keyNames) const;
  
     /// CIMMethod toXML      /** Determines if the object has keys.
     void toXml(Array<Sint8>& out) const          @return  true if the object has keys, false otherwise.
     {      */
         _checkRep();      Boolean hasKeys() const;
         _rep->toXml(out);  
     }  
  
     /// CIMMethod print      /** Makes a deep copy (clone) of the given object.
     void print(PEGASUS_STD(ostream) &o=PEGASUS_STD(cout)) const          @return copy of the CIMClass object.
     {  
         _checkRep();  
         _rep->print(o);  
     }  
   
     /** CIMMethod 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;      CIMClass clone() const;
  
     /// CIMMethod clone - ATTN:      /** Compares with another CIM class.
     CIMClass clone() const          @param x  Class object for the class to be compared.
     {          @return true if the classes are identical, false otherwise.
         return CIMClass(_rep->clone());      */
     }      Boolean identical(const CIMConstClass& x) const;
  
     void getKeyNames(Array<String>& keyNames) const      /** Determines if the object has not been initialized.
     {          @return  true if the object has not been initialized,
         _checkRep();          false otherwise.
         _rep->getKeyNames(keyNames);      */
     }      Boolean isUninitialized() const;
   
       /**
       Build a CIMInstance based on this CIM Class.  Properties in the instance
       are initialized to the default values (if any) specified in the class
       definition.  The parameters of the call determine whether qualifiers are
       included, the class origin attributes are included and which properties
       are included in the new instance.  This method is designed specifically
       for providers to allow them to easily build instance objects using the
       parameters provided with the CIM instance operations such as getInstance,
       enumerateInstances.
   
       @param includeQualifiers If true attaches the class level qualifiers from
       this class to the instance and all properties inserted in the instance.
       If false, no qualifiers are attached to the instance or to any properties
       included in the instance.  The TOINSTANCE flavor is ignored.  Because
       there is still confusion over the exact operation of this parameter in the
       CIM specifications and the concept of instance level qualifiers, the
       behavior of this function when the parameter is true MAY change in the
       future to match any future clarifications of interoperable behavior in the
       CIM specifications.
   
       @param includeClassOrigin If true ClassOrigin attributes attached to
       properties inthe class object are transferred to the properties attached
       to the instance object.  If false, any ClassOrigin attributes are ignored.
   
       @param propertyList A CIMPropertyList defining the properties that are to
       be added to the created instance.  If propertyList is not NULL properties
       defined in the class and in this propertyList are added to the new
       instance.  If the propertyLlist is NULL, all properties are added to the
       instance.  If the propertyList exists but is empty, not properties are
       added.  Note that this function does NOT generate an error if a property
       name is supplied that is NOT in the class; it simply does not add that
       property to the instance.
   
       @return CIMInstance of this class appropriately initialized.
   
       EXAMPLE:
   
       <Will be provided with the code>
       */
       CIMInstance createInstance(Boolean includeQualifiers,
           Boolean includeClassOrigin,
           const CIMPropertyList & propertyList) const;
  
 private: private:
  
     CIMClass(CIMClassRep* rep) : _rep(rep)      CIMClassRep* _rep;
     {  
     }  
  
     void _checkRep() const      CIMClass(CIMClassRep* rep);
     {  
         if (!_rep)      void _checkRep() const;
             ThrowUnitializedHandle();  
     }  
  
     CIMClassRep* _rep;  
     friend class CIMConstClass;     friend class CIMConstClass;
       friend class CIMObject;
       friend class CIMConstObject;
       friend class Resolver;
       friend class XmlWriter;
       friend class MofWriter;
       friend class BinaryStreamer;
 }; };
  
 #define PEGASUS_ARRAY_T CIMClass #define PEGASUS_ARRAY_T CIMClass
 # include "ArrayInter.h"  #include <Pegasus/Common/ArrayInter.h>
 #undef PEGASUS_ARRAY_T #undef PEGASUS_ARRAY_T
  
 /** CIMConstClass - ATTN: define this.  /// CIMConstClass
   
 */  
 class PEGASUS_COMMON_LINKAGE CIMConstClass class PEGASUS_COMMON_LINKAGE CIMConstClass
 { {
 public: public:
  
     CIMConstClass() : _rep(0)      ///
     {      CIMConstClass();
  
     }      ///
       CIMConstClass(const CIMConstClass& x);
  
     CIMConstClass(const CIMConstClass& x)      ///
     {      CIMConstClass(const CIMClass& x);
         Inc(_rep = x._rep);  
     }  
  
     CIMConstClass(const CIMClass& x)      ///
     {      PEGASUS_EXPLICIT CIMConstClass(const CIMObject& x);
         Inc(_rep = x._rep);  
     }  
  
     CIMConstClass& operator=(const CIMConstClass& x)      ///
     {      PEGASUS_EXPLICIT CIMConstClass(const CIMConstObject& x);
         if (x._rep != _rep)  
         {  
             Dec(_rep);  
             Inc(_rep = x._rep);  
         }  
         return *this;  
     }  
  
     CIMConstClass& operator=(const CIMClass& x)      ///
     {      CIMConstClass(
         if (x._rep != _rep)          const CIMName& className,
         {          const CIMName& superClassName = CIMName());
             Dec(_rep);  
             Inc(_rep = x._rep);  
         }  
         return *this;  
     }  
  
     // Throws IllegalName if className argument not legal CIM identifier.      ///
       CIMConstClass& operator=(const CIMConstClass& x);
  
     CIMConstClass(      ///
         const String& className,      CIMConstClass& operator=(const CIMClass& x);
         const String& superClassName = String())  
     {  
         _rep = new CIMClassRep(className, superClassName);  
     }  
  
     ~CIMConstClass()      ///
     {      ~CIMConstClass();
         Dec(_rep);  
     }  
  
     Boolean isAssociation() const      ///
     {      Boolean isAssociation() const;
         _checkRep();  
         return _rep->isAssociation();  
     }  
  
     Boolean isAbstract() const      ///
     {      Boolean isAbstract() const;
         _checkRep();  
         return _rep->isAbstract();  
     }  
  
     const String& getClassName() const      ///
     {      const CIMName& getClassName() const;
         _checkRep();  
         return _rep->getClassName();  
     }  
  
     const String& getSuperClassName() const      ///
     {      const CIMObjectPath& getPath() const;
         _checkRep();  
         return _rep->getSuperClassName();  
     }  
  
     Uint32 findQualifier(const String& name) const      ///
     {      const CIMName& getSuperClassName() const;
         _checkRep();  
         return _rep->findQualifier(name);  
     }  
  
     CIMConstQualifier getQualifier(Uint32 pos) const      ///
     {      Uint32 findQualifier(const CIMName& name) const;
         _checkRep();  
         return _rep->getQualifier(pos);  
     }  
  
     Uint32 getQualifierCount() const      ///
     {      CIMConstQualifier getQualifier(Uint32 index) 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 CIMName& name) const;
         _checkRep();  
         return _rep->getProperty(pos);  
     }  
  
     Uint32 getPropertyCount() const      ///
     {      CIMConstProperty getProperty(Uint32 index) 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 CIMName& name) const;
         _checkRep();  
         return _rep->getMethod(pos);  
     }  
  
     Uint32 getMethodCount() const      ///
     {      CIMConstMethod getMethod(Uint32 index) const;
         _checkRep();  
         return _rep->getMethodCount();  
     }  
  
     operator int() const { return _rep != 0; }      ///
       Uint32 getMethodCount() const;
  
     void toXml(Array<Sint8>& out) const      ///
     {      void getKeyNames(Array<CIMName>& 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(_rep->clone());  
     }  
  
     void getKeyNames(Array<String>& keyNames) const      ///
     {      Boolean isUninitialized() const;
         _checkRep();  
         _rep->getKeyNames(keyNames);  
     }  
  
 private: private:
  
     void _checkRep() const  
     {  
         if (!_rep)  
             ThrowUnitializedHandle();  
     }  
   
     CIMClassRep* _rep;     CIMClassRep* _rep;
  
       void _checkRep() const;
   
     friend class CIMClassRep;     friend class CIMClassRep;
     friend class CIMClass;     friend class CIMClass;
     friend class CIMInstanceRep;     friend class CIMInstanceRep;
       friend class CIMObject;
       friend class CIMConstObject;
       friend class XmlWriter;
       friend class MofWriter;
       friend class BinaryStreamer;
 }; };
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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