cimvalue.h

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

            x.set(Uint16(9));
        </pre>
        @exception UninitializedObjectException If the given type is CIMObject, 
        and the input CIMObject parameter is uninitialized or at least one entry 
        in the Array of CIMObjects is uninitialized.
        Note: If the input type is CIMObject, it/they will be cloned before
        putting it into the value of the target CIMValue. This is because 
        CIMObjects use a shared representation model, but we don't want
        CIMObjects inside a CIMValue to be altered by other external changes.
    */    
    void set(Boolean x);

    /// 
    void set(Uint8 x);
    ///
    void set(Sint8 x);
    ///
    void set(Uint16 x);
    ///
    void set(Sint16 x);
    ///
    void set(Uint32 x);
    ///
    void set(Sint32 x);
    ///
    void set(Uint64 x);
    ///
    void set(Sint64 x);
    ///
    void set(Real32 x);
    ///
    void set(Real64 x);
    ///
    void set(const Char16& x);
    ///
    void set(const String& x);
    ///
    void set(const CIMDateTime& x);
    ///
    void set(const CIMObjectPath& x);
    ///
    void set(const CIMObject& x);
    ///
    void set(const Array<Boolean>& x);
    ///
    void set(const Array<Uint8>& x);
    ///
    void set(const Array<Sint8>& x);
    ///
    void set(const Array<Uint16>& x);
    ///
    void set(const Array<Sint16>& x);
    ///
    void set(const Array<Uint32>& x);
    ///
    void set(const Array<Sint32>& x);
    ///
    void set(const Array<Uint64>& x);
    ///
    void set(const Array<Sint64>& x);
    ///
    void set(const Array<Real32>& x);
    ///
    void set(const Array<Real64>& x);
    ///
    void set(const Array<Char16>& x);
    ///
    void set(const Array<String>& x);
    ///
    void set(const Array<CIMDateTime>& x);
    ///
    void set(const Array<CIMObjectPath>& x);
    ///
    void set(const Array<CIMObject>& x);

    /** Gets the value of a CIMValue.
        Note: Before using get, the caller should use getType () and isNull ()
        to ensure that the value is not null, and is of the correct type.
     
        The behavior of get is undefined when the value is null.

        @param Variable in which to return the value.
        @exception TypeMismatchException If the CIMValue type is not compatible
                   with the type of the output parameter.
        <pre>
            Uint32 v;
            CIMValue value(CIMValue::UINT32, UINT32(99));
            value.get(v);
        </pre>

        <pre>
            Uint32 v;
            CIMValue value = property.getValue ();
            if ((value.getType () == CIMTYPE_UINT32) && (!value.isNull ()))
                value.get (v);
        </pre>
    */
    void get(Boolean& x) const;
    ///
    void get(Uint8& x) const;
    ///
    void get(Sint8& x) const;
    ///
    void get(Uint16& x) const;
    ///
    void get(Sint16& x) const;
    ///
    void get(Uint32& x) const;
    ///
    void get(Sint32& x) const;
    ///
    void get(Uint64& x) const;
    ///
    void get(Sint64& x) const;
    ///
    void get(Real32& x) const;
    ///
    void get(Real64& x) const;
    ///
    void get(Char16& x) const;
    ///
    void get(String& x) const;
    ///
    void get(CIMDateTime& x) const;
    ///
    void get(CIMObjectPath& x) const;
    ///
    void get(CIMObject& x) const;
    ///
    void get(Array<Boolean>& x) const;
    ///
    void get(Array<Uint8>& x) const;
    ///
    void get(Array<Sint8>& x) const;
    ///
    void get(Array<Uint16>& x) const;
    ///
    void get(Array<Sint16>& x) const;
    ///
    void get(Array<Uint32>& x) const;
    ///
    void get(Array<Sint32>& x) const;
    ///
    void get(Array<Uint64>& x) const;
    ///
    void get(Array<Sint64>& x) const;
    ///
    void get(Array<Real32>& x) const;
    ///
    void get(Array<Real64>& x) const;
    ///
    void get(Array<Char16>& x) const;
    ///
    void get(Array<String>& x) const;
    ///
    void get(Array<CIMDateTime>& x) const; 
    ///
    void get(Array<CIMObjectPath>& x) const; 
    ///
    void get(Array<CIMObject>& x) const; 

    /** Compares with another CIMValue object for equality.
        @param x - CIMValue to compare with.
        @return true if they are identical in type, attribute and value,
        false otherwise.
    */
    Boolean equal(const CIMValue& x) const;

    /** Converts the CIMvalue to a string.  Should only be
        used for output purposes.  To get an actual String value, use
        get(String &).
        @return  String output for CIMValue.
        <PRE>
            String test;
            CIMValue value(Boolean(true));
            test = value.toString();  // puts "TRUE" into test
        </PRE>
    */
    String toString() const;

#ifdef PEGASUS_USE_DEPRECATED_INTERFACES
    /**
        <I><B>Deprecated Interface</B></I><BR>
        Constructor.  (Note: This constructor exists solely to support binary
        compatibility with a previous definition of the Sint8 type.)
    */
    CIMValue(char x);

    /**
        <I><B>Deprecated Interface</B></I><BR>
        Constructor.  (Note: This constructor exists solely to support binary
        compatibility with a previous definition of the Sint8 type.)
    */
    CIMValue(const Array<char>& x);

    /**
        <I><B>Deprecated Interface</B></I><BR>
        Sets an Sint8 value.  (Note: This method exists solely to support
        binary compatibility with a previous definition of the Sint8 type.)
    */
    void set(char x);

    /**
        <I><B>Deprecated Interface</B></I><BR>
        Sets an Sint8 array value.  (Note: This method exists solely to support
        binary compatibility with a previous definition of the Sint8 type.)
    */
    void set(const Array<char>& x);

    /**
        <I><B>Deprecated Interface</B></I><BR>
        Gets an Sint8 value.  (Note: This method exists solely to support
        binary compatibility with a previous definition of the Sint8 type.)
    */
    void get(char& x) const;

    /**
        <I><B>Deprecated Interface</B></I><BR>
        Gets an Sint8 array value.  (Note: This method exists solely to support
        binary compatibility with a previous definition of the Sint8 type.)
    */
    void get(Array<char>& x) const;
#endif

private:

    void _get(const String*& data, Uint32& size) const;

    CIMValueRep* _rep;

    friend class CIMMethodRep;
    friend class CIMParameterRep;
    friend class CIMPropertyRep;
    friend class CIMQualifierRep;
    friend class CIMQualifierDeclRep;
    friend class BinaryStreamer;
    friend class XmlWriter;
};

/** operator == compares two CIMValue objects for equality.
    @param x - First CIMValue to compare
    @param y - Second CIMValue to compare
    @return true if they are identical in type, attribute and value,
    false otherwise.
*/
PEGASUS_COMMON_LINKAGE Boolean operator==(const CIMValue& x, const CIMValue& y);

/** operator != compares two CIMValue objects for inequality.
    @param x - First CIMValue to compare
    @param y - Second CIMValue to compare
    @return true if they are NOT identical in type, attribute or value,
    false otherwise.
*/
PEGASUS_COMMON_LINKAGE Boolean operator!=(const CIMValue& x, const CIMValue& y);

#define PEGASUS_ARRAY_T CIMValue
# include <Pegasus/Common/ArrayInter.h>
#undef PEGASUS_ARRAY_T

PEGASUS_NAMESPACE_END

#ifdef PEGASUS_INTERNALONLY
#include <Pegasus/Common/CIMValueInline.h>
#endif

#endif /* Pegasus_Value_h */