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

Diff for /pegasus/src/Pegasus/Common/CIMValue.h between version 1.21 and 1.58

version 1.21, 2002/05/15 06:42:28 version 1.58, 2012/01/11 23:58:57
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%LICENSE////////////////////////////////////////////////////////////////
 //  
 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM  
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy  // Licensed to The Open Group (TOG) under one or more contributor license
 // of this software and associated documentation files (the "Software"), to  // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
 // deal in the Software without restriction, including without limitation the  // this work for additional information regarding copyright ownership.
 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or  // Each contributor licenses this file to you under the OpenPegasus Open
 // sell copies of the Software, and to permit persons to whom the Software is  // Source License; you may not use this file except in compliance with the
 // furnished to do so, subject to the following conditions:  // License.
 // //
 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN  // Permission is hereby granted, free of charge, to any person obtaining a
 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED  // copy of this software and associated documentation files (the "Software"),
 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT  // to deal in the Software without restriction, including without limitation
 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR  // the rights to use, copy, modify, merge, publish, distribute, sublicense,
 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT  // and/or sell copies of the Software, and to permit persons to whom the
 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN  // Software is furnished to do so, subject to the following conditions:
 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION  
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  
 // //
 //==============================================================================  // The above copyright notice and this permission notice shall be included
   // in all copies or substantial portions of the Software.
 // //
 // Author: Mike Brasher (mbrasher@bmc.com)  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
   // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
   // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
   // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
   // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // //
 // Modified By: Karl schopmeyer (k.schopmeyer@opengroup.org)  //////////////////////////////////////////////////////////////////////////
 //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)  
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 33 
Line 35 
 #include <Pegasus/Common/String.h> #include <Pegasus/Common/String.h>
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <Pegasus/Common/CIMType.h> #include <Pegasus/Common/CIMType.h>
 #include <Pegasus/Common/CIMReference.h>  #include <Pegasus/Common/CIMObjectPath.h>
   #include <Pegasus/Common/CIMObject.h>
 #include <Pegasus/Common/CIMDateTime.h> #include <Pegasus/Common/CIMDateTime.h>
 #include <Pegasus/Common/Exception.h> #include <Pegasus/Common/Exception.h>
 #include <Pegasus/Common/Array.h> #include <Pegasus/Common/Array.h>
   #include <Pegasus/Common/Linkage.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 class CIMValueRep; class CIMValueRep;
   class CIMObject;
   class CIMInstance;
  
 /** /**
     The CIMValue class represents a value of any of the CIM data types      The CIMValue class represents a value of any of the CIM data types.
     (see CIMType.h for a list of valid CIM data types). This class      This class encapsulates a union which holds value of any CIMType.
     encapsulates a union which holds the current value. The class also      A type field indicates the type of the value.
     has a type field indicating the type of that value.  
 */ */
 class PEGASUS_COMMON_LINKAGE CIMValue class PEGASUS_COMMON_LINKAGE CIMValue
 { {
 public: public:
     /** Constructor with no value. This constructor creates an NULL CIMValue      /**
         object set to null and with type CIMType:none and !arraytype.          Constructs a null CIMValue with type Boolean and isArray=false.
     */     */
     CIMValue();     CIMValue();
  
     /** Constructor with only the Type. This constructor creates a NULL CIMValue      /**
         object with the array indicator set as shown and with the          Constructs a null CIMValue object with the specified type and
           array indicator.
           @param type The CIMType of the value
           @param isArray A Boolean indicating whether the value is of array type
           @param arraySize An integer specifying the size of the array, if the
               CIMValue is for an array of a fixed size.  This value is ignored
               if the isArray argument is false.
     */     */
     CIMValue(CIMType type, Boolean isArray, Uint32 arraySize = 0);     CIMValue(CIMType type, Boolean isArray, Uint32 arraySize = 0);
  
     /** Constructor with the Value constructor and a value.  This constructs a      /**
         CIMValue object with the type defined by the value constructor and the value          Constructs a CIMValue with the specified value and inferred type.
         installed          @param x The Boolean value to assign
         <pre>  
         ATTN: Add example  
         </pre>  
     */     */
     CIMValue(Boolean x);     CIMValue(Boolean x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The Uint8 value to assign
       */
     CIMValue(Uint8 x);     CIMValue(Uint8 x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The Sint8 value to assign
       */
     CIMValue(Sint8 x);     CIMValue(Sint8 x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The Uint16 value to assign
       */
     CIMValue(Uint16 x);     CIMValue(Uint16 x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The Sint16 value to assign
       */
     CIMValue(Sint16 x);     CIMValue(Sint16 x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The Uint32 value to assign
       */
     CIMValue(Uint32 x);     CIMValue(Uint32 x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The Sint32 value to assign
       */
     CIMValue(Sint32 x);     CIMValue(Sint32 x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The Uint64 value to assign
       */
     CIMValue(Uint64 x);     CIMValue(Uint64 x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The Sint64 value to assign
       */
     CIMValue(Sint64 x);     CIMValue(Sint64 x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The Real32 value to assign
       */
     CIMValue(Real32 x);     CIMValue(Real32 x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The Real64 value to assign
       */
     CIMValue(Real64 x);     CIMValue(Real64 x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The Char16 value to assign
       */
     CIMValue(const Char16& x);     CIMValue(const Char16& x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The String value to assign
       */
     CIMValue(const String& x);     CIMValue(const String& x);
  
     /// Constructor      /**
     CIMValue(const char* x);          Constructs a CIMValue with the specified value and inferred type.
           @param x The CIMDateTime value to assign
     /// Constructor      */
     CIMValue(const CIMDateTime& x);     CIMValue(const CIMDateTime& x);
  
     /// Constructor      /**
     CIMValue(const CIMReference& x);          Constructs a CIMValue with the specified value and inferred type.
           @param x The CIMObjectPath value to assign
       */
       CIMValue(const CIMObjectPath& x);
   
       /**
           Constructs a CIMValue with the specified value and inferred type.
           Note: The CIMObject argument is cloned to prevent subsequent
           modification through the shared representation model.
           @param x The CIMObject value to assign
           @exception UninitializedObjectException If the CIMObject is
               uninitialized.
       */
       CIMValue(const CIMObject& x);
   
       /**
           Constructs a CIMValue with the specified value and inferred type.
           Note: The CIMInstance argument is cloned to prevent subsequent
           modification through the shared representation model.
           @param x The CIMInstance value to assign
           @exception UninitializedObjectException If the CIMInstance is
               uninitialized.
       */
       CIMValue(const CIMInstance& x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The Boolean Array value to assign
       */
     CIMValue(const Array<Boolean>& x);     CIMValue(const Array<Boolean>& x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The Uint8 Array value to assign
       */
     CIMValue(const Array<Uint8>& x);     CIMValue(const Array<Uint8>& x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The Sint8 Array value to assign
       */
     CIMValue(const Array<Sint8>& x);     CIMValue(const Array<Sint8>& x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The Uint16 Array value to assign
       */
     CIMValue(const Array<Uint16>& x);     CIMValue(const Array<Uint16>& x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The Sint16 Array value to assign
       */
     CIMValue(const Array<Sint16>& x);     CIMValue(const Array<Sint16>& x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The Uint32 Array value to assign
       */
     CIMValue(const Array<Uint32>& x);     CIMValue(const Array<Uint32>& x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The Sint32 Array value to assign
       */
     CIMValue(const Array<Sint32>& x);     CIMValue(const Array<Sint32>& x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The Uint64 Array value to assign
       */
     CIMValue(const Array<Uint64>& x);     CIMValue(const Array<Uint64>& x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The Sint64 Array value to assign
       */
     CIMValue(const Array<Sint64>& x);     CIMValue(const Array<Sint64>& x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The Real32 Array value to assign
       */
     CIMValue(const Array<Real32>& x);     CIMValue(const Array<Real32>& x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The Real64 Array value to assign
       */
     CIMValue(const Array<Real64>& x);     CIMValue(const Array<Real64>& x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The Char16 Array value to assign
       */
     CIMValue(const Array<Char16>& x);     CIMValue(const Array<Char16>& x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The String Array value to assign
       */
     CIMValue(const Array<String>& x);     CIMValue(const Array<String>& x);
  
     /// Constructor      /**
           Constructs a CIMValue with the specified value and inferred type.
           @param x The CIMDateTime Array value to assign
       */
     CIMValue(const Array<CIMDateTime>& x);     CIMValue(const Array<CIMDateTime>& x);
  
     /// Constructor      /**
     CIMValue(const Array<CIMReference>& x);          Constructs a CIMValue with the specified value and inferred type.
           @param x The CIMObjectPath Array value to assign
       */
       CIMValue(const Array<CIMObjectPath>& x);
   
       /**
           Constructs a CIMValue with the specified value and inferred type.
           Note: The CIMObjects in the Array argument are cloned to prevent
           subsequent modification through the shared representation model.
           @param x The CIMObject Array value to assign
           @exception UninitializedObjectException If any of the CIMObjects in the
               Array are uninitialized.
       */
       CIMValue(const Array<CIMObject>& x);
   
       /**
           Constructs a CIMValue with the specified value and inferred type.
           Note: The CIMInstances in the Array argument are cloned to prevent
           subsequent modification through the shared representation model.
           @param x The CIMInstance Array value to assign
           @exception UninitializedObjectException If any of the CIMInstances in
               the Array are uninitialized.
       */
       CIMValue(const Array<CIMInstance>& x);
  
     /// Constructor      /**
           Constructs a CIMValue by copying another CIMValue object.
           Note: If the specified CIMValue contains CIMObject or CIMInstance
           objects, they are cloned to prevent subsequent modification through
           the shared representation model.
           @param x The CIMValue object to copy
       */
     CIMValue(const CIMValue& x);     CIMValue(const CIMValue& x);
  
     /// Destructor      /**
           Destructs a CIMValue object.
       */
     ~CIMValue();     ~CIMValue();
  
     /// Operator =      /**
           Assigns the value from a specified CIMValue object.
           Note: If the specified CIMValue contains CIMObject or CIMInstance
           objects, they are cloned to prevent subsequent modification through
           the shared representation model.
           @param x The CIMValue object to copy
           @return A reference to this CIMValue object with the new assignment
       */
     CIMValue& operator=(const CIMValue& x);     CIMValue& operator=(const CIMValue& x);
  
     /** assign - The method to assign one CIMValue object to another CIMValue      /**
     object.          Assigns the value from a specified CIMValue object.
           Note: If the specified CIMValue contains CIMObject or CIMInstance
           objects, they are cloned to prevent subsequent modification through
           the shared representation model.
           @param x The CIMValue object to copy
     */     */
     void assign(const CIMValue& x);     void assign(const CIMValue& x);
  
     /** clear - Clears the attributes and value of the CIMValue object.      /**
     <pre>          Resets to a null value with type Boolean and isArray=false.
     ATTNDOC:  
     </pre>  
     */     */
     void clear();     void clear();
  
     /** typeCompatible - Compares the types of two CIMvalues. This      /**
         compares the type field and the array indicators.          Compares the type and isArray attributes with a specified CIMValue.
         @return true if both are of the same type and both are either arrays          @param x The CIMValue object with which to compare
         or not. Else returns false.          @return A Boolean indicating whether the CIMValue objects have the same
         <pre>              type and isArray attribute value.
             CIMValue a(Boolean(true);  
             CIMValue b = a;  
             if b.typeCompatible(a)  
                 ...  
         </pre>  
     */     */
     Boolean typeCompatible(const CIMValue& x) const;     Boolean typeCompatible(const CIMValue& x) const;
  
     /** isArray - Determines if the value is an array      /**
         @return TRUE if the value is an array          Indicates whether the value is an array.
           @return A Boolean indicating whether the value is an array.
     */     */
     Boolean isArray() const;     Boolean isArray() const;
  
     /** Returns whether the CIMvalue object is Null.      /**
         Null is the specific condition where no value has          Indicates whether the value is null.  A null CIMValue has a type, but
         yet been set into the value.          no value can be retrieved from it.
         If a CIMValue object is Null, any get on that object          @return A Boolean indicating whether the value is null.
         will create an exception.  
         @return Returns True if the CIMValue object is Null  
     */     */
     Boolean isNull() const;     Boolean isNull() const;
  
     /** getArraySize = Returns the size of an Array CIMValue      /**
         @return The number of entries in the array          Gets the fixed array size of a CIMValue.  This value is undefined for
           non-array values.  A value of 0 is given for variable size arrays.
           @return An integer indicating the array size.
     */     */
     Uint32 getArraySize() const;     Uint32 getArraySize() const;
  
     /** getType - Gets the CIMType attribute for the CIMValue.      /**
         The CIMType is defined in ATTN:          Gets the value type.
         @return Returns the CIMType value          @return A CIMType indicating the type of the value.
     */     */
     CIMType getType() const;     CIMType getType() const;
  
     /** setNullValue - Sets the CIMType, the Array indicator and if it is      /**
         the arraytype, the Arraysize of a CIMValue and sets the isNull          Sets the value to null with the specified type and array indicator.
         Attribute.  This function is used to set up CIMValues an NULL but          @param type The CIMType of the value
         with valid CIMType and array characteristics (ex. when update from          @param isArray A Boolean indicating whether the value is of array type
         XML)          @param arraySize An integer specifying the size of the array, if the
         @param type - The CIMType for this CIMValue              CIMValue is for an array of a fixed size.  This value is ignored
         @param isArray - Boolean indicating whether this is an array CIMValue              if the isArray argument is false.
         @param arraySize (optional) Uint32 parameter indicating the array  
         size  
         @return void  
         <pre>  
             CIMValue value;                   // Create a CIMValue object  
             value.setNullValue(CIMType::BOOLEAN, false);  // Set it  
         </pre>  
     */     */
     void setNullValue(CIMType type, Boolean isArray, Uint32 arraySize = 0);     void setNullValue(CIMType type, Boolean isArray, Uint32 arraySize = 0);
  
     /** set - Sets the type, Array attribute and puts the value provided      /**
         into the value of the target CIMValue. This function sets the          Sets the CIMValue to the specified value and inferred type.
         CIMValue to nonNull also. The result is a complete CIMValue object          @param x The Boolean value to assign
         All of the CIMTypes defined in ATTN: and the Array types defined in  
         ATTN: may be set.  
         @param x Typed value (ex. Boolean(true).  
         @return void  
         <pre>  
             CIMValue x;  
             x.set(Uint16(9));  
         </pre>  
     */     */
     void set(Boolean x);     void set(Boolean x);
  
     /// Set      /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The Uint8 value to assign
       */
     void set(Uint8 x);     void set(Uint8 x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The Sint8 value to assign
       */
     void set(Sint8 x);     void set(Sint8 x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The Uint16 value to assign
       */
     void set(Uint16 x);     void set(Uint16 x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The Sint16 value to assign
       */
     void set(Sint16 x);     void set(Sint16 x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The Uint32 value to assign
       */
     void set(Uint32 x);     void set(Uint32 x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The Sint32 value to assign
       */
     void set(Sint32 x);     void set(Sint32 x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The Uint64 value to assign
       */
     void set(Uint64 x);     void set(Uint64 x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The Sint64 value to assign
       */
     void set(Sint64 x);     void set(Sint64 x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The Real32 value to assign
       */
     void set(Real32 x);     void set(Real32 x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The Real64 value to assign
       */
     void set(Real64 x);     void set(Real64 x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The Char16 value to assign
       */
     void set(const Char16& x);     void set(const Char16& x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The String value to assign
       */
     void set(const String& x);     void set(const String& x);
     ///  
     void set(const char* x);      /**
     ///          Sets the CIMValue to the specified value and inferred type.
           @param x The CIMDateTime value to assign
       */
     void set(const CIMDateTime& x);     void set(const CIMDateTime& x);
     ///  
     void set(const CIMReference& x);      /**
     ///          Sets the CIMValue to the specified value and inferred type.
           @param x The CIMObjectPath value to assign
       */
       void set(const CIMObjectPath& x);
   
       /**
           Sets the CIMValue to the specified value and inferred type.
           Note: The CIMObject argument is cloned to prevent subsequent
           modification through the shared representation model.
           @param x The CIMObject value to assign
           @exception UninitializedObjectException If the CIMObject is
               uninitialized.
       */
       void set(const CIMObject& x);
   
       /**
           Sets the CIMValue to the specified value and inferred type.
           Note: The CIMInstance argument is cloned to prevent subsequent
           modification through the shared representation model.
           @param x The CIMInstance value to assign
           @exception UninitializedObjectException If the CIMInstance is
               uninitialized.
       */
       void set(const CIMInstance& x);
   
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The Boolean Array value to assign
       */
     void set(const Array<Boolean>& x);     void set(const Array<Boolean>& x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The Uint8 Array value to assign
       */
     void set(const Array<Uint8>& x);     void set(const Array<Uint8>& x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The Sint8 Array value to assign
       */
     void set(const Array<Sint8>& x);     void set(const Array<Sint8>& x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The Uint16 Array value to assign
       */
     void set(const Array<Uint16>& x);     void set(const Array<Uint16>& x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The Sint16 Array value to assign
       */
     void set(const Array<Sint16>& x);     void set(const Array<Sint16>& x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The Uint32 Array value to assign
       */
     void set(const Array<Uint32>& x);     void set(const Array<Uint32>& x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The Sint32 Array value to assign
       */
     void set(const Array<Sint32>& x);     void set(const Array<Sint32>& x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The Uint64 Array value to assign
       */
     void set(const Array<Uint64>& x);     void set(const Array<Uint64>& x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The Sint64 Array value to assign
       */
     void set(const Array<Sint64>& x);     void set(const Array<Sint64>& x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The Real32 Array value to assign
       */
     void set(const Array<Real32>& x);     void set(const Array<Real32>& x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The Real64 Array value to assign
       */
     void set(const Array<Real64>& x);     void set(const Array<Real64>& x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The Char16 Array value to assign
       */
     void set(const Array<Char16>& x);     void set(const Array<Char16>& x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The String Array value to assign
       */
     void set(const Array<String>& x);     void set(const Array<String>& x);
     ///  
       /**
           Sets the CIMValue to the specified value and inferred type.
           @param x The CIMDateTime Array value to assign
       */
     void set(const Array<CIMDateTime>& x);     void set(const Array<CIMDateTime>& x);
     ///  
     void set(const Array<CIMReference>& x);  
  
     /** get - Gets the value of a CIMValue      /**
         @param Variable in which we return the value:          Sets the CIMValue to the specified value and inferred type.
         @return void          @param x The CIMObjectPath Array value to assign
       */
       void set(const Array<CIMObjectPath>& x);
   
       /**
           Sets the CIMValue to the specified value and inferred type.
           Note: The CIMObjects in the Array argument are cloned to prevent
           subsequent modification through the shared representation model.
           @param x The CIMObject Array value to assign
           @exception UninitializedObjectException If any of the CIMObjects in the
               Array are uninitialized.
       */
       void set(const Array<CIMObject>& x);
   
       /**
           Sets the CIMValue to the specified value and inferred type.
           Note: The CIMInstances in the Array argument are cloned to prevent
           subsequent modification through the shared representation model.
           @param x The CIMInstance Array value to assign
           @exception UninitializedObjectException If any of the CIMInstances in
               the Array are uninitialized.
       */
       void set(const Array<CIMInstance>& x);
   
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
                 <pre>                 <pre>
                 Uint32 v;              // get with complete checking on type and nullness
                 CIMValue value(CIMValue::UINT32, UINT32(99));              Boolean v;
               CIMValue value = property.getValue();
               if ((value.getType() == CIMTYPE_BOOLEAN) && (!value.isNull()))
                 value.get(v);                 value.get(v);
               or
               // Set the value from property into v if the value is
               // of Boolean type and !isNull(). If type incorrect, generates
               // an exception.  If CIMValue is null, leaves v false. Else
               // sets Boolean value from property into v.
               Boolean v = false;
               property.getValue().get(v);
                 </pre>                 </pre>
           @param x Output Boolean into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
     */     */
     void get(Boolean& x) const;     void get(Boolean& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
   
           @param x Output Uint8 into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Uint8& x) const;     void get(Uint8& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output Sint8 into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Sint8& x) const;     void get(Sint8& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output Uint16 into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Uint16& x) const;     void get(Uint16& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output Sint16 into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Sint16& x) const;     void get(Sint16& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           <pre>
               Uint32 v;
               CIMValue value = property.getValue();
               if ((value.getType() == CIMTYPE_SINT32) && (!value.isNull()))
                   value.get(v);
           </pre>
           @param x Output Uint32 into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Uint32& x) const;     void get(Uint32& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output Sint32 into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Sint32& x) const;     void get(Sint32& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output Uint64 into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Uint64& x) const;     void get(Uint64& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output Sint64 into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Sint64& x) const;     void get(Sint64& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output Real32 into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Real32& x) const;     void get(Real32& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output Real64 into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Real64& x) const;     void get(Real64& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output Char16 into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Char16& x) const;     void get(Char16& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output String into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(String& x) const;     void get(String& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output CIMDateTime into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(CIMDateTime& x) const;     void get(CIMDateTime& x) const;
     ///  
     void get(CIMReference& x) const;      /**
     ///          Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).).
           @param x Output CIMObjectPath into which the value is stored if
               CIMValue state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
       void get(CIMObjectPath& x) const;
   
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output CIMObject into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
       void get(CIMObject& x) const;
   
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output CIMInstance into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
       void get(CIMInstance& x) const;
   
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output Boolean Array into which the value is stored if
               CIMValue state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Array<Boolean>& x) const;     void get(Array<Boolean>& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output Uint8 Array into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Array<Uint8>& x) const;     void get(Array<Uint8>& x) const;
     //////  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output Sint8 Array into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Array<Sint8>& x) const;     void get(Array<Sint8>& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).).
           @param x Output Uint16 Array into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Array<Uint16>& x) const;     void get(Array<Uint16>& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output Sint16 Array into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Array<Sint16>& x) const;     void get(Array<Sint16>& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output Uint32 Array into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Array<Uint32>& x) const;     void get(Array<Uint32>& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output Sint32 Array into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Array<Sint32>& x) const;     void get(Array<Sint32>& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output Uint64 Array into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Array<Uint64>& x) const;     void get(Array<Uint64>& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output Sint64 Array into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Array<Sint64>& x) const;     void get(Array<Sint64>& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output Real32 Array into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Array<Real32>& x) const;     void get(Array<Real32>& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output Real64 Array into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Array<Real64>& x) const;     void get(Array<Real64>& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output Char16 Array into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Array<Char16>& x) const;     void get(Array<Char16>& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output String Array into which the value is stored if CIMValue
               state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Array<String>& x) const;     void get(Array<String>& x) const;
     ///  
       /**
           Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output CIMDateTime Array into which the value is stored if
               CIMValue state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
     void get(Array<CIMDateTime>& x) const;     void get(Array<CIMDateTime>& x) const;
     ///  
     void get(Array<CIMReference>& x) const;  
  
     /** Makes a deep copy (clone) of the given object. */      /**
     CIMValue clone() const;          Gets the value of the CIMValue.  The caller should first verify that
           the value is not null and may verify type to avoid the possibility of
           the TypeMismatchException.  The output parameter x is NOT
           updated if the value is null (isNull() == true).
           @param x Output CIMObjectPath Array into which the value is stored if
               CIMValue state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
       void get(Array<CIMObjectPath>& x) const;
  
     /** toMof - Converts a CIMValueObject to Mof.      /**
         @out Sint8 Array to hold the Mof representation          Gets the value of the CIMValue.  The caller should first verify that
         @return Returns the Mof representation of the CIMValue          the value is not null and may verify type to avoid the possibility of
         object in the input parameter out.          the TypeMismatchException.  The output parameter x is NOT
     */          updated if the value is null (isNull() == true).
     void toMof(Array<Sint8>& out) const;          @param x Output CIMObject Array into which the value is stored if
               CIMValue state is not null.
     /** toString - Converts the CIMvalue to a string.  Should only be          @exception TypeMismatchException If the value type does not match the
             used for output purposes.  To get an actual String value, use              output parameter.
             get(String &).      */
         @return - String output for CIMValue.      void get(Array<CIMObject>& x) const;
         @exception - Throws exception CIMValueInvalidType if the CIMValue  
             has an invalid type. Normally this is a Pegasus internal error.      /**
         <PRE>          Gets the value of the CIMValue.  The caller should first verify that
         Example:          the value is not null and may verify type to avoid the possibility of
             String test;          the TypeMismatchException.  The output parameter x is NOT
             CIMValue value(Boolean(true));          updated if the value is null (isNull() == true).
             test = value.toString();  // puts "TRUE" into test          @param x Output CIMInstance Array into which the value is stored if
         </PRE>              CIMValue state is not null.
           @exception TypeMismatchException If the value type does not match the
               output parameter.
       */
       void get(Array<CIMInstance>& x) const;
   
       /**
           Compares with another CIMValue object for equality.
           @param x The CIMValue with which to compare
           @return A Boolean indicating whether they are identical in type,
               array attributes, and value.
       */
       Boolean equal(const CIMValue& x) const;
   
       /**
           Converts a CIMValue to a String.  This method should only be
           used for diagnostic output purposes.  To get an actual String value,
           use get(String &).
           @return A String representation of the value.
         */         */
     String toString() const;     String toString() const;
  
   #ifdef PEGASUS_USE_DEPRECATED_INTERFACES
       /**
           <I><B>Deprecated Interface</B></I><BR>
           Constructs a CIMValue with the specified value and type Sint8.
           (Note: This constructor exists solely to support binary compatibility
           with a previous definition of the Sint8 type.)
           @param x The Sint8 value to assign
       */
       CIMValue(char x);
   
       /**
           <I><B>Deprecated Interface</B></I><BR>
           Constructs a CIMValue with the specified value and type Sint8 Array.
           (Note: This constructor exists solely to support binary compatibility
           with a previous definition of the Sint8 type.)
           @param x The Sint8 Array value to assign
       */
       CIMValue(const Array<char>& x);
   
       /**
           <I><B>Deprecated Interface</B></I><BR>
           Sets the CIMValue to the specified value and type Sint8.
           (Note: This method exists solely to support binary compatibility with
           a previous definition of the Sint8 type.)
           @param x The value to assign
       */
       void set(char x);
   
       /**
           <I><B>Deprecated Interface</B></I><BR>
           Sets the CIMValue to the specified value and type Sint8 Array.
           (Note: This method exists solely to support binary compatibility with
           a previous definition of the Sint8 type.)
           @param x The Array value to assign
       */
       void set(const Array<char>& x);
   
       /**
           <I><B>Deprecated Interface</B></I><BR>
           Gets the Sint8 value of the CIMValue.  The caller should first verify
           that the value is of the expected type and is not null.  The output
           parameter x is not updated if the value is null (isNull() == true).
           (Note: This method exists solely to support binary compatibility with
           a previous definition of the Sint8 type.)
           @param x Output variable into which the value is stored.
       */
       void get(char& x) const;
   
       /**
           <I><B>Deprecated Interface</B></I><BR>
           Gets the Sint8 Array value of the CIMValue.  The caller should first
           verify that the value is of the expected type and is not null.  The
           output parameter x is not updated if the value is null
           (isNull() == true).
           (Note: This method exists solely to support binary compatibility with
           a previous definition of the Sint8 type.)
           @param x Output Array variable into which the value is stored.
       */
       void get(Array<char>& x) const;
   #endif
   
 private: private:
  
       void _get(const String*& data, Uint32& size) const;
   
     CIMValueRep* _rep;     CIMValueRep* _rep;
  
     friend class CIMMethodRep;     friend class CIMMethodRep;
Line 414 
Line 1111 
     friend class CIMPropertyRep;     friend class CIMPropertyRep;
     friend class CIMQualifierRep;     friend class CIMQualifierRep;
     friend class CIMQualifierDeclRep;     friend class CIMQualifierDeclRep;
     PEGASUS_COMMON_LINKAGE friend Boolean operator==(      friend class BinaryStreamer;
         const CIMValue& x,      friend class XmlWriter;
         const CIMValue& y);      friend class SCMOClass;
       friend class SCMOInstance;
 }; };
  
 /** operator == compares two CIMValue objects for equality.  /**
         @param x - First CIMvalue to compare      Compares two CIMValue objects for equality.
         @parm y - Second CIMValue to compare      @param x First CIMValue to compare
         @return True if they are identical in type, attribute and value.      @param y Second CIMValue to compare
       @return A Boolean indicating whether they are identical in type, array
           attributes, and value.
 */ */
 PEGASUS_COMMON_LINKAGE Boolean operator==(const CIMValue& x, const CIMValue& y); PEGASUS_COMMON_LINKAGE Boolean operator==(const CIMValue& x, const CIMValue& y);
  
 /** operator != compares two CIMValue objects for nonequality  /**
       Compares two CIMValue objects for inequality.
       @param x First CIMValue to compare
       @param y Second CIMValue to compare
       @return A Boolean indicating whether they are NOT identical in type, array
           attributes, and value.
 */ */
 PEGASUS_COMMON_LINKAGE Boolean operator!=(const CIMValue& x, const CIMValue& y); PEGASUS_COMMON_LINKAGE Boolean operator!=(const CIMValue& x, const CIMValue& y);
  
 #define PEGASUS_ARRAY_T CIMValue #define PEGASUS_ARRAY_T CIMValue
 # include "ArrayInter.h"  # include <Pegasus/Common/ArrayInter.h>
 #undef PEGASUS_ARRAY_T #undef PEGASUS_ARRAY_T
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
  
   #ifdef PEGASUS_INTERNALONLY
   #include <Pegasus/Common/CIMValueInline.h>
   #endif
   
 #endif /* Pegasus_Value_h */ #endif /* Pegasus_Value_h */

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