(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.6 and 1.47

version 1.6, 2001/07/10 22:31:09 version 1.47, 2007/10/19 18:22:02
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 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.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 20 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (mbrasher@bmc.com)  
 //  
 // Modified By:  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #ifndef Pegasus_CIMObject_h  #ifndef Pegasus_Object_h
 #define Pegasus_CIMObject_h  #define Pegasus_Object_h
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <Pegasus/Common/CIMClass.h>  #include <Pegasus/Common/Linkage.h>
 #include <Pegasus/Common/CIMInstance.h>  #include <Pegasus/Common/String.h>
   #include <Pegasus/Common/CIMName.h>
   #include <Pegasus/Common/Array.h>
   #include <Pegasus/Common/CIMProperty.h>
   #include <Pegasus/Common/CIMQualifier.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 /** This class contains either a class or an instance (both CIM objects).  class CIMConstObject;
     Initializers are provided for both CIMClass and CIMInstance. The  class CIMObjectRep;
     isClass() and isInstance() methods are provided for determining the  class CIMClass;
     type of contained object. Methods are also provided for getting  class CIMConstClass;
     the internal object (into a CIMClass or CIMInstance).  class CIMInstance;
   class CIMConstInstance;
   class CIMProperty;
   class CIMConstProperty;
   class CIMQualifier;
   class CIMConstQualifier;
   
   ////////////////////////////////////////////////////////////////////////////////
   //
   // CIMObject
   //
   ////////////////////////////////////////////////////////////////////////////////
   
   /**
       The CIMObject class represents the DMTF standard CIM object definition,
       which may represent a CIMClass or a CIMInstance.
   
       <p>The CIMObject class uses a shared representation model, such that
       multiple CIMObject objects may refer to the same data copy.  Assignment
       and copy operators create new references to the same data, not distinct
       copies.  An update to a CIMObject object affects all the CIMObject
       objects that refer to the same data copy.  The data remains valid until
       all the CIMObject objects that refer to it are destructed.  A separate
       copy of the data may be created using the clone method.
 */ */
 class PEGASUS_COMMON_LINKAGE CIMObject class PEGASUS_COMMON_LINKAGE CIMObject
 { {
 public: public:
  
     CIMObject() : _rep(0), _type(TYPE_NONE)      /**
     {          Constructs an uninitialized CIMObject object.  A method
           invocation on an uninitialized object will result in the throwing
           of an UninitializedObjectException.  An uninitialized object may
           be converted into an initialized object only by using the assignment
           operator with an initialized object.
       */
       CIMObject();
  
     }      /**
           Constructs a CIMObject object from the value of a specified
           CIMObject object, so that both objects refer to the same data copy.
           @param x The CIMObject object from which to construct a new
               CIMObject object.
       */
       CIMObject(const CIMObject& x);
  
     CIMObject(const CIMObject& x) : _type(x._type)      /**
     {          Constructs a CIMObject object from the value of a specified
         Inc(_rep = x._rep);          CIMClass object, so that both objects refer to the same data copy.
     }          @param x The CIMClass object from which to construct the
               CIMObject object.
       */
       CIMObject(const CIMClass& x);
  
     CIMObject(const CIMClass& x) : _type(TYPE_CLASS)      /**
     {          Constructs a CIMObject object from the value of a specified
         Inc(_rep = x._rep);          CIMInstance object, so that both objects refer to the same data copy.
     }          @param x The CIMInstance object from which to construct the
               CIMObject object.
       */
       CIMObject(const CIMInstance& x);
  
     CIMObject(const CIMInstance& x) : _type(TYPE_INSTANCE)      /**
     {          Assigns the value of the specified CIMObject object to this object,
         Inc(_rep = x._rep);          so that both objects refer to the same data copy.
     }          @param x The CIMObject object from which to assign this CIMObject
               object.
           @return A reference to this CIMObject object.
       */
       CIMObject& operator=(const CIMObject& x);
  
     CIMObject& operator=(const CIMObject& x)      /**
     {          Destructs the CIMObject object.
         if (x._rep != _rep)      */
         {      ~CIMObject();
             Dec(_rep);  
             Inc(_rep = x._rep);  
             _type = x._type;  
         }  
         return *this;  
     }  
  
     CIMObject& operator=(const CIMClass& x)      /**
     {          Gets the class name of the object.
         if (x._rep != _rep)          @return A CIMName containing the class name.
         {          @exception UninitializedObjectException If the object is not
             Dec(_rep);              initialized.
             Inc(_rep = x._rep);      */
             _type = TYPE_CLASS;      const CIMName& getClassName() const;
         }  
         return *this;  
     }  
  
     CIMObject& operator=(const CIMInstance& x)      /**
     {          Gets the object path for the object.
         if (x._rep != _rep)          @return A CIMObjectPath containing the object path.
         {          @exception UninitializedObjectException If the object is not
             Dec(_rep);              initialized.
             Inc(_rep = x._rep);      */
             _type = TYPE_INSTANCE;      const CIMObjectPath& getPath() const;
         }  
         return *this;  
     }  
  
     ~CIMObject()      /**
     {          Sets the object path for the object.
         Dec(_rep);          @param path A CIMObjectPath containing the object path.
     }          @exception UninitializedObjectException If the object is not
               initialized.
       */
       void setPath (const CIMObjectPath & path);
  
     Boolean isClass() const      /**
     {          Adds a qualifier to the object.
         return _type == TYPE_CLASS;          @param qualifier The CIMQualifier to be added.
     }          @return A reference to this CIMObject object.
           @exception AlreadyExistsException If a qualifier with the
               same name already exists in the CIMObject.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       CIMObject& addQualifier(const CIMQualifier& qualifier);
  
     Boolean isInstance() const      /**
     {          Finds a qualifier by name.
         return _type == TYPE_INSTANCE;          @param name A CIMName specifying the name of the qualifier to be found.
     }          @return Index of the qualifier if found or PEG_NOT_FOUND if not found.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       Uint32 findQualifier(const CIMName& name) const;
   
       /**
           Gets the qualifier at the specified index.
           @param index The index of the qualifier to be retrieved.
           @return The CIMQualifier at the specified index.
           @exception IndexOutOfBoundsException If the index is outside
               the range of qualifiers available for the CIMObject.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       CIMQualifier getQualifier(Uint32 index);
  
     /** Returns the class contained by this object (if an class).      /**
         @return CIMClass          Gets the qualifier at the specified index.
         @exception throws TypeMismatch if object does not contain a CIMClass.          @param index The index of the qualifier to be retrieved.
           @return The CIMConstQualifier at the specified index.
           @exception IndexOutOfBoundsException If the index is outside
               the range of qualifiers available for the CIMObject.
           @exception UninitializedObjectException If the object is not
               initialized.
     */     */
     CIMClass getClass();      CIMConstQualifier getQualifier(Uint32 index) const;
  
     /** Const version of getClass() */      /**
           Removes a qualifier from the object.
           @param index The index of the qualifier to remove.
           @exception IndexOutOfBoundsException If the index is
               outside the range of qualifiers available for the CIMObject.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       void removeQualifier(Uint32 index);
  
     CIMConstClass getClass() const;      /**
           Gets the number of qualifiers in the object.
           @return An integer count of the qualifiers in the CIMObject.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       Uint32 getQualifierCount() const;
  
     /** Returns the instance contained by this object (if an instance).      /**
         @return CIMInstance          Adds a property to the object.
         @exception throws TypeMismatch if object does not contain a CIMInstance.          @param x The CIMProperty to be added.
           @return A reference to this CIMObject object.
           @exception AlreadyExistsException If a property with the
               same name already exists in the CIMObject.
           @exception UninitializedObjectException If the object is not
               initialized.
     */     */
     CIMInstance getInstance();      CIMObject& addProperty(const CIMProperty& x);
  
     /** Const version of getInstance() */      /**
           Finds a property by name.
           @param name A CIMName specifying the name of the property to be found.
           @return Index of the property if found or PEG_NOT_FOUND if not found.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       Uint32 findProperty(const CIMName& name) const;
  
     CIMConstInstance getInstance() const;      /**
           Gets the property at the specified index.
           @param index The index of the property to be retrieved.
           @return The CIMProperty at the specified index.
           @exception IndexOutOfBoundsException If the index is outside
               the range of properties available for the CIMObject.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       CIMProperty getProperty(Uint32 index);
  
     operator int() const      /**
     {          Gets the property at the specified index.
         return _rep != 0;          @param index The index of the property to be retrieved.
     }          @return The CIMConstProperty at the specified index.
           @exception IndexOutOfBoundsException If the index is outside
               the range of properties available for the CIMObject.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       CIMConstProperty getProperty(Uint32 index) const;
  
     void toXml(Array<Sint8>& out) const;      /**
           Removes a property from the object.
           @param index The index of the property to remove.
           @exception IndexOutOfBoundsException If the index is
               outside the range of properties available for the CIMObject.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       void removeProperty(Uint32 index);
  
 private:      /**
           Gets the number of properties in the object.
           @return An integer count of the properties in the CIMObject.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       Uint32 getPropertyCount() const;
  
     void _checkRep() const      /**
     {          Makes a deep copy of the object.  This creates a new copy of all
         if (!_rep)          the object attributes including qualifiers and properties.
             ThrowUnitializedHandle();          @return A new copy of the CIMObject object.
     }          @exception UninitializedObjectException If the object is not
               initialized.
       */
       CIMObject clone() const;
  
     // Point to either a CIMClass or CIMInstance:      /**
           Compares the CIMObject with a specified CIMConstObject.
           @param x The CIMConstObject to be compared.
           @return True if this object is identical to the one specified,
               false otherwise.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       Boolean identical(const CIMConstObject& x) const;
   
       /**
           Determines whether the object has been initialized.
           @return True if the object has not been initialized, false otherwise.
       */
       Boolean isUninitialized() const;
   
       /**
           Generates a human-readable String representing the value of the
           CIMObject.  The String may be in MOF format, but the format is not
           guaranteed and may change without notice.
           @return A human-readable String representing the CIMObject value.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       String toString() const;
   
       /**
           Indicates whether the object represents a CIMClass.
           @return True if the object represents a CIMClass; false otherwise.
       */
       Boolean isClass() const;
   
       /**
           Indicates whether the object represents a CIMInstance.
           @return True if the object represents a CIMInstance; false otherwise.
       */
       Boolean isInstance() const;
   
   private:
   
       CIMObjectRep* _rep;
  
     Sharable* _rep;      CIMObject(CIMObjectRep* rep);
  
     enum Type { TYPE_CLASS, TYPE_INSTANCE, TYPE_NONE };      friend class CIMConstObject;
     Type _type;      friend class CIMClass;
       friend class CIMConstClass;
       friend class CIMInstance;
       friend class CIMConstInstance;
 }; };
  
 /** The CIMObjectWithPath encapsulates a CIMReference and CIMObject.  #define PEGASUS_ARRAY_T CIMObject
     Accessors are provided for getting the two parts. Constructors are  # include <Pegasus/Common/ArrayInter.h>
     provided for initializing it from a CIMObject.  #undef PEGASUS_ARRAY_T
   
   
   ////////////////////////////////////////////////////////////////////////////////
   //
   // CIMConstObject
   //
   ////////////////////////////////////////////////////////////////////////////////
   
   /**
       The CIMConstObject class provides a const interface to a CIMObject
       object.  This class is needed because the shared representation model
       used by CIMObject does not prevent modification to a const CIMObject
       object.  Note that the value of a CIMConstObject object could still be
       modified by a CIMObject object that refers to the same data copy.
 */ */
 class PEGASUS_COMMON_LINKAGE CIMObjectWithPath  class PEGASUS_COMMON_LINKAGE CIMConstObject
 { {
 public: public:
  
     /** Constructor      /**
           Constructs an uninitialized CIMConstObject object.  A method
           invocation on an uninitialized object will result in the throwing
           of an UninitializedObjectException.  An uninitialized object may
           be converted into an initialized object only by using the assignment
           operator with an initialized object.
       */
       CIMConstObject();
   
       /**
           Constructs a CIMConstObject object from the value of a specified
           CIMConstObject object, so that both objects refer to the same data
           copy.
           @param x The CIMConstObject object from which to construct a new
               CIMConstObject object.
       */
       CIMConstObject(const CIMConstObject& x);
   
       /**
           Constructs a CIMConstObject object from the value of a specified
           CIMObject object, so that both objects refer to the same data copy.
           @param x The CIMObject object from which to construct a new
               CIMConstObject object.
       */
       CIMConstObject(const CIMObject& x);
   
       /**
           Constructs a CIMConstObject object from the value of a specified
           CIMClass object, so that both objects refer to the same data copy.
           @param x The CIMClass object from which to construct the
               CIMConstObject object.
       */
       CIMConstObject(const CIMClass& x);
   
       /**
           Constructs a CIMConstObject object from the value of a specified
           CIMInstance object, so that both objects refer to the same data copy.
           @param x The CIMInstance object from which to construct the
               CIMConstObject object.
       */
       CIMConstObject(const CIMInstance& x);
   
       /**
           Constructs a CIMConstObject object from the value of a specified
           CIMConstClass object, so that both objects refer to the same data copy.
           @param x The CIMConstClass object from which to construct the
               CIMConstObject object.
       */
       CIMConstObject(const CIMConstClass& x);
   
       /**
           Constructs a CIMConstObject object from the value of a specified
           CIMConstInstance object, so that both objects refer to the same data
           copy.
           @param x The CIMConstInstance object from which to construct the
               CIMConstObject object.
       */
       CIMConstObject(const CIMConstInstance& x);
   
       /**
           Assigns the value of the specified CIMConstObject object to this
           object, so that both objects refer to the same data copy.
           @param x The CIMConstObject object from which to assign this
               CIMConstObject object.
           @return A reference to this CIMConstObject object.
       */
       CIMConstObject& operator=(const CIMConstObject& x);
   
       /**
           Destructs the CIMConstObject object.
       */
       ~CIMConstObject();
   
       /**
           Gets the class name of the object.
           @return A CIMName containing the class name.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       const CIMName& getClassName() const;
   
       /**
           Gets the object path for the object.
           @return A CIMObjectPath containing the object path.
           @exception UninitializedObjectException If the object is not
               initialized.
     */     */
     CIMObjectWithPath();      const CIMObjectPath& getPath() const;
  
     /** constructor      /**
           Finds a qualifier by name.
           @param name A CIMName specifying the name of the qualifier to be found.
           @return Index of the qualifier if found or PEG_NOT_FOUND if not found.
           @exception UninitializedObjectException If the object is not
               initialized.
     */     */
     CIMObjectWithPath(const CIMReference& reference, const CIMObject& object);      Uint32 findQualifier(const CIMName& name) const;
  
     /** Constructor - Constructs a CIMObjectWithPath Object from      /**
         another CimObjectWithPath          Gets the qualifier at the specified index.
         @param - ATTN          @param index The index of the qualifier to be retrieved.
           @return The CIMConstQualifier at the specified index.
           @exception IndexOutOfBoundsException If the index is outside
               the range of qualifiers available for the CIMConstObject.
           @exception UninitializedObjectException If the object is not
               initialized.
     */     */
     CIMObjectWithPath(const CIMObjectWithPath& x);      CIMConstQualifier getQualifier(Uint32 index) const;
  
     ~CIMObjectWithPath();      /**
           Gets the number of qualifiers in the object.
           @return An integer count of the qualifiers in the CIMConstObject.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       Uint32 getQualifierCount() const;
  
     CIMObjectWithPath& operator=(const CIMObjectWithPath& x);      /**
           Finds a property by name.
           @param name A CIMName specifying the name of the property to be found.
           @return Index of the property if found or PEG_NOT_FOUND if not found.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       Uint32 findProperty(const CIMName& name) const;
  
     /** set -      /**
           Gets the property at the specified index.
           @param index The index of the property to be retrieved.
           @return The CIMConstProperty at the specified index.
           @exception IndexOutOfBoundsException If the index is outside
               the range of properties available for the CIMConstObject.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       CIMConstProperty getProperty(Uint32 index) const;
   
       /**
           Gets the number of properties in the object.
           @return An integer count of the properties in the CIMConstObject.
           @exception UninitializedObjectException If the object is not
               initialized.
     */     */
     void set(const CIMReference& reference, const CIMObject& object);      Uint32 getPropertyCount() const;
  
     /**     /**
           Makes a deep copy of the object.  This creates a new copy of all
           the object attributes including qualifiers and properties.
           @return A CIMObject object with a separate copy of the
               CIMConstObject object.
           @exception UninitializedObjectException If the object is not
               initialized.
     */     */
     const CIMReference& getReference() const { return _reference; }      CIMObject clone() const;
  
     /**     /**
           Compares the CIMConstObject with a specified CIMConstObject.
           @param x The CIMConstObject to be compared.
           @return True if this object is identical to the one specified,
               false otherwise.
           @exception UninitializedObjectException If the object is not
               initialized.
     */     */
     const CIMObject& getObject() const { return _object; }      Boolean identical(const CIMConstObject& x) const;
  
     /**     /**
           Determines whether the object has been initialized.
           @return True if the object has not been initialized, false otherwise.
     */     */
     CIMReference& getReference() { return _reference; }      Boolean isUninitialized() const;
  
     /**     /**
           Generates a human-readable String representing the value of the
           CIMObject.  The String may be in MOF format, but the format is not
           guaranteed and may change without notice.
           @return A human-readable String representing the CIMObject value.
           @exception UninitializedObjectException If the object is not
               initialized.
     */     */
     CIMObject& getObject() { return _object; }      String toString () const;
  
     /**     /**
           Indicates whether the object represents a CIMConstClass.
           @return True if the object represents a CIMConstClass; false otherwise.
     */     */
     void toXml(Array<Sint8>& out) const;      Boolean isClass() const;
   
       /**
           Indicates whether the object represents a CIMConstInstance.
           @return True if the object represents a CIMConstInstance; false
               otherwise.
       */
       Boolean isInstance() const;
  
 private: private:
  
     CIMReference _reference;      CIMObjectRep* _rep;
     CIMObject _object;  
       friend class CIMObject;
       friend class CIMClass;
       friend class CIMConstClass;
       friend class CIMInstance;
       friend class CIMConstInstance;
 }; };
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
  
 #endif /* Pegasus_CIMObject_h */  #endif /* Pegasus_Object_h */

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