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.11.2.2 and 1.30

version 1.11.2.2, 2001/08/01 11:17:36

version 1.30, 2002/08/20 17:39:37

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 22

Line 23

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

// Modified By:

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

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

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

Line 32

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>

#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

Line 47

Line 53

class PEGASUS_COMMON_LINKAGE CIMValue

{

public:

/// Constructor

/** Constructor with no value. This constructor creates an NULL CIMValue

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

CIMValue();

/// Constructor

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

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

object with the array indicator set as shown and with the

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) { _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 CIMDateTime& x);

/// Constructor

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

CIMValue(const CIMObjectPath& x);

/// Constructor

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

CIMValue(const Array<Boolean>& x);

/// Constructor

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

CIMValue(const Array<Uint8>& x);

/// Constructor

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

CIMValue(const Array<Sint8>& x);

/// Constructor

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

CIMValue(const Array<Uint16>& x);

/// Constructor

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

CIMValue(const Array<Sint16>& x);

/// Constructor

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

CIMValue(const Array<Uint32>& x);

/// Constructor

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

CIMValue(const Array<Sint32>& x);

/// Constructor

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

CIMValue(const Array<Uint64>& x);

/// Constructor

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

CIMValue(const Array<Sint64>& x);

/// Constructor

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

CIMValue(const Array<Real32>& x);

/// Constructor

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

CIMValue(const Array<Real64>& x);

/// Constructor

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

CIMValue(const Array<Char16>& x);

/// Constructor

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

CIMValue(const Array<String>& x);

/// Constructor

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

CIMValue(const Array<CIMDateTime>& x);

/// Constructor

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

CIMValue(const Array<CIMObjectPath>& x);

/// Constructor

CIMValue(const CIMValue& x);

/// Destrustructor

/// Destructor

~CIMValue();

/// Operator =

CIMValue& operator=(const CIMValue& x)

CIMValue& operator=(const CIMValue& x);

{

assign(x); return *this;

}

/// CIMMethod assign

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

object.

void assign(const CIMValue& x);

/// CIMMethod clear

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

void clear();

/** CIMMethod typeCompatible - Compares the types of two values.

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

@return true if compatible.

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

Boolean typeCompatible(const CIMValue& x) const;

{

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

}

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

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

/** 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 { return _isNull; }

Boolean isNull() const;

/** CIMMethod getArraySize

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

@return The number of entries in the array

Uint32 getArraySize() const;

CIMType getType() const

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

{

@return the CIMType value

return CIMType(_type);

}

CIMType getType() const;

/// method setNullvalue - ATTN:

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

/// method set - ATTN:

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

/// CIMMethod Set

/// 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 char* x);

void set(const CIMDateTime& x);

///

void set(const CIMReference& 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);

/// CIMMethod get - ATTN

/** get - Gets the value of a CIMValue

@param Variable in which we return the value:

@return void

<pre>

Uint32 v;

CIMValue value(CIMValue::UINT32, UINT32(99));

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

/** toXML - Converts a CIMValueObject to XML.

/** Compare with another CIMValue object for equality.

@out Sint8 Array to hold the XML representation

@param x - CIMValue to compare with

@return Returns the XML representation of the CIMValue

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

object in the input parameter out.

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

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

stream

@return None

<PRE>

Example:

CIMValue value(Boolean(true));

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

</PRE>

void print(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;

Boolean equal(const CIMValue& x) const;

/** toString - Converts the CIMvalue to a string

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

@exception - Throws CIMValueInvalidTypeException 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

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

</PRE>

String toString() const;

private:

void _init();

// ATTN-RK-P2-20020719: For debugging only; remove before API release.

// Use CIMValue(const String&) instead.

PEGASUS_EXPLICIT CIMValue(const char* x) {}

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==(

const CIMValue& x,

const CIMValue& y);

};

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

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

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

{

return !operator==(x, y);

PEGASUS_COMMON_LINKAGE Boolean operator!=(const CIMValue& x, const CIMValue& 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.11.2.2
changed lines
	Added in v.1.30

No CVS admin address has been configured