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

Diff for /pegasus/src/Pegasus/Common/SCMOInstance.h between version 1.1.2.7 and 1.4.2.1

version 1.1.2.7, 2009/08/11 13:06:15 version 1.4.2.1, 2012/05/25 13:04:22
Line 37 
Line 37 
 #include <Pegasus/Common/Linkage.h> #include <Pegasus/Common/Linkage.h>
 #include <Pegasus/Common/SCMO.h> #include <Pegasus/Common/SCMO.h>
 #include <Pegasus/Common/SCMOClass.h> #include <Pegasus/Common/SCMOClass.h>
   #include <Pegasus/Common/Union.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 #define PEGASUS_SCMB_INSTANCE_MAGIC 0xD00D1234 #define PEGASUS_SCMB_INSTANCE_MAGIC 0xD00D1234
  
 class SCMOClass;  
   
 class PEGASUS_COMMON_LINKAGE SCMOInstance class PEGASUS_COMMON_LINKAGE SCMOInstance
 { {
 public: public:
  
     /**     /**
        * A SCMOInstance can only be created by a SCMOClass
        */
       SCMOInstance();
   
       /**
      * Creating a SCMOInstance using a SCMOClass.      * Creating a SCMOInstance using a SCMOClass.
      * @param baseClass A SCMOClass.      * @param baseClass A SCMOClass.
      */      */
     SCMOInstance(SCMOClass baseClass);      SCMOInstance(SCMOClass& baseClass);
   
   
       /**
        * Creating a SCMOInstance using a CIMClass
        * using an optional name space name,
        * @param baseClass A SCMOClass.
        * @param nameSpaceName An optional name space name.
        */
       SCMOInstance(CIMClass& theCIMClass, const char* nameSpaceName=0);
  
     /**     /**
      * Copy constructor for the SCMO instance, used to implement refcounting.      * Copy constructor for the SCMO instance, used to implement refcounting.
Line 66 
Line 79 
     }     }
  
     /**     /**
        * Constructs a SCMOInstance from a memory object of type SCMBInstance_Main.
        * It incremets the referece counter of the memory object.
        * @param hdr A memory object of type SCMBInstance_Main.
        **/
       SCMOInstance(SCMBInstance_Main* hdr)
       {
           inst.hdr = hdr;
           Ref();
       }
   
   
       /**
        * Assignment operator for the SCMO instance,
        * @param theSCMOInstance The right hand value
        **/
       SCMOInstance& operator=(const SCMOInstance& theSCMOInstance)
       {
           if (inst.hdr != theSCMOInstance.inst.hdr)
           {
               Unref();
               inst.hdr = theSCMOInstance.inst.hdr;
               Ref();
           }
           return *this;
       }
   
       /**
      * Destructor is decrementing the refcount. If refcount is zero, the      * Destructor is decrementing the refcount. If refcount is zero, the
      * singele chunk memory object is deallocated.      * singele chunk memory object is deallocated.
      */      */
Line 96 
Line 136 
      *      *
      */      */
     SCMOInstance(     SCMOInstance(
         SCMOClass baseClass,          SCMOClass& baseClass,
         Boolean includeQualifiers,         Boolean includeQualifiers,
         Boolean includeClassOrigin,         Boolean includeClassOrigin,
         const char** propertyList);         const char** propertyList);
Line 106 
Line 146 
      * CIMInstance data into the new SCMOInstance.      * CIMInstance data into the new SCMOInstance.
      * @param baseClass The SCMOClass of this instance.      * @param baseClass The SCMOClass of this instance.
      * @param cimInstance A CIMInstace of the same class.      * @param cimInstance A CIMInstace of the same class.
      * @exception Exception if class name and name space does not match.       * @exception Exception if class name does not match.
      * @exception  
      *     Exception if CIMInstance has more key bindings then the SCMOClass.  
      * @exception  
      *     Exception if a key binding is not found as a key property  
      *     of the SCMOClass.  
      * @exception Exception if a key binding does not match  
      *     the class definition.  
      * @exception Exception if a property is not part of class definition.      * @exception Exception if a property is not part of class definition.
      * @exception Exception if a property does not match the class definition.      * @exception Exception if a property does not match the class definition.
      */      */
     SCMOInstance(SCMOClass baseClass, const CIMInstance& cimInstance);      SCMOInstance(SCMOClass& baseClass, const CIMInstance& cimInstance);
  
     /**     /**
      * Builds a SCMOInstance from the given SCMOClass and copies all      * Builds a SCMOInstance from the given SCMOClass and copies all
      * CIMObjectPath data into the new SCMOInstance.      * CIMObjectPath data into the new SCMOInstance.
      * @param baseClass The SCMOClass of this instance.      * @param baseClass The SCMOClass of this instance.
      * @param cimInstance A CIMObjectpath of the same class.      * @param cimInstance A CIMObjectpath of the same class.
      * @exception Exception if class name and name space does not match.       * @exception Exception if class name does not match.
      * @exception  
      *     Exception if CIMInstance has more key bindings then the SCMOClass.  
      * @exception  
      *     Exception if a key binding is not found as a key property  
      *     of the SCMOClass.  
      * @exception Exception if a key binding does not match  
      *     the class definition.  
      */      */
     SCMOInstance(SCMOClass baseClass, const CIMObjectPath& cimObj);      SCMOInstance(SCMOClass& baseClass, const CIMObjectPath& cimObj);
   
       /**
        * Builds a SCMOInstance from the given CIMInstance copying all data.
        * The SCMOClass is retrieved from SCMOClassCache using
        * the class and name space of the CIMInstance.
        * If the SCMOClass was not found, an empty SCMOInstance will be returned
        * and the resulting SCMOInstance is compromized.
        * If the CIMInstance does not contain a name space, the optional fall back
        * name space is used.
        * @param cimInstance A CIMInstace with class name and name space.
        * @param altNameSpace An alternative name space name.
        * @exception Exception if a property is not part of class definition.
        * @exception Exception if a property does not match the class definition.
        */
       SCMOInstance(
           const CIMInstance& cimInstance,
           const char* altNameSpace=0,
           Uint32 altNSLen=0);
   
       /**
        * Builds a SCMOInstance from the given CIMObjectPath copying all data.
        * The SCMOClass is retrieved from SCMOClassCache using
        * the class and name space of the CIMObjectPath.
        * If the SCMOClass was not found, an empty SCMOInstance will be returned
        * and the resulting SCMOInstance is compromized.
        * If the CIMObjectPath does not contain a name space,
        * the optional fall back name space is used.
        * @param cimObj A CIMObjectpath with name space and name
        * @param altNameSpace An alternative name space name.
        * @
        */
       SCMOInstance(
           const CIMObjectPath& cimObj,
           const char* altNameSpace=0,
           Uint32 altNSLen=0);
   
       /**
        * Builds a SCMOInstance from the given CIMObject copying all data.
        * The SCMOClass is retrieved from SCMOClassCache using
        * the class and name space of the CIMObject.
        * If the SCMOClass was not found, an empty SCMOInstance will be returned
        * and the resulting SCMOInstance is compromized.
        * If the CIMInstance does not contain a name space, the optional fall back
        * name space is used.
        * @param cimInstance A CIMInstace with class name and name space.
        * @param altNameSpace An alternative name space name.
        * @exception Exception if a property is not part of class definition.
        * @exception Exception if a property does not match the class definition.
        */
       SCMOInstance(
           const CIMObject& cimObject,
           const char* altNameSpace=0,
           Uint32 altNSLen=0);
  
     /**     /**
      * Converts the SCMOInstance into a CIMInstance.      * Converts the SCMOInstance into a CIMInstance.
Line 152 
Line 231 
     SCMOInstance clone(Boolean objectPathOnly = false) const;     SCMOInstance clone(Boolean objectPathOnly = false) const;
  
     /**     /**
        * Retrieves the objectpath part of the SCMOInstance as an instance
        * of class CIMObjectPath.                .
        * @param cimObj Reference to an instantiated CIMObjectPath to be
        *     populated with the data from the SCMOInstance.
        * @return void
        */
       void getCIMObjectPath(CIMObjectPath& cimObj) const;
   
       /**
      * Returns the number of properties of the instance.      * Returns the number of properties of the instance.
      * @param Number of properties      * @param Number of properties
      */      */
Line 165 
Line 253 
      *              Has to be copied by caller.      *              Has to be copied by caller.
      *              It is set to NULL if rc != SCMO_OK.      *              It is set to NULL if rc != SCMO_OK.
      * @param pvalue Returns a pointer to the value of property.      * @param pvalue Returns a pointer to the value of property.
      *               The value has to be copied by the caller !       *               The value is stored in a SCMBUnion
        *                and has to be copied by the caller !
      *               It returns NULL if rc != SCMO_OK.      *               It returns NULL if rc != SCMO_OK.
        *
      *               If the value is an array, the      *               If the value is an array, the
      *               value array is stored in continuous memory.      *               value array is stored in continuous memory.
      *               e.g. If the CIMType is CIMTYPE_UINT32:       *               e.g. (SCMBUnion*)value[0 to size-1]
      *               value = (void*)Uint32[0 to size-1]       *
      *               If it is an array of CIMTYPE_STRING, an array       *               If the value is type of CIMTYPE_STRING,
      *               of char* to the string values is returned.       *               the string is referenced by the structure
      *               This array has to be freed by the caller !       *               SCMBUnion.extString:
        *                       pchar contains the absolut pointer to the string
        *                       length contains the size of the string
        *                              without trailing '\0'.
        *               Only for strings the caller has to free pvalue !
      * @param type Returns the CIMType of the property      * @param type Returns the CIMType of the property
      *             It is invalid if rc == SCMO_INDEX_OUT_OF_BOUND.      *             It is invalid if rc == SCMO_INDEX_OUT_OF_BOUND.
      * @param isArray Returns if the value is an array.      * @param isArray Returns if the value is an array.
Line 191 
Line 285 
         Uint32 pos,         Uint32 pos,
         const char** pname,         const char** pname,
         CIMType& type,         CIMType& type,
         const void** pvalue,          const SCMBUnion** pvalue,
         Boolean& isArray,         Boolean& isArray,
         Uint32& size ) const;         Uint32& size ) const;
  
       void getSCMBValuePropertyAt(
           Uint32 pos,
           SCMBValue** value,
           const char ** valueBase,
           SCMBClassProperty ** propDef,
           const char ** classBase) const;
   
     /**     /**
      * Gets the type and value of the named property.      * Gets the type and value of the named property.
      * The value has to be copied by the caller !      * The value has to be copied by the caller !
      * @param name The property name      * @param name The property name
      * @param pvalue Returns a pointer to the value of property.      * @param pvalue Returns a pointer to the value of property.
      *               The value has to be copied by the caller !       *               The value is stored in a SCMBUnion
        *                and has to be copied by the caller !
      *               It returns NULL if rc != SCMO_OK.      *               It returns NULL if rc != SCMO_OK.
        *
      *               If the value is an array, the      *               If the value is an array, the
      *               value array is stored in continuous memory.      *               value array is stored in continuous memory.
      *               e.g. If the CIMType is CIMTYPE_UINT32:       *               e.g. (SCMBUnion*)value[0 to size-1]
      *               value = (void*)Uint32[0 to size-1]       *
      *               If it is an array of CIMTYPE_STRING, an array       *               If the value is type of CIMTYPE_STRING,
      *               of char* to the string values is returned.       *               the string is referenced by the structure
      *               This array has to be freed by the caller !       *               SCMBUnion.extString:
        *                       pchar contains the absolut pointer to the string
        *                       length contains the size of the string
        *                              without trailing '\0'.
        *               Only for strings the caller has to free pvalue !
      * @param type Returns the CIMType of the property      * @param type Returns the CIMType of the property
      *             It is invalid if rc == SCMO_NOT_FOUND.      *             It is invalid if rc == SCMO_NOT_FOUND.
      * @param isArray Returns if the value is an array.      * @param isArray Returns if the value is an array.
Line 224 
Line 331 
     SCMO_RC getProperty(     SCMO_RC getProperty(
         const char* name,         const char* name,
         CIMType& type,         CIMType& type,
         const void** pvalue,          const SCMBUnion** pvalue,
         Boolean& isArray,         Boolean& isArray,
         Uint32& size ) const;         Uint32& size ) const;
  
Line 236 
Line 343 
      * be set/replaced.      * be set/replaced.
      * @param name The name of the property to be set.      * @param name The name of the property to be set.
      * @param type The CIMType of the property      * @param type The CIMType of the property
      * @param value A pointer to property  value.       * @param value A pointer to the value to be set at the named property.
        *              The value has to be in a SCMBUnion.
      *         The value is copied into the instance      *         The value is copied into the instance
      *         If the value == NULL, a null value is assumed.      *         If the value == NULL, a null value is assumed.
      *         If the value is an array, the       *              If the value is an array, the value array has to be
      *         value array must be stored in continuous memory.       *              stored in continuous memory.
      *         e.g. If the CIMType is CIMTYPE_UINT32:       *              e.g. (SCMBUnion*)value[0 to size-1]
      *         value = (void*)Uint32[0 to size-1]       *
        *              To store an array of size 0, The value pointer has to
        *              not NULL ( value != NULL ) but the size has to be 0
        *              (size == 0).
        *
        *              If the value is type of CIMTYPE_STRING,
        *              the string is referenced by the structure
        *              SCMBUnion.extString:
        *                       pchar contains the absolut pointer to the string
        *                       length contains the size of the string
        *                              without trailing '\0'.
      * @param isArray Indicate that the value is an array. Default false.      * @param isArray Indicate that the value is an array. Default false.
      * @param size Returns the size of the array. If not an array this      * @param size Returns the size of the array. If not an array this
      *         this parameter is ignorer. Default 0.      *         this parameter is ignorer. Default 0.
Line 259 
Line 377 
     SCMO_RC setPropertyWithOrigin(     SCMO_RC setPropertyWithOrigin(
         const char* name,         const char* name,
         CIMType type,         CIMType type,
         void* value,          const SCMBUnion* value,
         Boolean isArray=false,         Boolean isArray=false,
         Uint32 size = 0,         Uint32 size = 0,
         const char* origin = NULL);         const char* origin = NULL);
Line 271 
Line 389 
      */      */
     void buildKeyBindingsFromProperties();     void buildKeyBindingsFromProperties();
  
     /**      //This function is not implemented and now Property filtering is done by
      * Set/replace a property filter on an instance.      //the CIMOM infrastructure
      * The filter is a white list of property names.  
      * A property part of the list can be accessed by name or index and  
      * is eligible to be returned to requester.  
      * Key properties can not be filtered. They are always a part of the  
      * instance. If a key property is not part of the property list,  
      * it will not be filtered out.  
      * @param propertyList Is an NULL terminated array of char* to  
      * property names  
      */  
     void setPropertyFilter(const char **propertyList);     void setPropertyFilter(const char **propertyList);
  
     /**     /**
Line 300 
Line 409 
      * is still SCMO_OK.      * is still SCMO_OK.
      * @param index The node index.      * @param index The node index.
      * @param type The CIMType of the property      * @param type The CIMType of the property
      * @param value A pointer to property  value.       * @param pInVal A pointer to the value to be set at the named property.
        *               The value has to be in a SCMBUnion.
      *         The value is copied into the instance      *         The value is copied into the instance
      *         If the value is an array, the       *               If the value == NULL, a null value is assumed.
      *         value array must be stored in continuous memory.       *               If the value is an array, the value array has to be
      *         e.g. If the CIMType is CIMTYPE_UINT32:       *               stored in continuous memory.
      *         value = (void*)Uint32[0 to size-1]       *               e.g. (SCMBUnion*)value[0 to size-1]
        *
        *              To store an array of size 0, The value pointer has to
        *               not NULL ( value != NULL ) but the size has to be 0
        *                (size == 0).
        *
        *               If the value is type of CIMTYPE_STRING,
        *               the string is referenced by the structure
        *               SCMBUnion.extString:
        *                        pchar contains the absolut pointer to the string
        *                       length contains the size of the string
        *                                without trailing '\0'.
      * @param isArray Indicate that the value is an array. Default false.      * @param isArray Indicate that the value is an array. Default false.
      * @param size The size of the array. If not an array this      * @param size The size of the array. If not an array this
      *         this parameter is ignorer. Default 0.      *         this parameter is ignorer. Default 0.
Line 321 
Line 442 
     SCMO_RC setPropertyWithNodeIndex(     SCMO_RC setPropertyWithNodeIndex(
         Uint32 node,         Uint32 node,
         CIMType type,         CIMType type,
         void* value,          const SCMBUnion* pInVal,
         Boolean isArray=false,         Boolean isArray=false,
         Uint32 size = 0);         Uint32 size = 0);
  
     /**     /**
      * Set/replace the named key binding       * Set/replace the named key binding using binary data
      * @param name The key binding name.      * @param name The key binding name.
      * @param type The type as CIMKeyBinding::Type.       * @param type The type as CIMType.
      * @parma value The value as string.       * @param keyvalue A pointer to the binary key value.
        *         The value is copied into the instance
        *         If the value == NULL, a null value is assumed.
        * @param keyvalue A pointer to the value to be set at the key binding,
        *               The keyvalue has to be in a SCMBUnion.
        *               The keyvalue is copied into the instance.
        *               If the keyvalue == NULL, a null value is assumed.
        *
        *               If the keyvalue is type of CIMTYPE_STRING,
        *               the string is referenced by the structure
        *               SCMBUnion.extString:
        *                        pchar contains the absolut pointer to the string
        *                       length contains the size of the string
        *                                without trailing '\0'.
      * @return     SCMO_OK      * @return     SCMO_OK
        *             SCMO_INVALID_PARAMETER : Given name or pvalue
        *                                      is a NULL pointer.
      *             SCMO_TYPE_MISSMATCH : Given type does not      *             SCMO_TYPE_MISSMATCH : Given type does not
      *                                   match to key binding type      *                                   match to key binding type
      *             SCMO_NOT_FOUND : Given property name not found.      *             SCMO_NOT_FOUND : Given property name not found.
      */      */
     SCMO_RC setKeyBinding(     SCMO_RC setKeyBinding(
         const char* name,         const char* name,
         CIMKeyBinding::Type type,          CIMType type,
         const char* pvalue);          const SCMBUnion* keyvalue);
  
     /**     /**
      * Set/replace the named key binding       * Set/replace the key binding at node
      * @param node The node index of the key.      * @param node The node index of the key.
      * @param type The type as CIMKeyBinding::Type.       * @param type The type as CIMType.
      * @parma value The value as string.       * @param keyvalue A pointer to the value to be set at the key binding,
        *               The keyvalue has to be in a SCMBUnion.
        *               The keyvalue is copied into the instance.
        *               If the keyvalue == NULL, a null value is assumed.
        *
        *               If the keyvalue is type of CIMTYPE_STRING,
        *               the string is referenced by the structure
        *               SCMBUnion.extString:
        *                        pchar contains the absolut pointer to the string
        *                       length contains the size of the string
        *                                without trailing '\0'.
      * @return     SCMO_OK      * @return     SCMO_OK
        *             SCMO_INVALID_PARAMETER : Given pvalue is a NULL pointer.
      *             SCMO_TYPE_MISSMATCH : Given type does not      *             SCMO_TYPE_MISSMATCH : Given type does not
      *                                   match to key binding type      *                                   match to key binding type
      *             SCMO_INDEX_OUT_OF_BOUND : Given index is our of range.      *             SCMO_INDEX_OUT_OF_BOUND : Given index is our of range.
      */      */
     SCMO_RC setKeyBindingAt(     SCMO_RC setKeyBindingAt(
         Uint32 node,         Uint32 node,
         CIMKeyBinding::Type type,          CIMType type,
         const char* pvalue);          const SCMBUnion* keyvalue);
   
       /**
        * Clears all key bindings in an instance.
        * Warning: External references are freed but only the internal
        * control structures are resetted. No memory is freed and at setting
        * new key bindings the instance will grow in memory usage.
        **/
       void clearKeyBindings();
  
     /**     /**
      * Gets the key binding count.      * Gets the key binding count.
      * @return the number of key bindings set.      * @return the number of key bindings set.
      */      */
     Uint32 getKeyBindingCount();      Uint32 getKeyBindingCount() const;
  
     /**     /**
      * Get the indexed key binding.      * Get the indexed key binding.
Line 367 
Line 522 
      * @parm pname Returns the name.      * @parm pname Returns the name.
      *             Has to be copied by caller.      *             Has to be copied by caller.
      *             It is invalid if rc == SCMO_INDEX_OUT_OF_BOUND.      *             It is invalid if rc == SCMO_INDEX_OUT_OF_BOUND.
      * @param type Returns the type as CIMKeyBinding::Type.       * @param type Returns the type as CIMType.
      *             It is invalid if rc == SCMO_INDEX_OUT_OF_BOUND.      *             It is invalid if rc == SCMO_INDEX_OUT_OF_BOUND.
      * @parma pvalue Returns the value as string.       * @param keyvalue A pointer to the binary key value.
      *             Has to be copied by caller.      *             Has to be copied by caller.
      *             It is only valid if rc == SCMO_OK.      *             It is only valid if rc == SCMO_OK.
      * @return     SCMO_OK      * @return     SCMO_OK
Line 380 
Line 535 
     SCMO_RC getKeyBindingAt(     SCMO_RC getKeyBindingAt(
         Uint32 idx,         Uint32 idx,
         const char** pname,         const char** pname,
         CIMKeyBinding::Type& type,          CIMType& type,
         const char** pvalue) const;          const SCMBUnion** keyvalue) const;
   
       SCMO_RC getKeyBindingAtUnresolved(
           Uint32 node,
           const char** pname,
           Uint32 & pnameLen,
           CIMType& type,
           const SCMBUnion** pdata,
           const char** valueBase) const;
  
     /**     /**
      * Get the named key binding.      * Get the named key binding.
      * @parm name The name of the key binding.      * @parm name The name of the key binding.
      * @param type Returns the type as CIMKeyBinding::Type.       * @param type Returns the type as CIMType.
      *             It is invalid if rc == SCMO_INDEX_OUT_OF_BOUND.      *             It is invalid if rc == SCMO_INDEX_OUT_OF_BOUND.
      * @parma value Returns the value as string.       * @param keyvalue Returns a pointer to the value of keybinding.
        *               The value is stored in a SCMBUnion
        *                and has to be copied by the caller !
        *               It returns NULL if rc != SCMO_OK.
        *
        *               If the value is type of CIMTYPE_STRING,
        *               the string is referenced by the structure
        *               SCMBUnion.extString:
        *                       pchar contains the absolut pointer to the string
        *                       length contains the size of the string
        *                              without trailing '\0'.
        *               Only for strings the caller has to free pvalue !
        * @param keyvalue A pointer to the binary key value.
      *             Has to be copied by caller.      *             Has to be copied by caller.
      *             It is only valid if rc == SCMO_OK.      *             It is only valid if rc == SCMO_OK.
      * @return     SCMO_OK      * @return     SCMO_OK
Line 397 
Line 572 
      */      */
     SCMO_RC getKeyBinding(     SCMO_RC getKeyBinding(
         const char* name,         const char* name,
         CIMKeyBinding::Type& ptype,          CIMType& ptype,
         const char** pvalue) const;          const SCMBUnion** keyvalue) const;
   
       /**
        * Determines whether the c++ object has been initialized.
        * @return True if the c++ object has not been initialized, false otherwise.
        */
       Boolean isUninitialized( ) const {return (0 == inst.base); };
  
     /**     /**
      * Determines whether the object has been initialized.       * Determines if the SCMOInstance does not contain any property information.
      * @return True if the object has not been initialized, false otherwise.       * Maybe only the class name and/or name space are available.
        * @return True if the SCMOInstacne is empty, false otherwise.
      */      */
     Boolean isUninitialized( ) const {return (inst.base == NULL); };      Boolean isEmpty( ) const {return (inst.hdr->theClass.ptr->isEmpty()); };
   
       /**
        * Determines whether the instance is used as a class container.
        * @return True if the instance is used as a class container only.
        */
       Boolean getIsClassOnly( ) const
       {
           return inst.hdr->flags.isClassOnly;
       }
   
       /**
        * To mark if this instance is a class only container.
        */
       void setIsClassOnly( Boolean b )
       {
           inst.hdr->flags.isClassOnly = b;
       }
  
     /**     /**
      * Determies if two objects are referencing to the same instance      * Determies if two objects are referencing to the same instance
Line 413 
Line 612 
     Boolean isSame(SCMOInstance& theInstance) const;     Boolean isSame(SCMOInstance& theInstance) const;
  
     /**     /**
        * Sets the provided host name at the instance.
        * @param hostName The host name as UTF8.
        */
       void setHostName(const char* hostName);
   
       /**
      * Get the host name of the instance. The caller has to make a copy !      * Get the host name of the instance. The caller has to make a copy !
      * @return The host name as UTF8.      * @return The host name as UTF8.
      */      */
     const char* getHostName() const;     const char* getHostName() const;
  
     /**     /**
      * Sets the provided host name at the instance.       * Get the host name of the instance.
      * @param hostName The host name as UTF8.       * @param Return strlen of result string.
        * @return The class name as UTF8.
      */      */
     void setHostName(const char* hostName);      const char* getHostName_l(Uint32 & length) const;
   
       /**
        * Sets the provided class name at the instance. By caling this function
        * the instance is in an inconsitacne state and is maked as isCompromised.
        * @param className The class name as UTF8.
        */
       void setClassName(const char* className);
   
       /**
        * Sets the provided class name at the instance. By caling this function
        * the instance is in an inconsitacne state and is maked as isCompromised.
        * @param className The class name as UTF8.
        * @param len The strlen of the name space.
        */
       void setClassName_l(const char* className, Uint32 len);
  
     /**     /**
      * Get the class name of the instance. The cabler has to make a copy !       * Get the class name of the instance. The caller has to make a copy !
      * @return The class name as UTF8.      * @return The class name as UTF8.
      */      */
     const char* getClassName() const;     const char* getClassName() const;
  
     /**     /**
        * Get the class name of the instance. The caller has to make a copy !
        * @param lenght Return strlen of result string.
        * @return The class name as UTF8.
        */
       const char* getClassName_l(Uint32 & length) const;
   
       /**
        * Sets the provided name space name at the instance.
        * By caling this function the instance is in an inconsitacne state and
        * is maked as isCompromised.
        * @param nameSpaceName The name space name as UTF8.
        */
       void setNameSpace(const char* nameSpace);
   
       /**
        * Sets the provided name space name unchecked at the instance.
        * By caling this function the instance is in an inconsitacne state and
        * is maked as isCompromised.
        * @param nameSpaceName The name space name as UTF8.
        * @param len The strlen of the name space.
        */
       void setNameSpace_l(const char* nameSpace, Uint32 len);
   
       /**
      * Get the name space of the instance. The caller has to make a copy !      * Get the name space of the instance. The caller has to make a copy !
      * @return The name space as UTF8.      * @return The name space as UTF8.
      */      */
     const char* getNameSpace() const;     const char* getNameSpace() const;
  
     /**     /**
        * Get the class name of the instance. The caller has to make a copy !
        * @param Return strlen of result string.
        * @return The class name as UTF8.
        */
       const char* getNameSpace_l(Uint32 & length) const;
   
       /**
        * If hostname or namespace of the SCMOInstance are NULL or empty string,
        * replace them with the given input.
        * @param hn The host name to apply to the SCMOInstance.
        * @param hnLen The length of the hostname in byte without closing zero.
        * @param ns The namespace name to apply to the SCMOInstance.
        * @param nsLen The length of the hostname in byte without closing zero.
        */
       void completeHostNameAndNamespace(
           const char* hn,
           Uint32 hnLen,
           const char* ns,
           Uint32 nsLen);
   
       /**
        * Is the name space or class name of the instance the origianl values
        * set by the used SCMOClass.
        * The class name and/or name space may differ with the associated class.
        * @return true if name space or class name was set manually by
        *          setNameSpace() or setClassName()
        */
       Boolean isCompromised() const
       {
           return inst.hdr->flags.isCompromised;
       };
   
   
       /**
        * Mark the instance as a non validated instance.
        */
       void markAsCompromised()
       {
           inst.hdr->flags.isCompromised = true;
       };
   
       /**
      *  To indicate the export processing ( eg. XMLWriter )      *  To indicate the export processing ( eg. XMLWriter )
      *  to include qualifiers for this instance.      *  to include qualifiers for this instance.
      */      */
Line 472 
Line 759 
         inst.hdr->flags.includeClassOrigin = false;         inst.hdr->flags.includeClassOrigin = false;
     }     }
  
   
       /**
        * Returns the number of external references hosted by the instance.
        **/
       Uint32 numberExtRef() const
       {
           return inst.mem->numberExtRef;
       }
   
       /**
        * Gets the pointer of an external reference of the instance.
        * Warning: The pointer is purely returned. No management is done.
        * @parm idx The index of the external reference.
        **/
       SCMOInstance* getExtRef(Uint32 idx) const;
   
       /**
        * Sets a pointer of an external reference of the instance.
        * Warning: The pointer is purely returned. No management is done.
        * @parm idx The index of the external reference.
        * @parm ptr The pointer to an SCMOInstance
        **/
       void putExtRef(Uint32 idx,SCMOInstance* ptr);
   
 private: private:
  
     void Ref()     void Ref()
     {     {
         inst.hdr->refCount++;         inst.hdr->refCount++;
         // printf("\ninst.hdr->refCount=%u\n",inst.hdr->refCount.get());  
     };     };
  
     void Unref()     void Unref()
     {     {
         if (inst.hdr->refCount.decAndTestIfZero())         if (inst.hdr->refCount.decAndTestIfZero())
         {         {
             // printf("\ninst.hdr->refCount=%u\n",inst.hdr->refCount.get());              // All external references has to be destroyed.
               _destroyExternalReferences();
             // The class has also be dereferenced.             // The class has also be dereferenced.
             delete inst.hdr->theClass;              delete inst.hdr->theClass.ptr;
             free(inst.base);             free(inst.base);
             inst.base=NULL;             inst.base=NULL;
         }         }
         else  
       };
   
   
       void _copyOnWrite()
         {         {
             // printf("\ninst.hdr->refCount=%u\n",inst.hdr->refCount.get());          if ( 1 < inst.hdr->refCount.get() )
         }          {
               SCMBInstance_Main * oldRef = inst.hdr;
               SCMBMgmt_Header* oldMgmt = inst.mem;
  
               _clone();
               if (oldRef->refCount.decAndTestIfZero())
               {
                   // All external references has to be destroyed.
                   _destroyExternalReferencesInternal(oldMgmt);
                   // The class has also be dereferenced.
                   delete oldRef->theClass.ptr;
                   free((void*)oldRef);
                   oldRef=0;
               }
           }
     };     };
     /**  
      * A SCMOInstance can only be created by a SCMOClass  
      */  
     SCMOInstance();  
  
     void _initSCMOInstance(      void _clone();
         SCMOClass* pClass,  
         Boolean inclQual,      void _destroyExternalReferences();
         Boolean inclOrigin);  
       void _destroyExternalKeyBindings();
   
       void _copyExternalReferences();
   
       void _setExtRefIndex(Uint64 idx);
  
       void _initSCMOInstance(SCMOClass* pClass);
   
       void _setCIMInstance(const CIMInstance& cimInstance);
   
       void _getPropertyAt(
           Uint32 pos,
           SCMBValue** value,
           const char ** valueBase,
           SCMBClassProperty ** propDef) const;
  
     SCMO_RC _getPropertyAtNodeIndex(     SCMO_RC _getPropertyAtNodeIndex(
             Uint32 pos,             Uint32 pos,
             const char** pname,             const char** pname,
             CIMType& type,             CIMType& type,
             const void** pvalue,          const SCMBUnion** pvalue,
             Boolean& isArray,             Boolean& isArray,
             Uint32& size ) const;             Uint32& size ) const;
  
     void _setPropertyAtNodeIndex(     void _setPropertyAtNodeIndex(
         Uint32 pos,         Uint32 pos,
         CIMType type,         CIMType type,
         void* value,          const SCMBUnion* pInVal,
         Boolean isArray,         Boolean isArray,
         Uint32 size);         Uint32 size);
  
     void _setCIMValueAtNodeIndex(Uint32 node, CIMValueRep* valRep);      void _setCIMValueAtNodeIndex(
           Uint32 node,
           CIMValueRep* valRep,
           CIMType realType);
  
     void _getCIMValueFromSCMBValue(      static void _getCIMValueFromSCMBUnion(
           CIMValue& cimV,
           const CIMType type,
           const Boolean isNull,
           const Boolean isArray,
           const Uint32 arraySize,
           const SCMBUnion& scmbUn,
           const char * base);
   
       static void _getCIMValueFromSCMBValue(
         CIMValue& cimV,         CIMValue& cimV,
         const SCMBValue& scmbV,         const SCMBValue& scmbV,
         const char * base) const;          const char * base);
   
       static SCMOClass _getSCMOClass(
           const CIMObjectPath& theCIMObj,
           const char* altNS,
           Uint32 altNSlength);
  
     CIMProperty _getCIMPropertyAtNodeIndex(Uint32 nodeIdx) const;     CIMProperty _getCIMPropertyAtNodeIndex(Uint32 nodeIdx) const;
  
     void _setCIMObjectPath(const CIMObjectPath& cimObj);     void _setCIMObjectPath(const CIMObjectPath& cimObj);
  
     void _getCIMObjectPath(CIMObjectPath& cimObj) const;      SCMBUnion* _resolveSCMBUnion(
   
     void* _getSCMBUnion(  
         CIMType type,         CIMType type,
         Boolean isArray,         Boolean isArray,
         Uint32 size,         Uint32 size,
Line 543 
Line 896 
         char* base) const;         char* base) const;
  
     void _setSCMBUnion(     void _setSCMBUnion(
         void* value,          const SCMBUnion* pInVal,
         CIMType type,         CIMType type,
         Boolean isArray,         Boolean isArray,
         Uint32 size,         Uint32 size,
         Uint64 start);          SCMBUnion & u);
  
     static void _setUnionValue(     static void _setUnionValue(
         Uint64 start,         Uint64 start,
         SCMBMgmt_Header** pmem,         SCMBMgmt_Header** pmem,
         CIMType type,         CIMType type,
           Uint64 startNS,
           Uint32 lenNS,
         Union& u);         Union& u);
  
     static void _setArrayValue(      static void _setUnionArrayValue(
         Uint64 start,         Uint64 start,
         SCMBMgmt_Header** pmem,         SCMBMgmt_Header** pmem,
         CIMType type,         CIMType type,
         Uint32& n,         Uint32& n,
           Uint64 startNS,
           Uint32 lenNS,
         Union& u);         Union& u);
  
     SCMO_RC _getKeyBindingAtNodeIndex(      static void _setExtRefIndex(SCMBUnion* pInst, SCMBMgmt_Header** pmem);
         Uint32 pos,  
       SCMO_RC _getKeyBindingDataAtNodeIndex(
           Uint32 node,
         const char** pname,         const char** pname,
         CIMKeyBinding::Type& ptype,          Uint32 & pnameLen,
         const char** pvalue) const;          CIMType& type,
           const SCMBUnion** pdata) const;
  
     void _copyKeyBindings(SCMOInstance& targetInst) const;     void _copyKeyBindings(SCMOInstance& targetInst) const;
  
Line 580 
Line 940 
  
     void _setKeyBindingFromSCMBUnion(     void _setKeyBindingFromSCMBUnion(
         CIMType type,         CIMType type,
         SCMBUnion& u,          const SCMBUnion& u,
         SCMBDataPtr& keyNode);          const char * uBase,
           SCMBKeyBindingValue& keyData);
   
       SCMO_RC _setKeyBindingFromString(
           const char* name,
           CIMType type,
           String cimKeyBinding);
   
       SCMBUserKeyBindingElement* _getUserDefinedKeyBinding(
           const char* name,
           Uint32 nameLen,
           CIMType type);
   
       void _setUserDefinedKeyBinding(
           SCMBUserKeyBindingElement& theInsertElement,
           char* elementBase);
       /**
        * Set a SCMO user defined key binding using the class CIM type tolerating
        * CIM key binding types converted to CIM types by fuction
        *  _CIMTypeFromKeyBindingType().
        *
        * @parm classType The type of the key binding in the class definition
        * @parm setType The type of the key binding to be set.
        * @param keyValue A pointer to the key binding to be set.
        * @param kbValue Out parameter, the SCMO keybinding to be set.
        *
        **/
       SCMO_RC _setKeyBindingTypeTolerate(
           CIMType classType,
           CIMType setType,
           const SCMBUnion* keyValue,
           SCMBKeyBindingValue& kbValue);
   
       CIMType _CIMTypeFromKeyBindingType(
           const char* key,
           CIMKeyBinding::Type t);
   
       SCMO_RC _getUserKeyBindingNodeIndex(Uint32& node, const char* name) const;
   
       SCMBUserKeyBindingElement* _getUserDefinedKeyBindingAt(Uint32 index) const;
   
       Boolean _setCimKeyBindingStringToSCMOKeyBindingValue(
           const String& kbs,
           CIMType type,
           SCMBKeyBindingValue& scmoKBV
           );
   
  
     union{     union{
         // To access the instance main structure         // To access the instance main structure
Line 594 
Line 1000 
  
     friend class SCMOClass;     friend class SCMOClass;
     friend class SCMODump;     friend class SCMODump;
       friend class SCMOXmlWriter;
       friend class SCMOStreamer;
 }; };
  
   inline void SCMOInstance::_getPropertyAt(
       Uint32 pos,
       SCMBValue** value,
       const char ** valueBase,
       SCMBClassProperty ** propDef) const
   {
       SCMBValue* theInstPropNodeArray =
           (SCMBValue*)&(inst.base[inst.hdr->propertyArray.start]);
   
       // create a pointer to property node array of the class.
       Uint64 idx = inst.hdr->theClass.ptr->cls.hdr->propertySet.nodeArray.start;
       SCMBClassPropertyNode* theClassPropNodeArray =
           (SCMBClassPropertyNode*)&(inst.hdr->theClass.ptr->cls.base)[idx];
   
       // return the absolute pointer to the property definition
       *propDef= &(theClassPropNodeArray[pos].theProperty);
   
       // need check if property set or not, if not set use the default value
       if (theInstPropNodeArray[pos].flags.isSet)
       {
           // return the absolute pointer to the property value in the instance
           *value = &(theInstPropNodeArray[pos]);
           *valueBase = inst.base;
       }
       else
       {
           // return the absolute pointer to
           *value = &(theClassPropNodeArray[pos].theProperty.defaultValue);
           *valueBase = inst.hdr->theClass.ptr->cls.base;
       }
   }
   
   inline void SCMOInstance::getSCMBValuePropertyAt(
       Uint32 pos,
       SCMBValue** value,
       const char ** valueBase,
       SCMBClassProperty ** propDef,
       const char ** propDefBase) const
   {
       _getPropertyAt(pos,value,valueBase,propDef);
   
       *propDefBase = inst.hdr->theClass.ptr->cls.base;
   }
   
   inline SCMO_RC SCMOInstance::getKeyBindingAtUnresolved(
           Uint32 node,
           const char** pname,
           Uint32 & pnameLen,
           CIMType& type,
           const SCMBUnion** pdata,
           const char** valueBase) const
   {
       SCMO_RC rc = _getKeyBindingDataAtNodeIndex(node,pname,pnameLen,type,pdata);
       // Adjust size to string length
       if (pnameLen)
       {
           pnameLen--;
       }
       *valueBase = inst.base;
       return rc;
   }
   
   
   
   #define PEGASUS_ARRAY_T SCMOInstance
   # include <Pegasus/Common/ArrayInter.h>
   #undef PEGASUS_ARRAY_T
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
  

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