Return to CIMValue.h CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

HP-RK API Review: Remove InvalidTypeException definition; replace with use of TypeMismatchException.

//%/////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,
// The Open Group, Tivoli Systems
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. 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.
//
//==============================================================================
//
// Author: Mike Brasher (mbrasher@bmc.com)
//
// Modified By: Karl schopmeyer (k.schopmeyer@opengroup.org)
//              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
//              Carol Ann Krug Graves, Hewlett-Packard Company
//                (carolann_graves@hp.com)
//
//%/////////////////////////////////////////////////////////////////////////////

#ifndef Pegasus_Value_h
#define Pegasus_Value_h

#include <Pegasus/Common/String.h>
#include <Pegasus/Common/Config.h>
#include <Pegasus/Common/CIMType.h>
#include <Pegasus/Common/CIMObjectPath.h>
#include <Pegasus/Common/CIMDateTime.h>
#include <Pegasus/Common/Exception.h>
#include <Pegasus/Common/Array.h>
#include <Pegasus/Common/Linkage.h>

PEGASUS_NAMESPACE_BEGIN

class CIMValueRep;

/**
    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
    encapsulates a union which holds the current value. The class also
    has a type field indicating the type of that value.
*/
class PEGASUS_COMMON_LINKAGE CIMValue
{
public:
    /** Constructor with no value. This constructor creates an NULL CIMValue
        object set to null and with type CIMType:none and !arraytype.
    */
    CIMValue();

    /** Constructor that creates a NULL CIMValue object with the type and
        array indicator set as specified.
        @exception TypeMismatchException If the given type is not valid for a
        CIMValue object.
    */
    CIMValue(CIMType type, Boolean isArray, Uint32 arraySize = 0);

    // ATTN This needs an example
    /** Constructor with the Value constructor and a value.
        This constructs a
        CIMValue object with the type defined by the value constructor
        and the value
        installed
    */
    CIMValue(Boolean x);

    /// Constructor
    CIMValue(Uint8 x);

    /// Constructor
    CIMValue(Sint8 x);

    /// Constructor
    CIMValue(Uint16 x);

    /// Constructor
    CIMValue(Sint16 x);

    /// Constructor
    CIMValue(Uint32 x);

    /// Constructor
    CIMValue(Sint32 x);

    /// Constructor
    CIMValue(Uint64 x);

    /// Constructor
    CIMValue(Sint64 x);

    /// Constructor
    CIMValue(Real32 x);

    /// Constructor
    CIMValue(Real64 x);

    /// Constructor
    CIMValue(const Char16& x);

    /// Constructor
    CIMValue(const String& x);

    /// Constructor
    CIMValue(const CIMDateTime& x);

    /// Constructor
    CIMValue(const CIMObjectPath& x);

    /// Constructor
    CIMValue(const Array<Boolean>& x);

    /// Constructor
    CIMValue(const Array<Uint8>& x);

    /// Constructor
    CIMValue(const Array<Sint8>& x);

    /// Constructor
    CIMValue(const Array<Uint16>& x);

    /// Constructor
    CIMValue(const Array<Sint16>& x);

    /// Constructor
    CIMValue(const Array<Uint32>& x);

    /// Constructor
    CIMValue(const Array<Sint32>& x);

    /// Constructor
    CIMValue(const Array<Uint64>& x);

    /// Constructor
    CIMValue(const Array<Sint64>& x);

    /// Constructor
    CIMValue(const Array<Real32>& x);

    /// Constructor
    CIMValue(const Array<Real64>& x);

    /// Constructor
    CIMValue(const Array<Char16>& x);

    /// Constructor
    CIMValue(const Array<String>& x);

    /// Constructor
    CIMValue(const Array<CIMDateTime>& x);

    /// Constructor
    CIMValue(const Array<CIMObjectPath>& x);

    /// Constructor
    CIMValue(const CIMValue& x);

    /// Destructor
    ~CIMValue();

    /// Operator =
    CIMValue& operator=(const CIMValue& x);

    /** assign - The method to assign one CIMValue object to another CIMValue
    object.
    */
    void assign(const CIMValue& x);

    /** clear - Clears the attributes and value of the CIMValue object.
    */
    void clear();

    /** typeCompatible - Compares the types of two CIMValues. This
        compares the type field and the array indicators.
        @return true if both are of the same type and both are either arrays
        or not. Else returns false.
        <pre>
            CIMValue a(Boolean(true);
            CIMValue b = a;
            if b.typeCompatible(a)
                ...
        </pre>
    */
    Boolean typeCompatible(const CIMValue& x) const;

    /** isArray - Determines if the value is an array
        @return TRUE if the value is an array
    */
    Boolean isArray() const;

    /** Returns whether the CIMvalue object is Null. 
        Null is the specific condition where no value has
        yet been set into the value.
        If a CIMValue object is Null, any get on that object
        will create an exception.
        @return Returns True if the CIMValue object is Null
    */
    Boolean isNull() const;

    /** getArraySize = Returns the size of an Array CIMValue
        @return The number of entries in the array
    */
    Uint32 getArraySize() const;

    /** getType - Gets the CIMType attribute for the CIMValue.
        @return the CIMType value
    */
    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
        Attribute.  This function is used to set up CIMValues an NULL but
        with valid CIMType and array characteristics (ex. when update from
        XML)
        @param type - The CIMType for this CIMValue
        @param isArray - Boolean indicating whether this is an array CIMValue
        @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);

    //  All of the CIMTypes defined in ATTN: and the Array types defined in
    //  ATTN: may be set.
    /** set - Sets the type, Array attribute and puts the value provided
        into the value of the target CIMValue. This function sets the
        CIMValue to nonNull also. The result is a complete CIMValue object
        @param x Typed value (ex. Boolean(true).
        @return void
        <pre>
            CIMValue x;
            x.set(Uint16(9));
        </pre>
    */    
    void set(Boolean x);

    /// Set
    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 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);

    /** get - 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.
        If the CIMValue is null, the output parameter is not updated.

        @param Variable in which we 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(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; 

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

    /** toString - 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>
        Example:
            String test;
            CIMValue value(Boolean(true));
            test = value.toString();  // puts "TRUE" into test
        </PRE>
        */
    String toString() const;

private:

    // ATTN-RK-P2-20020719: For debugging only; remove before API release.
    // Use CIMValue(const String&) instead.
    PEGASUS_EXPLICIT CIMValue(const char* x) {}

    CIMValueRep* _rep;

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

/** 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.
*/
PEGASUS_COMMON_LINKAGE Boolean operator==(const CIMValue& x, const CIMValue& y);

/** operator != compares two CIMValue objects for inequality
*/
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

#endif /* Pegasus_Value_h */