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

Diff for /pegasus/src/Pegasus/Common/CIMObject.h between version 1.13 and 1.26

version 1.13, 2002/04/29 15:11:42 version 1.26, 2002/05/24 19:20:33
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)
   //              Carol Ann Krug Graves, Hewlett-Packard Company
   //                  (carolann_graves@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 30 
Line 32 
 #define Pegasus_Object_h #define Pegasus_Object_h
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <Pegasus/Common/CIMObjectRep.h>  #include <Pegasus/Common/String.h>
   #include <Pegasus/Common/Array.h>
   #include <Pegasus/Common/CIMProperty.h>
   #include <Pegasus/Common/CIMQualifier.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   class CIMConstObject;
   class CIMObjectRep;
 class CIMClass; class CIMClass;
 class CIMConstClass; class CIMConstClass;
 class CIMInstance; class CIMInstance;
Line 45 
Line 52 
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
 class CIMConstObject;  
 class CIMObject;  
   
 /** This class either refers to a CIMInstance or a CIMClass. /** This class either refers to a CIMInstance or a CIMClass.
  
     The CIMObjectRep data member points to either a CIMInstanceRep or     The CIMObjectRep data member points to either a CIMInstanceRep or
Line 59 
Line 63 
  
     /** Constructor.     /** Constructor.
     */     */
     CIMObject() : _rep(0)      CIMObject();
     {  
   
     }  
  
     /** Copy constructor.     /** Copy constructor.
     */     */
     CIMObject(const CIMObject& x)      CIMObject(const CIMObject& x);
     {  
         Inc(_rep = x._rep);  
     }  
  
     /** Construction from CIMClass.     /** Construction from CIMClass.
     */     */
Line 81 
Line 79 
  
     /** Assignment operator.     /** Assignment operator.
     */     */
     CIMObject& operator=(const CIMObject& x)      CIMObject& operator=(const CIMObject& x);
     {  
         if (x._rep != _rep)  
         {  
             Dec(_rep);  
             Inc(_rep = x._rep);  
         }  
         return *this;  
     }  
  
     /** Assignment operator.     /** Assignment operator.
     */     */
Line 101 
Line 91 
  
     /** Destructor.     /** Destructor.
     */     */
     ~CIMObject()      ~CIMObject();
     {  
         Dec(_rep);  
     }  
  
     /** Accessor for ClassName component of the object.     /** Accessor for ClassName component of the object.
         @return - Returns the ClassName of the object in         @return - Returns the ClassName of the object in
Line 115 
Line 102 
             className = myclass.getClassName;             className = myclass.getClassName;
         </pre>         </pre>
     */     */
     const String& getClassName() const      const String& getClassName() const;
     {  
         _checkRep();  
         return _rep->getClassName();  
     }  
   
     /** isClassName Compares ClassName with a String. This test performs  
         a comparison of the classname component of the object  
         with a String.  Note that this function was included specifically  
         because the equality compare is not just a straight comparison  
         because classnames are case independent.  
         @param classname String containing the name for comparison  
         @return True if it is the same class name (equalNoCase compare passes)  
         or false if not.  
     */  
     const Boolean isClassName(const String& classname) const  
     {  
         _checkRep();  
         return _rep->isClassName(classname);  
  
     }      const CIMObjectPath& getPath() const;
     const CIMReference& getPath() const  
     {      /**
         _checkRep();        Sets the object path for the object
         return _rep->getPath();        @param  path  CIMObjectPath containing the object path
     }       */
       void setPath (const CIMObjectPath & path);
  
     /** addQualifier - Adds the CIMQualifier object to the instance.     /** addQualifier - Adds the CIMQualifier object to the instance.
         Thows an exception of the CIMQualifier already exists in the instance         Thows an exception of the CIMQualifier already exists in the instance
Line 148 
Line 118 
         @return ATTN:         @return ATTN:
         @exception Throws AlreadyExists.         @exception Throws AlreadyExists.
     */     */
     CIMObject& addQualifier(const CIMQualifier& qualifier)      CIMObject& addQualifier(const CIMQualifier& qualifier);
     {  
         _checkRep();  
         _rep->addQualifier(qualifier);  
         return *this;  
     }  
  
     /** findQualifier - Searches the instance for the qualifier object     /** findQualifier - Searches the instance for the qualifier object
         defined by the input parameter.         defined by the input parameter.
Line 161 
Line 126 
         @return - Position of the qualifier to be used in subsequent         @return - Position of the qualifier to be used in subsequent
         operations or PEG_NOT_FOUND if the qualifier is not found.         operations or PEG_NOT_FOUND if the qualifier is 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 - Searches the instance for the qualifier object     /** existsQualifier - Searches the instance for the qualifier object
         defined by the input parameter.         defined by the input parameter.
Line 179 
Line 134 
         @return - Returns True if  the qualifier object exists or false         @return - Returns True if  the qualifier object exists or false
         if the qualifier is not found.         if the qualifier is 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 - Retrieves the qualifier object defined by the     /** getQualifier - Retrieves the qualifier object defined by the
         index input parameter.  @ index for the qualifier object.         index input parameter.  @ index for the qualifier object.
Line 200 
Line 145 
         @exception Throws the OutOfBounds exception if the index         @exception Throws the OutOfBounds exception if the index
         is out of bounds         is out of bounds
     */     */
     CIMQualifier getQualifier(Uint32 pos)      CIMQualifier getQualifier(Uint32 pos);
     {  
         _checkRep();  
         return _rep->getQualifier(pos);  
     }  
  
     /** getQualifier - Retrieves the qualifier object defined by the     /** getQualifier - Retrieves the qualifier object defined by the
         index input parameter.  @ index for the qualifier object.         index input parameter.  @ index for the qualifier object.
Line 217 
Line 158 
         ATTN: What is effect of out of range index???         ATTN: What is effect of out of range index???
         ATTN: Is the above statement correct???         ATTN: Is the above statement correct???
     */     */
     CIMConstQualifier getQualifier(Uint32 pos) const      CIMConstQualifier getQualifier(Uint32 pos) const;
     {  
         _checkRep();  
         return _rep->getQualifier(pos);  
     }  
  
     void removeQualifier(Uint32 pos)      void removeQualifier(Uint32 pos);
         {  
         _checkRep();  
         _rep->removeQualifier(pos);  
         }  
  
         /**     getQualifierCount - Gets the numbercount of CIMQualifierobjects      /** getQualifierCount - Gets the number of CIMQualifier objects
         defined for this CIMObject.         defined for this CIMObject.
         @return Count of the number of CIMQalifier objects in the          @return Count of the number of CIMQualifier objects in the
         CIMObject.         CIMObject.
         @exception Throws the OutOfBounds exception if the index         @exception Throws the OutOfBounds exception if the index
         is out of bounds         is out of bounds
     */     */
     Uint32 getQualifierCount() const      Uint32 getQualifierCount() const;
     {  
         _checkRep();  
         return _rep->getQualifierCount();  
     }  
  
     /** addProperty - Adds a property object defined by the input     /** addProperty - Adds a property object defined by the input
         parameter to the CIMObject         parameter to the CIMObject
Line 250 
Line 179 
         @exception Throws the exception AlreadyExists if the property         @exception Throws the exception AlreadyExists if the property
         already exists.         already exists.
     */     */
     CIMObject& addProperty(const CIMProperty& x)      CIMObject& addProperty(const CIMProperty& x);
     {  
         _checkRep();  
         _rep->addProperty(x);  
         return *this;  
     }  
  
     /** findProperty - Searches the CIMProperty objects installed in the     /** findProperty - Searches the CIMProperty objects installed in the
         CIMObject for property objects with the name defined by the         CIMObject for property objects with the name defined by the
Line 265 
Line 189 
         PEG_NOT_FOUND if no property object found with the name defined by the         PEG_NOT_FOUND if no property object found with the name defined by the
         input.         input.
     */     */
     Uint32 findProperty(const String& name)      Uint32 findProperty(const String& name) const;
     {  
         _checkRep();  
         return _rep->findProperty(name);  
     }  
  
     Uint32 findProperty(const String& name) const      /** existsProperty - Determines if a property object with the
     {  
         _checkRep();  
         return _rep->findProperty(name);  
     }  
   
     /** existsPropery - Determines if a property object with the  
         name defined by the input parameter exists in the class.         name defined by the input parameter exists in the class.
         @parm String parameter with the property name.         @parm String parameter with the property name.
         @return True if the property object exists.         @return True if the property object exists.
     */     */
     Boolean existsProperty(const String& name)      Boolean existsProperty(const String& name) const;
     {  
         _checkRep();  
         return _rep->existsProperty(name);  
     }  
  
     Boolean existsProperty(const String& name) const      /** getProperty - Gets the CIMProperty object in the CIMObject defined
     {  
        _checkRep();  
        return _rep->existsProperty(name);  
     }  
   
     /** getProperty - Gets the CIMproperty object in the CIMObject defined  
         by the input index parameter.         by the input index parameter.
         @param Index to the property object in the CIMObject.         @param Index to the property object in the CIMObject.
         The index to qualifier objects is zero-origin and continuous         The index to qualifier objects is zero-origin and continuous
Line 306 
Line 210 
  
         ATTN: What is the effect of out of range?         ATTN: What is the effect of out of range?
     */     */
     CIMProperty getProperty(Uint32 pos)      CIMProperty getProperty(Uint32 pos);
     {  
         _checkRep();  
         return _rep->getProperty(pos);  
     }  
  
     /** getProperty - Gets the CIMproperty object in the CIMObject defined     /** getProperty - Gets the CIMproperty object in the CIMObject defined
         by the input index parameter.         by the input index parameter.
Line 324 
Line 224 
  
         ATTN: What is the effect of out of range?         ATTN: What is the effect of out of range?
     */     */
     CIMConstProperty getProperty(Uint32 pos) const      CIMConstProperty getProperty(Uint32 pos) const;
     {  
         _checkRep();  
         return _rep->getProperty(pos);  
     }  
  
     /** removeProperty - Removes the property represented     /** removeProperty - Removes the property represented
         by the position input parameter from the instance.         by the position input parameter from the instance.
Line 336 
Line 232 
         instance.  Normally this is obtained by getProperty();         instance.  Normally this is obtained by getProperty();
         @exception Throws OutofBounds if index is not a property object         @exception Throws OutofBounds if index is not a property object
     */     */
     void removeProperty(Uint32 pos)      void removeProperty(Uint32 pos);
     {  
         _checkRep();  
         _rep->removeProperty(pos);  
     }  
  
     /** getPropertyCount - Gets the numbercount of CIMProperty      /** getPropertyCount - Gets the number of CIMProperty
         objects defined for this CIMObject.         objects defined for this CIMObject.
         @return Count of the number of CIMProperty objects in the         @return Count of the number of CIMProperty objects in the
         CIMObject. Zero indicates that no CIMProperty objects         CIMObject. Zero indicates that no CIMProperty objects
Line 351 
Line 243 
         is out of bounds         is out of bounds
  
     */     */
     Uint32 getPropertyCount() const      Uint32 getPropertyCount() const;
     {  
         _checkRep();  
         return _rep->getPropertyCount();  
     }  
  
     /** operator int() - ATTN: */      /** Clones the given object.
     operator int() const { return _rep != 0; }      */
       CIMObject clone() const;
  
     /** Returns true if the two classes are structurally identical.     /** Returns true if the two classes are structurally identical.
     */     */
     Boolean identical(const CIMConstObject& x) const;     Boolean identical(const CIMConstObject& x) const;
  
     /** Convert object to XML format.  #ifdef PEGASUS_INTERNALONLY
     */      /** isNull() - ATTN: */
     void toXml(Array<Sint8>& out) const      Boolean isNull() const;
     {  #endif
         _checkRep();  
         _rep->toXml(out);  
     }  
   
     /** Clones the given object.  
     */  
     CIMObject clone() const  
     {  
         _checkRep();  
         return CIMObject(_rep->clone());  
     }  
  
 private: private:
  
     CIMObject(CIMObjectRep* rep) : _rep(rep)      CIMObjectRep* _rep;
     {  
  
     }  #ifdef PEGASUS_INTERNALONLY
       CIMObject(CIMObjectRep* rep);
  
     void _checkRep() const      void _checkRep() const;
     {  
         if (!_rep)  
             ThrowUnitializedHandle();  
     }  
   
     CIMObjectRep* _rep;  
  
     friend class CIMConstObject;     friend class CIMConstObject;
     friend class CIMClass;     friend class CIMClass;
     friend class CIMConstClass;     friend class CIMConstClass;
     friend class CIMInstance;     friend class CIMInstance;
     friend class CIMConstInstance;     friend class CIMConstInstance;
   #endif
 }; };
  
   #define PEGASUS_ARRAY_T CIMObject
   # include <Pegasus/Common/ArrayInter.h>
   #undef PEGASUS_ARRAY_T
   
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
 // CIMConstObject // CIMConstObject
Line 412 
Line 289 
 { {
 public: public:
  
     CIMConstObject() : _rep(0)      CIMConstObject();
     {  
  
     }      CIMConstObject(const CIMConstObject& x);
  
     CIMConstObject(const CIMConstObject& x)      CIMConstObject(const CIMObject& x);
     {  
         Inc(_rep = x._rep);  
     }  
   
     CIMConstObject(const CIMObject& x)  
     {  
         Inc(_rep = x._rep);  
     }  
  
     /** Construction from CIMClass.     /** Construction from CIMClass.
     */     */
Line 443 
Line 311 
     */     */
     CIMConstObject(const CIMConstInstance& x);     CIMConstObject(const CIMConstInstance& x);
  
     CIMConstObject& operator=(const CIMConstObject& x)      CIMConstObject& operator=(const CIMConstObject& x);
     {  
         if (x._rep != _rep)  
         {  
             Dec(_rep);  
             Inc(_rep = x._rep);  
         }  
         return *this;  
     }  
  
     CIMConstObject& operator=(const CIMObject& x)      CIMConstObject& operator=(const CIMObject& x);
     {  
         if (x._rep != _rep)  
         {  
             Dec(_rep);  
             Inc(_rep = x._rep);  
         }  
         return *this;  
     }  
  
     CIMConstObject& operator=(const CIMClass& x);     CIMConstObject& operator=(const CIMClass& x);
  
Line 471 
Line 323 
  
     CIMConstObject& operator=(const CIMConstInstance& x);     CIMConstObject& operator=(const CIMConstInstance& x);
  
     ~CIMConstObject()      ~CIMConstObject();
     {  
         Dec(_rep);  
     }  
   
     const String& getClassName() const  
     {  
         _checkRep();  
         return _rep->getClassName();  
     }  
  
     const CIMReference& getPath() const      const String& getClassName() const;
     {  
         _checkRep();  
         return _rep->getPath();  
     }  
  
     Uint32 findQualifier(const String& name) const      const CIMObjectPath& getPath() const;
     {  
         _checkRep();  
         return _rep->findQualifier(name);  
     }  
  
     CIMConstQualifier getQualifier(Uint32 pos) const      Uint32 findQualifier(const String& name) const;
     {  
         _checkRep();  
         return _rep->getQualifier(pos);  
     }  
  
     Uint32 getQualifierCount() const      CIMConstQualifier getQualifier(Uint32 pos) const;
     {  
         _checkRep();  
         return _rep->getQualifierCount();  
     }  
  
     Uint32 findProperty(const String& name) const      Uint32 getQualifierCount() const;
     {  
         _checkRep();  
         return _rep->findProperty(name);  
     }  
  
     CIMConstProperty getProperty(Uint32 pos) const      Uint32 findProperty(const String& name) const;
     {  
         _checkRep();  
         return _rep->getProperty(pos);  
     }  
  
     Uint32 getPropertyCount() const      CIMConstProperty getProperty(Uint32 pos) const;
     {  
         _checkRep();  
         return _rep->getPropertyCount();  
     }  
  
     operator int() const { return _rep != 0; }      Uint32 getPropertyCount() const;
  
     void toXml(Array<Sint8>& out) const      CIMObject clone() const;
     {  
         _checkRep();  
         _rep->toXml(out);  
     }  
   
     void print(PEGASUS_STD(ostream) &o=PEGASUS_STD(cout)) const  
     {  
         _checkRep();  
         _rep->print(o);  
     }  
  
     Boolean identical(const CIMConstObject& x) const      Boolean identical(const CIMConstObject& x) const;
     {  
         x._checkRep();  
         _checkRep();  
         return _rep->identical(x._rep);  
     }  
  
     CIMObject clone() const  #ifdef PEGASUS_INTERNALONLY
     {      Boolean isNull() const;
         return CIMObject(_rep->clone());  #endif
     }  
  
 private: private:
  
     void _checkRep() const  
     {  
         if (!_rep)  
             ThrowUnitializedHandle();  
     }  
   
     CIMObjectRep* _rep;     CIMObjectRep* _rep;
  
   #ifdef PEGASUS_INTERNALONLY
       void _checkRep() const;
   
     friend class CIMObject;     friend class CIMObject;
     friend class CIMClass;     friend class CIMClass;
     friend class CIMConstClass;     friend class CIMConstClass;
     friend class CIMInstance;     friend class CIMInstance;
     friend class CIMConstInstance;     friend class CIMConstInstance;
   #endif
 }; };
  
 /** The CIMObjectWithPath encapsulates a CIMReference and CIMObject.  /** The CIMObjectWithPath encapsulates a CIMObjectPath and CIMObject.
     Accessors are provided for getting the two parts. Constructors are     Accessors are provided for getting the two parts. Constructors are
     provided for initializing it from a CIMObject.     provided for initializing it from a CIMObject.
 */ */
Line 581 
Line 378 
  
     /** constructor     /** constructor
     */     */
     CIMObjectWithPath(const CIMReference& reference, const CIMObject& object);      CIMObjectWithPath(const CIMObjectPath& reference, const CIMObject& object);
  
     /** Constructor - Constructs a CIMObjectWithPath Object from     /** Constructor - Constructs a CIMObjectWithPath Object from
         another CimObjectWithPath         another CimObjectWithPath
Line 595 
Line 392 
  
     /** set -     /** set -
     */     */
     void set(const CIMReference& reference, const CIMObject& object);      void set(const CIMObjectPath& reference, const CIMObject& object);
  
     /**     /**
     */     */
     const CIMReference& getReference() const { return _reference; }      const CIMObjectPath& getReference() const;
  
     /**     /**
     */     */
     const CIMObject& getObject() const { return _object; }      const CIMObject& getObject() const;
  
     /**     /**
     */     */
     CIMReference& getReference() { return _reference; }      CIMObjectPath& getReference();
  
     /**     /**
     */     */
     CIMObject& getObject() { return _object; }      CIMObject& getObject();
   
     /**  
     */  
     void toXml(Array<Sint8>& out) const;  
  
 private: private:
  
     CIMReference _reference;      CIMObjectPath _reference;
     CIMObject _object;     CIMObject _object;
 }; };
  
   #define PEGASUS_ARRAY_T CIMObjectWithPath
   # include <Pegasus/Common/ArrayInter.h>
   #undef PEGASUS_ARRAY_T
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
  
 #endif /* Pegasus_Object_h */ #endif /* Pegasus_Object_h */

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