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.25

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

version 1.25, 2002/06/01 00:56:29

Line 1

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

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

Line 33

Line 34

#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/Union.h>

#include <Pegasus/Common/Exception.h>

#include <Pegasus/Common/Array.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

Line 65

Line 69

ATTN: Add example

</pre>

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

CIMValue(Boolean x);

/// Constructor

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

CIMValue(Uint8 x);

/// Constructor

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

CIMValue(Sint8 x);

/// Constructor

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

CIMValue(Uint16 x);

/// Constructor

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

CIMValue(Sint16 x);

/// Constructor

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

CIMValue(Uint32 x);

/// Constructor

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

CIMValue(Sint32 x);

/// Constructor

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

CIMValue(Uint64 x);

/// Constructor

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

CIMValue(Sint64 x);

/// Constructor

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

CIMValue(Real32 x);

/// Constructor

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

CIMValue(Real64 x);

/// Constructor

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

CIMValue(const Char16& x);

/// Constructor

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

CIMValue(const String& x);

/// Constructor

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

CIMValue(const char* x);

/// Constructor

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

CIMValue(const CIMDateTime& x);

/// Constructor

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

CIMValue(const CIMObjectPath& x);

/// Constructor

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

CIMValue(const Array<Boolean>& x);

/// Constructor

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

CIMValue(const Array<Uint8>& x);

/// Constructor

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

CIMValue(const Array<Sint8>& x);

/// Constructor

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

CIMValue(const Array<Uint16>& x);

/// Constructor

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

CIMValue(const Array<Sint16>& x);

/// Constructor

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

CIMValue(const Array<Uint32>& x);

/// Constructor

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

CIMValue(const Array<Sint32>& x);

/// Constructor

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

CIMValue(const Array<Uint64>& x);

/// Constructor

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

CIMValue(const Array<Sint64>& x);

/// Constructor

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

CIMValue(const Array<Real32>& x);

/// Constructor

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

CIMValue(const Array<Real64>& x);

/// Constructor

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

CIMValue(const Array<Char16>& x);

/// Constructor

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

CIMValue(const Array<String>& x);

/// Constructor

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

CIMValue(const Array<CIMDateTime>& x);

/// Constructor

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

CIMValue(const Array<CIMObjectPath>& x);

/// Constructor

CIMValue(const CIMValue& x);

Line 164

Line 168

~CIMValue();

/// Operator =

CIMValue& operator=(const CIMValue& x)

CIMValue& operator=(const CIMValue& x);

{

assign(x); return *this;

}

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

object.

void assign(const CIMValue& x);

Line 193

...

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

@return TRUE if the value is an array

Boolean isArray() const { return _isArray; }

Boolean isArray() const;

/** Returns whether the CIMvalue object is Null.

Null is the specific condition where no value has

Line 210

Line 207

will create an exception.

@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

@return The number of entries in the array

Line 221

Line 218

The CIMType is defined in ATTN:

@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

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

Line 286

Line 280

///

void set(const CIMDateTime& x);

///

void set(const CIMReference& x);

void set(const CIMObjectPath& x);

///

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

///

Line 316

Line 310

///

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

///

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

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

/** get - Gets the value of a CIMValue

@param Variable in which we return the value:

Line 355

Line 349

///

void get(CIMDateTime& x) const;

///

void get(CIMReference& x) const;

void get(CIMObjectPath& x) const;

///

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

///

Line 385

Line 379

///

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

/** Makes a deep copy (clone) of the given object. */

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

CIMValue clone() const;

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.

@out Sint8 Array to hold the Mof representation

@return Returns the Mof representation of the CIMValue

object in the input parameter out.

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

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

used for output purposes. To get an actual String value, use

Line 451

Line 401

private:

void _init();

CIMValueRep* _rep;

CIMType _type;

Boolean _isArray;

Boolean _isNull;

Union _u;

friend class CIMMethodRep;

friend class CIMParameterRep;

Line 467

Line 412

const CIMValue& x,

const CIMValue& y);

};

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

@param x - First CIMvalue to compare

@parm y - Second CIMValue to compare

Line 476

Line 422

/** operator != compares two CIMValue objects for nonequality

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

Legend:

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

No CVS admin address has been configured