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.1 and 1.43

version 1.11.2.1, 2001/07/26 21:07:31

version 1.43, 2005/04/19 21:21:36

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:

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

#ifndef Pegasus_Value_h

Line 32

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

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

with type CIMType:none and !arraytype.

CIMValue();

/// Constructor

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

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

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.

CIMValue(Boolean x);

/// Constructor.

CIMValue(Uint8 x);

/// Constructor.

CIMValue(Sint8 x);

/// Constructor

/// Constructor.

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

CIMValue(Uint16 x);

/// Constructor

/// Constructor.

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

CIMValue(Sint16 x);

/// Constructor

/// Constructor.

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

CIMValue(Uint32 x);

/// Constructor

/// Constructor.

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

CIMValue(Sint32 x);

/// Constructor

/// Constructor.

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

CIMValue(Uint64 x);

/// Constructor

/// Constructor.

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

CIMValue(Sint64 x);

/// Constructor

/// Constructor.

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

CIMValue(Real32 x);

/// Constructor

/// Constructor.

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

CIMValue(Real64 x);

/// Constructor

/// Constructor.

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

CIMValue(const Char16& x);

/// Constructor

/// Constructor.

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

CIMValue(const String& x);

/// Constructor

/// Constructor.

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

CIMValue(const CIMDateTime& x);

/// Constructor

/// Constructor.

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

CIMValue(const CIMObjectPath& x);

/// Constructor

/// Constructor.

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

CIMValue(const CIMObject& x);

/// Constructor

/// Constructor.

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

CIMValue(const Array<Boolean>& x);

/// Constructor

/// Constructor.

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

CIMValue(const Array<Uint8>& x);

/// Constructor

/// Constructor.

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

CIMValue(const Array<Sint8>& x);

/// Constructor

/// Constructor.

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

CIMValue(const Array<Uint16>& x);

/// Constructor

/// Constructor.

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

CIMValue(const Array<Sint16>& x);

/// Constructor

/// Constructor.

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

CIMValue(const Array<Uint32>& x);

/// Constructor

/// Constructor.

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

CIMValue(const Array<Sint32>& x);

/// Constructor

/// Constructor.

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

CIMValue(const Array<Uint64>& x);

/// Constructor

/// Constructor.

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

CIMValue(const Array<Sint64>& x);

/// Constructor

/// Constructor.

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

CIMValue(const Array<Real32>& x);

/// Constructor

/// Constructor.

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

CIMValue(const Array<Real64>& x);

/// Constructor

/// Constructor.

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

CIMValue(const Array<Char16>& x);

/// Constructor

/// Constructor.

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

CIMValue(const Array<String>& x);

/// Constructor

/// Constructor.

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

CIMValue(const Array<CIMDateTime>& x);

/// Constructor

/// Constructor.

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

CIMValue(const Array<CIMObjectPath>& x);

/// Constructor

/// Constructor.

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

CIMValue(const Array<CIMObject>& x);

/// Constructor

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

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

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

void assign(const CIMValue& x);

/// CIMMethod clear

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

void clear();

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

/** 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, false otherwise.

<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

/** 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 value is null.

/** Determines whether the CIMvalue object is Null.

Null is the specific condition where no value has

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

object will create an exception.

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

Boolean isNull() const { return _isNull; }

Boolean isNull() const;

/** CIMMethod getArraySize

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

CIMType getType() const

/** Gets the CIMType attribute for the CIMValue.

{

@return the CIMType value.

return CIMType(_type);

}

CIMType getType() const;

/// method setNullvalue - ATTN:

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

characteristics.

@param type - CIMType for this CIMValue.

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

@param arraySize - Optional parameter indicating the array size.

<pre>

CIMValue value;

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

</pre>

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

/// method set - ATTN:

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

into the value of the target CIMValue.

<pre>

CIMValue x;

x.set(Uint16(9));

</pre>

void set(Boolean x);

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

///

/// CIMMethod get - ATTN

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.

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

///

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;

///

/** CIMMethod toXML

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.

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

Boolean equal(const CIMValue& x) const;

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

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

stream

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

@return None

get(String &).

@return String output for CIMValue.

<PRE>

Example:

CIMValue value(Boolean(true));

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

</PRE>

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

/** toString - Converts the CIMvalue to a string

@return - String output for CIMValue.

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

#ifdef PEGASUS_USE_DEPRECATED_INTERFACES

/// Constructor.

CIMValue(char x);

/// Constructor.

CIMValue(const Array<char>& x);

void _init();

///

void set(char x);

CIMType _type;

///

Boolean _isArray;

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

Boolean _isNull;

Union _u;

///

void get(char& x) const;

///

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

#endif

private:

CIMValueRep* _rep;

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,

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,

false otherwise.

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.

{

@param x - First CIMValue to compare

return !operator==(x, y);

@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 "ArrayInter.h"

# include <Pegasus/Common/ArrayInter.h>

#undef PEGASUS_ARRAY_T

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.11.2.1
changed lines
	Added in v.1.43

No CVS admin address has been configured