pegasus/src/Pegasus/Common/CIMValue.h - diff

Return to CIMValue.h CVS log

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

Diff for /pegasus/src/Pegasus/Common/CIMValue.h between version 1.17 and 1.48

version 1.17, 2002/03/24 13:33:07

version 1.48, 2005/11/07 23:12:52

Line 1

//%/////////////////////////////////////////////////////////////////////////////

//%2005////////////////////////////////////////////////////////////////////////

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

// IBM Corp.; EMC Corporation, The Open Group.

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to

Line 20

Line 27

//==============================================================================

// Author: Mike Brasher (mbrasher@bmc.com)

// Modified By: Karl schopmeyer (k.schopmeyer@opengroup.org)

// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)

//%/////////////////////////////////////////////////////////////////////////////

#ifndef Pegasus_Value_h

Line 33

Line 35

#include <Pegasus/Common/String.h>

#include <Pegasus/Common/Config.h>

#include <Pegasus/Common/CIMType.h>

#include <Pegasus/Common/CIMObjectPath.h>

#include <Pegasus/Common/CIMObject.h>

#include <Pegasus/Common/CIMDateTime.h>

#include <Pegasus/Common/Union.h>

#include <Pegasus/Common/Exception.h>

#include <Pegasus/Common/Array.h>

#include <Pegasus/Common/Linkage.h>

PEGASUS_NAMESPACE_BEGIN

class CIMValueRep;

class CIMObject;

/**

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

(see \Ref{CIMType} 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

/** Constructor - Creates an NULL CIMValue object set to null and

object set to null and with type CIMType:none and !arraytype.

with type CIMType:none and !arraytype.

CIMValue();

/** Constructor with only the Type. This constructor creates a NULL CIMValue

/** Constructor - Creates a NULL CIMValue object with the type and

object with the array indicator set as shown and with the

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

/** Constructor with the Value constructor and a value. This constructs a

/// Constructor.

CIMValue object with the type defined by the value constructor and the value

CIMValue(Boolean x);

installed

<pre>

ATTN: Add example

</pre>

CIMValue(Boolean x) { _init(); set(x); }

/// Constructor

/// Constructor.

CIMValue(Uint8 x) { _init(); set(x); }

CIMValue(Uint8 x);

/// Constructor

/// Constructor.

CIMValue(Sint8 x) { _init(); set(x); }

CIMValue(Sint8 x);

/// Constructor

/// Constructor.

CIMValue(Uint16 x) { _init(); set(x); }

CIMValue(Uint16 x);

/// Constructor

/// Constructor.

CIMValue(Sint16 x) { _init(); set(x); }

CIMValue(Sint16 x);

/// Constructor

/// Constructor.

CIMValue(Uint32 x) { _init(); set(x); }

CIMValue(Uint32 x);

/// Constructor

/// Constructor.

CIMValue(Sint32 x) { _init(); set(x); }

CIMValue(Sint32 x);

/// Constructor

/// Constructor.

CIMValue(Uint64 x) { _init(); set(x); }

CIMValue(Uint64 x);

/// Constructor

/// Constructor.

CIMValue(Sint64 x) { _init(); set(x); }

CIMValue(Sint64 x);

/// Constructor

/// Constructor.

CIMValue(Real32 x) { _init(); set(x); }

CIMValue(Real32 x);

/// Constructor

/// Constructor.

CIMValue(Real64 x) { _init(); set(x); }

CIMValue(Real64 x);

/// Constructor

/// Constructor.

CIMValue(const Char16& x) { _init(); set(x); }

CIMValue(const Char16& x);

/// Constructor

/// Constructor.

CIMValue(const String& x) { _init(); set(x); }

CIMValue(const String& x);

/// Constructor

/// Constructor.

CIMValue(const char* x) { _init(); set(x); }

CIMValue(const CIMDateTime& x);

/// Constructor

/// Constructor.

CIMValue(const CIMDateTime& x) { _init(); set(x); }

CIMValue(const CIMObjectPath& x);

/// Constructor

/** Constructor.

CIMValue(const CIMReference& x) { _init(); set(x); }

Note: Constructing a CIMValue with an uninitialized CIMObject is not

defined and results in a thrown UninitializedObjectException.

Note: The input CIMObject will be cloned before putting it into the

value of the constructed 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.

CIMValue(const CIMObject& x);

/// Constructor

/// Constructor.

CIMValue(const Array<Boolean>& x) { _init(); set(x); }

CIMValue(const Array<Boolean>& x);

/// Constructor

/// Constructor.

CIMValue(const Array<Uint8>& x) { _init(); set(x); }

CIMValue(const Array<Uint8>& x);

/// Constructor

/// Constructor.

CIMValue(const Array<Sint8>& x) { _init(); set(x); }

CIMValue(const Array<Sint8>& x);

/// Constructor

/// Constructor.

CIMValue(const Array<Uint16>& x) { _init(); set(x); }

CIMValue(const Array<Uint16>& x);

/// Constructor

/// Constructor.

CIMValue(const Array<Sint16>& x) { _init(); set(x); }

CIMValue(const Array<Sint16>& x);

/// Constructor

/// Constructor.

CIMValue(const Array<Uint32>& x) { _init(); set(x); }

CIMValue(const Array<Uint32>& x);

/// Constructor

/// Constructor.

CIMValue(const Array<Sint32>& x) { _init(); set(x); }

CIMValue(const Array<Sint32>& x);

/// Constructor

/// Constructor.

CIMValue(const Array<Uint64>& x) { _init(); set(x); }

CIMValue(const Array<Uint64>& x);

/// Constructor

/// Constructor.

CIMValue(const Array<Sint64>& x) { _init(); set(x); }

CIMValue(const Array<Sint64>& x);

/// Constructor

/// Constructor.

CIMValue(const Array<Real32>& x) { _init(); set(x); }

CIMValue(const Array<Real32>& x);

/// Constructor

/// Constructor.

CIMValue(const Array<Real64>& x) { _init(); set(x); }

CIMValue(const Array<Real64>& x);

/// Constructor

/// Constructor.

CIMValue(const Array<Char16>& x) { _init(); set(x); }

CIMValue(const Array<Char16>& x);

/// Constructor

/// Constructor.

CIMValue(const Array<String>& x) { _init(); set(x); }

CIMValue(const Array<String>& x);

/// Constructor

/// Constructor.

CIMValue(const Array<CIMDateTime>& x) { _init(); set(x); }

CIMValue(const Array<CIMDateTime>& x);

/// Constructor

/// Constructor.

CIMValue(const Array<CIMReference>& x) { _init(); set(x); }

CIMValue(const Array<CIMObjectPath>& x);

/// Constructor

/** Constructor.

Note: Constructing a CIMValue with an uninitialized CIMObject anywhere

in the input array is not defined and results in a thrown

UninitializedObjectException.

Note: Each CIMObject in the input Array will be cloned before putting

the Array into the value of the constructed 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.

CIMValue(const Array<CIMObject>& x);

/** Constructor.

Note: If the input type is CIMObject, it/they will be cloned before

putting it into the value of the constructed 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.

CIMValue(const CIMValue& x);

/// Destructor

/// Destructor.

~CIMValue();

/// Operator =

/** Operator =

CIMValue& operator=(const CIMValue& x)

Note: If the right hand side type is CIMObject, it/they will be cloned

{

before putting it into the value of the target CIMValue. This is because

assign(x); return *this;

CIMObjects use a shared representation model, but we don't want

}

CIMObjects inside a CIMValue to be altered by other external changes.

/** assign - The method to assign one CIMValue object to another CIMValue

CIMValue& operator=(const CIMValue& x);

object.

/** Assigns one CIMValue object to another CIMValue object.

@param x - CIMValue object to be used for assignment.

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 assign(const CIMValue& x);

/** clear - Clears the attributes and value of the CIMValue object.

/** Clears the attributes and value of the CIMValue object.

<pre>

ATTNDOC:

</pre>

void clear();

/** typeCompatible - Compares the types of two CIMvalues. This

/** 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.

or not, false otherwise.

<pre>

CIMValue a(Boolean(true);

CIMValue b = a;

Line 193

Line 222

...

</pre>

Boolean typeCompatible(const CIMValue& x) const

Boolean typeCompatible(const CIMValue& x) const;

{

return _type == x._type && _isArray == x._isArray;

}

/** isArray - Determines if the value is an array

/** Determines if the value is an array.

@return TRUE if the value is an array

@return true if the value is an array, false otherwise.

Boolean isArray() const { return _isArray; }

Boolean isArray() const;

/** Returns whether the CIMvalue object is Null.

/** Determines whether the CIMvalue object is Null.

Null is the specific condition where no value has

yet been set into the value.

yet been set. If a CIMValue object is Null, any get on that

If a CIMValue object is Null, any get on that object

object will create an exception.

will create an exception.

@return true if the CIMValue object is Null, false otherwise.

@return Returns True if the CIMValue object is Null

Boolean isNull() const { return _isNull; }

Boolean isNull() const;

/** getArraySize = Returns the size of an Array CIMValue

/** Gets the size of an Array CIMValue.

@return The number of entries in the array

@return The number of entries in the array.

Uint32 getArraySize() const;

/** getType - Gets the CIMType attribute for the CIMValue.

/** Gets the CIMType attribute for the CIMValue.

The CIMType is defined in ATTN:

@return the CIMType value.

@return Returns the CIMType value

CIMType getType() const

CIMType getType() const;

{

return CIMType(_type);

}

/** setNullvalue - Sets the CIMType, the Array indicator and if it is

/** Sets the CIMValue a NULL, but with valid CIMType and array

the arraytype, the Arraysize of a CIMValue and sets the isNull

characteristics.

Attribute. This function is used to set up CIMValues an NULL but

@param type - CIMType for this CIMValue.

with valid CIMType and array characteristics (ex. when update from

@param isArray - Boolean indicating whether this is an array CIMValue.

XML)

@param arraySize - Optional parameter indicating the array size.

@param type - The CIMType for this CIMValue

@paramisArray - Boolean indicating whether this is an array CIMValue

@param arraySize (optional) Uint32parameter indicating the array

size

@return void

<pre>

CIMValue value; // Create a CIMValue object

CIMValue value;

value.setNullValue(CIMType::BOOLEAN, false); // Set it

value.setNullValue(CIMType::BOOLEAN, false);

</pre>

void setNullValue(CIMType type, Boolean isArray, Uint32 arraySize = 0);

/** set - Sets the type, Array attribute and puts the value provided

/** Sets the type, Array attribute and puts the value provided

into the value of the target CIMValue. This function sets the

into the value of the target CIMValue.

CIMValue to nonNull also. The result is a complete CIMValue object

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>

@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);

/// Set

///

void set(Uint8 x);

///

void set(Sint8 x);

Line 282

Line 300

///

void set(const String& x);

///

void set(const char* x);

///

void set(const CIMDateTime& x);

///

void set(const CIMReference& x);

void set(const CIMObjectPath& x);

///

void set(const CIMObject& x);

///

void set(const Array<Boolean>& x);

///

Line 316

Line 334

///

void set(const Array<CIMDateTime>& x);

///

void set(const Array<CIMReference>& x);

void set(const Array<CIMObjectPath>& x);

///

void set(const Array<CIMObject>& x);

/** get - Gets the value of a CIMValue

/** Gets the value of a CIMValue.

@param Variable in which we return the value:

Note: Before using get, the caller should use getType () and isNull ()

@return void

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;

///

Line 355

Line 388

///

void get(CIMDateTime& x) const;

///

void get(CIMReference& 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;

Line 385

Line 420

///

void get(Array<CIMDateTime>& x) const;

///

void get(Array<CIMReference>& x) const;

void get(Array<CIMObjectPath>& x) const;

///

/** toXML - Converts a CIMValue object to XML. The XML is appended

void get(Array<CIMObject>& x) const;

to the Array provided with the call. Returns the result as an

XML element wrapped in the <VALUE>, <VALUE.ARRAY>, <VALUE.REFERENCE>,

or <VALUE.REFARRAY> tags. If the CIMValue is Null, no element is

returned.

@param out Sint8 Array to hold the XML representation

@param forceTag Boolean parameter that if set forces the XML tags to

be output even if the CIMValue is NULL.

@return Returns the XML representation of the CIMValue

object in the input parameter out.

void toXml(Array<Sint8>& out, Boolean forceTag) const;

/** toXML - Converts a CIMValue object to XML. There is no input

parameter and the result is returned as a String rather

than appended to an 8-bit array as above. Returns the

element as value wrapped in the <VALUE>, <VALUE.ARRAY>,

<VALUE.REFERENCE>, or <VALUE.REFARRAY> tags. If the

CIMValue is Null, no element is returned.

@param forceTag Boolean parameter that if set forces the XML tags to

be output even if the CIMValue is NULL.

@return Returns the XML representation of the CIMValue

object in String form.

String toXml(Boolean forceTag) const;

/** CIMMethod print - Format and print the Value as XML to std output

stream

@param forceTag Boolean parameter that if set forces the XML tags to

be output even if the CIMValue is NULL.

@param o Stream to output to. Defaults to cout.

@return None

<PRE>

Example:

CIMValue value(Boolean(true));

value.print(true); // Prints "true"

</PRE>

void print(Boolean forceTag, PEGASUS_STD(ostream) &o=PEGASUS_STD(cout)) const;

/** toMof - Converts a CIMValueObject to Mof.

/** Compares with another CIMValue object for equality.

@out Sint8 Array to hold the Mof representation

@param x - CIMValue to compare with.

@return Returns the Mof representation of the CIMValue

@return true if they are identical in type, attribute and value,

object in the input parameter out.

false otherwise.

void toMof(Array<Sint8>& out) const;

Boolean equal(const CIMValue& x) const;

/** toString - Converts the CIMvalue to a string. Should only be

/** 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.

@return String output for CIMValue.

@exception - Throws exception CIMValueInvalidType if the CIMValue

has an invalid type. Normally this is a Pegasus internal error.

<PRE>

Example:

String test;

CIMValue value(Boolean(true));

test = value.toString(); // puts "TRUE" into test

Line 449

Line 443

String toString() const;

#ifdef PEGASUS_USE_DEPRECATED_INTERFACES

/**

Deprecated Interface

Constructor. (Note: This constructor exists solely to support binary

compatibility with a previous definition of the Sint8 type.)

CIMValue(char x);

/**

Deprecated Interface

Constructor. (Note: This constructor exists solely to support binary

compatibility with a previous definition of the Sint8 type.)

CIMValue(const Array<char>& x);

/**

Deprecated Interface

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

/**

Deprecated Interface

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

/**

Deprecated Interface

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;

/**

Deprecated Interface

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 _init();

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

CIMType _type;

CIMValueRep* _rep;

Boolean _isArray;

Boolean _isNull;

Union _u;

friend class CIMMethodRep;

friend class CIMParameterRep;

friend class CIMPropertyRep;

friend class CIMQualifierRep;

friend class CIMQualifierDeclRep;

PEGASUS_COMMON_LINKAGE friend Boolean operator==(

friend class BinaryStreamer;

const CIMValue& x,

friend class XmlWriter;

const CIMValue& y);

};

/** operator == compares two CIMValue objects for equality.

@param x - First CIMvalue to compare

@param x - First CIMValue to compare

@parm y - Second CIMValue to compare

@param y - Second CIMValue to compare

@return True if they are identical in type, attribute and value.

@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 nonequality

/** 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.

inline Boolean operator!=(const CIMValue& x, const CIMValue& y)

PEGASUS_COMMON_LINKAGE Boolean operator!=(const CIMValue& x, const CIMValue& y);

{

return !operator==(x, y);

}

#define PEGASUS_ARRAY_T CIMValue

# include "ArrayInter.h"

# 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 */

Legend:

Removed from v.1.17
changed lines
	Added in v.1.48

No CVS admin address has been configured