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

Return to CIMClass.h CVS log

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

Diff for /pegasus/src/Pegasus/Common/CIMClass.h between version 1.39 and 1.65

version 1.39, 2002/05/06 20:56:21

version 1.65, 2004/06/30 21:07:54

Line 1

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

//%2003////////////////////////////////////////////////////////////////////////

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

// IBM Corp.; EMC 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 23

Line 26

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

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

// Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.com)

// Adriann Schuur (schuur@de.ibm.com) PEP 164

// Karl Schopmeyer k.schopmeyer@opengroup.org (PEP 157)

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

Line 30

Line 37

#define Pegasus_CIMClass_h

#include <Pegasus/Common/Config.h>

#include <Pegasus/Common/Linkage.h>

#include <Pegasus/Common/CIMName.h>

#include <Pegasus/Common/CIMObject.h>

#include <Pegasus/Common/CIMMethod.h>

#include <Pegasus/common/CIMInstance.h>

#include <Pegasus/Common/CIMPropertyList.h>

PEGASUS_NAMESPACE_BEGIN

class CIMConstClass;

class CIMClassRep;

class DeclContext;

class Resolver;

// REVIEW: redocument.

/** The CIMClass class is used to represent CIM classes in Pegasus. In CIM,

/** The CIMClass class is used to represent CIM classes in Pegasus.

a class object may be a class or an associator. A CIM class must contain a

name and may contain methods, properties, and qualifiers. It is a template

for creating a CIM instance. A CIM class represents a collection of CIM

instances, all of which support a common type (for example, a set of

properties, methods, and associations).

class PEGASUS_COMMON_LINKAGE CIMClass

{

public:

/** Constructor - Creates an uninitiated a new CIM object

/** Creates an uninitialized new CIM object representing a CIM class.

reprenting a CIM class. The class object created by this

The class object created by this constructor can only be used

constructor can only be used in an operation such as the

in an operation such as the copy constructor. It cannot be used

copy constructor. It cannot be used to create a class by

to create a class by appending names, properties, etc. since it

appending names, properties, etc. since it is unitiated.

is uninitialized.

Use one of the other constructors to create an initiated new CIM class

Use one of the other constructors to create an initialized new

object.

CIM class object.

@exception Throws an exception "unitialized handle" if this

@exception UninitializedObjectException if an attempt is made to

unitialized handle is used

use the unitialized object.

/REF(HPEGASUS_HANDLES)

CIMClass();

/** Constructor - Creates a class from a previous class

/** Creates a new CIM object representing a CIMClass from the given

CIMClass object.

@param x CIMClass Object from which to create the CIMClass

CIMClass(const CIMClass& x);

PEGASUS_EXPLICIT CIMClass(const CIMObject& x)

/** Creates a new CIMClass object representing a CIMClass from the given

throw(DynamicCastFailed);

CIMObject Object.

@param x CIMObject object from which to create the CIMClass object.

/** Constructor - Creates a Class from inputs of a classname and

@exception DynamicCastFailedException If a CIMClass can not be

SuperClassName

created from the given CIMObject.

@param className CIMReference representing name of the class being created

@param superClassName String representing name of the SuperClass

PEGASUS_EXPLICIT CIMClass(const CIMObject& x);

ATTN: Define what makes up legal name.

@return Throws IllegalName if className argument illegal CIM identifier.

/** Creates a new CIM object representing a CIMClass from inputs

of a classname and SuperClassName.

@param className CIMName representing name of the class being created.

@param superClassName CIMName representing name of the SuperClass.

<pre>

CIMClass NewCass("MyClass", "YourClass");

CIMClass NewClass("MyClass", "YourClass");

</pre>

CIMClass(

const CIMReference& reference,

const CIMName& className,

const String& superClassName = String::EMPTY);

const CIMName& superClassName = CIMName());

/** Assignment operator.

///

CIMClass& operator=(const CIMClass& x);

/// Destructor

~CIMClass();

/** isAssociation - Identifies whether or not this CIM class

/** Identifies whether or not this CIM class is an association. An

is an association. An association is a relationship between two

association is a relationship between two (or more) classes or

(or more) classes or instances of two classes. The properties of an

instances of two classes. The properties of an association class

association class include pointers, or references, to the two (or

include pointers, or references, to the two (or more) instances.

more) instances. All CIM classes can be included in one or more

All CIM classes can be included in one or more associations.

associations.

@return true if this CIM class is an association, false

@return Boolean True if this CIM class belongs to an association;

otherwise.

otherwise, false.

Boolean isAssociation() const;

/** isAbstract Test if the CIMClass is abstract.

/** Tests if the CIMClass is abstract.

@return - True if the CIMClass Object is abstract

@return true if the CIMClass Object is abstract, false otherwise.

SeeAlso: Abstract

Boolean isAbstract() const;

/** getClassName Gets the name of the class

ATTN: COMMENT. Why not just get name so we have common method for all.

/** Gets the name of the class represented by this CIM object.

@return Returns string with the class name.

@return CIMName with the class name.

const String& getClassName() const;

const CIMName& getClassName() const;

/** equalClassName compares Name of the class with a String. This test

///

performs a comparison of the classname component of the object

const CIMObjectPath& getPath() const;

with a String. Note that this function was included specifically

because the equality compare is not just a straight comparison

/** Sets the object path for the class.

because classnames are case independent.

@param path CIMObjectPath containing the object path.

@param classname String containing the name for comparison

@return True if it is the same class name (equalNoCase compare passes)

void setPath (const CIMObjectPath & path);

or false if not.

/** Gets the name of the Parent class of this CIM Object.

const Boolean equalClassName(const String& classname) const;

@return CIMName with parent class name.

const CIMReference& getPath() const;

const CIMName& getSuperClassName() const;

/** getSuperClassName - Gets the name of the Parent

/** Sets the name of the parent class from the input

@return String with parent class name.

parameter.

@param superClassName - CIMName defining parent class name.

const String& getSuperClassName() const;

void setSuperClassName(const CIMName& superClassName);

/** setSuperClassName - Sets the name of the parent class from

the input parameter. \REF{CLASSNAME}. ATTN: Define legal classnames

/** Adds the specified qualifier to the class and increments the

@param String defining parent name.

qualifier count. It is illegal to add the same qualifier more

@return Throws IllegalName if superClassName argument not legal CIM

than one time.

identifier

@param qualifier CIMQualifier object representing the qualifier

@exception throws IllegalName if the name is not correct. See

to be added.

\URL[ClassNames]{DefinitionofTerms.html#CLASSNAME}

@return the CIMClass object.

@exception AlreadyExistsException if the qualifier already exists.

void setSuperClassName(const String& superClassName);

/** addQualifier - Adds the specified qualifier to the class

and increments the qualifier count. It is illegal to add the same

qualifier more than one time.

@param qualifier CIMQualifier object representing the qualifier to be

added

@return Returns handle of the class object

@exception Throws AlreadyExists.

CIMClass& addQualifier(const CIMQualifier& qualifier);

/** findQualifier - Searches for a qualifier with the specified `

/** Searches for a qualifier with the specified input name if it

input name if it exists in the class

exists in the class.

@param name CIMName of the qualifier

@param name CIMName of the qualifier to be found

to be found @return Position of the qualifier in the Class.

@return Index of the qualifier found or PEG_NOT_FOUND

@return Returns index of the qualifier found or PEG_NOT_FOUND

if not found.

Uint32 findQualifier(const String& name) const;

Uint32 findQualifier(const CIMName& name) const;

/** existsQualifier - Returns true if the qualifier with the

/** Gets the CIMQualifier object defined by the input parameter.

specified name exists in the class

@param index Index of the qualifier in the class from the

@param name String name of the qualifier object being tested.

findQualifier method.

@return True if the qualifier exits. Otherwise false is returned.

@return CIMQualifier object representing the qualifier found.

On error, CIMQualifier object will be null.

Boolean existsQualifier(const String& name) const;

@exception IndexOutOfBoundsException exception if the index is

outside the range of parameters available from the CIMClass.

/** isTrueQualifier - Determines if the qualifier defined by

the input parameter exists for the class, is Boolean, and

CIMQualifier getQualifier(Uint32 index);

has a value of true.

This function is useful to quickly determine the state of a

/** Gets the qualifier defined by the input parameter from the

qualifier.

qualifier list for this CIMClass.

@param String containing the qualifier name.

@param index Index of the qualifier in the CIM class.

@return Boolean True if the qualifier exists,

@return CIMConstQualifier object representing the qualifier

found. On error, CIMConstQualifier object will be null.

Boolean isTrueQualifier(const String& name) const;

@exception IndexOutOfBoundsException exception if the index is

outside the range of parameters available from the CIMClass.

/** getQualifier - Gets the CIMQualifier object defined

by the input parameter

CIMConstQualifier getQualifier(Uint32 index) const;

@param pos defines the position of the qualifier in the class from the

findQualifier method

/** Removes the qualifier defined by the index parameter.

@return CIMQualifier object representing the qualifier found. On error,

@param index Defines the index of the qualifier to be removed.

CIMQualifier handle will be null.

@exception IndexOutOfBoundsException if the index is outside

the range of existing qualifier objects for this class.

CIMQualifier getQualifier(Uint32 pos);

void removeQualifier(Uint32 index);

/** getQualifier - Gets the qualifier defined by the input parameter

from the qualifier list for this CIMClass.

/** Gets the count of the number of qualifiers defined in the class.

@return the number of qualifiers in the class definition (not

CIMConstQualifier getQualifier(Uint32 pos) const;

those on properties or methods)

/** removeQualifier - Removes the qualifier defined by the

index parameter.

@param Defines the index of the qualifier to be removed.

@return There is no return.

@exception Throw OutOfBound exception if the index is outside

the range of existing qualifier objects for this class

void removeQualifier(Uint32 pos);

/** getQualifierCount - Returns the number of qualifiers

in the class.

@return ATTN:

Uint32 getQualifierCount() const;

/** addProperty - Adds the specified property object to the

/** Adds the specified property object to the properties in

properties in the CIM class

the CIM class

@param x CIMProperty to be added to the CIM Class.

@return CIMClass object after the specified property is added.

CIMClass& addProperty(const CIMProperty& x);

/** findProperty - Finds the property object with the

/** Finds the property object with the name defined by the

name defined by the input parameter in the class.

input parameter in the class.

@param String parameter with the property name.

@param name CIMName with the property name to be found.

@return position representing the property object found or

@return Index of the property object found or

PEG_NOT_FOUND if the property is not found.

Uint32 findProperty(const String& name) const;

Uint32 findProperty(const CIMName& name) const;

/** existsProperty - Determines if a property object with the

/** Gets a property object from the CIMClass.

name defined by the input parameter exists in the class.

@param index Index for the property object to get.

@parm String parameter with the property name.

@return CIMProperty object requested.

@return True if the property object exists.

@exception IndexOutOfBoundsException if the index is outside

the range of properties in this class.

Boolean existsProperty(const String& name) const;

/** getProperty - Returns a property representing the property

defined by the input parameter

@param position for this property

ATTN: Should we not use something like handle for position???

@return CIMProperty object

ATTN: what is error return?

CIMProperty getProperty(Uint32 pos);

/**getProperty Gets a property object from the CIMClass

@param pos The index of the property object to get.

@return Returns handle of the property object requested

@exception Throws OutofBounds if the size field is greather than the

bunber of properties in the class.

CIMConstProperty getProperty(Uint32 pos) const;

/** removeProperty - Removes the property represented

by the position input parameter from the class

@param pos Index to the property to be removed from the

findPropety method

@exception Throws OutofBounds if index is not a property object

void removeProperty(Uint32 pos);

/** getPropertyCount - Gets the count of the number of properties

defined in the class.

@return count of number of proerties in the class

Uint32 getPropertyCount() const;

CIMProperty getProperty(Uint32 index);

/** addMethod - Adds the method object defined by the input

/** Gets a property object from the CIMClass.

parameter to the class and increments the count of the number of

@param index Index for the property object to get.

methods in the class

@return CIMProperty object requested.

@param method object representing the method to be added

@exception IndexOutOfBoundsException if the index is outside

@return Returns the CIMClass object to which the method was added.

the range of properties in this class.

@exception Throws AlreadyExists if the method already exists and throws

UnitializedHandle if the handle is not initialized

CIMClass& addMethod(const CIMMethod& x);

CIMConstProperty getProperty(Uint32 index) const;

/** findMethod - Locate the method object defined by the

/** Removes the specified property from the class.

name input

@param index Index of the property to be removed.

@param String representing the name of the method to be found

@exception IndexOutOfBoundsException if the index is outside

@return Position of the method object in the class to be used in

the range of properties in this class.

subsequent getmethod, etc. operations

Uint32 findMethod(const String& name) const;

void removeProperty(Uint32 index);

/** existsMethod - Determine if the method object defined by the

/** Gets the count of the number of properties defined in the class.

name input exists

@return count of number of properties in the class.

@param String representing the name of the method to be found

@return True if the method exists

Boolean existsMethod(const String& name) const;

Uint32 getPropertyCount() const;

/** getMethod - Gets the method object defined by the

/** Adds the method object defined by the input parameter to the

input parameter.

class and increments the count of the number of methods in the class.

@param pos Index to the method object to get

@param name CIMMethod object representing the method to be added.

@return Returns handle of the method requested

@return the CIMClass object to which the method was added.

@exception Throws OutofBounds if the index represented by pos is greater

@exception AlreadyExistsException if the method already exists.

than the number of methods defined in the class object

@exception UninitializedObjectException if the object is not initialized.

CIMMethod getMethod(Uint32 pos);

CIMClass& addMethod(const CIMMethod& x);

/** getMethod Gets the method object defined by the input

/** Locate the method object defined by the input parameter.

parameter. This is the const version.

@param name CIMName representing the name of the method to be found.

@return Position of the method object in the class.

Uint32 findMethod(const CIMName& name) const;

CIMConstMethod getMethod(Uint32 pos) const;

/** Gets the method object defined by the input parameter.

@param index Index to the method object to get.

/** removeMethod - Removes the method defined by the

@return CIMMethod object of the method requested.

index parameter.

@exception IndexOutOfBoundsException if the index is outside

@param Defines the index of the method to be removed.

the range of methods in this class.

@return There is no return.

@exception Throw OutOfBound exception if the index is outside

the range of existing method objects for this class

void removeMethod(Uint32 pos);

CIMMethod getMethod(Uint32 index);

/** getMethodCount - Count of the number of methods in the class

/** Gets the method object defined by the input parameter.

@return integer representing the number of methods in the class object.

@param index Index to the method object to get.

@return CIMConstMethod object of the method requested.

@exception IndexOutOfBoundsException if the index is outside

the range of methods in this class.

Uint32 getMethodCount() const;

CIMConstMethod getMethod(Uint32 index) const;

/** Get names of all keys of this class. */

/** Removes the method defined by the index parameter.

void getKeyNames(Array<String>& keyNames) const;

@param index Defines the index of the method to be removed.

@exception IndexOutOfBoundsException if the index is outside

Boolean hasKeys() const;

the range of methods in this class.

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

CIMClass clone() const;

/** identical - Compares with another class

ATTN: Clarify exactly what identical means

@param Class object for the class to be compared

@return True if the classes are identical

Boolean identical(const CIMConstClass& x) const;

void removeMethod(Uint32 index);

/** toXML - prepares an XML representation of the CIMClass object

/** Gets the count of the number of methods in the class.

in the provided Sint8 variable.

@return the count of the number of methods in the class object.

@param out Sint8 array for the XML representation

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

Uint32 getMethodCount() const;

/** toMof - prepares a MOF representation of the CIMClass object

/// Get names of all keys of this class.

in the provided Sint8 variable.

void getKeyNames(Array<CIMName>& keyNames) const;

@param out Sint8 array for the XML representation

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

/** print - Prints the toXML output to cout

/** Determines if the object has keys.

@return true if the object has keys, false otherwise.

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

Boolean hasKeys() const;

#ifdef PEGASUS_INTERNALONLY

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

/** Resolve - Resolve the class: inherit any properties and

@return copy of the CIMClass object.

qualifiers. Make sure the superClass really exists and is consistent

with this class. Also set the propagated flag class-origin for each

class feature.

ATTN: explain why this here

void resolve(

CIMClass clone() const;

DeclContext* declContext,

const String& nameSpace);

/// operator - ATTN:

operator int() const;

/** printMof - Prints the toMof output to cout

/** Compares with another CIM class.

@param x Class object for the class to be compared.

@return true if the classes are identical, false otherwise.

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

Boolean identical(const CIMConstClass& x) const;

#endif

/** Determines if the object has not been initialized.

@return true if the object has not been initialized,

false otherwise.

Boolean isUninitialized() const;

/**

Build a CIMInstance based on this CIM Class. Properties in the instance

are initialized to the default values (if any) specified in the class

definition. The parameters of the call determine whether qualifiers are

included, the class origin attributes are included and which properties

are included in the new instance. This method is designed specifically

for providers to allow them to easily build instance objects using the

parameters provided with the CIM instance operations such as getInstance,

enumerateInstances.

@param includeQualifiers If true attaches the class level qualifiers from

this class to the instance and all properties inserted in the instance.

If false, no qualifiers are attached to the instance or to any properties

included in the instance. The TOINSTANCE flavor is ignored. Because

there is still confusion over the exact operation of this parameter in the

CIM specifications and the concept of instance level qualifiers, the

behavior of this function when the parameter is true MAY change in the

future to match any future clarifications of interoperable behavior in the

CIM specifications.

@param includeClassOrigin If true ClassOrigin attributes attached to

properties inthe class object are transferred to the properties attached

to the instance object. If false, any ClassOrigin attributes are ignored.

@param propertyList A CIMPropertyList defining the properties that are to

be added to the created instance. If propertyList is not NULL properties

defined in the class and in this propertyList are added to the new

instance. If the propertyLlist is NULL, all properties are added to the

instance. If the propertyList exists but is empty, not properties are

added. Note that this function does NOT generate an error if a property

name is supplied that is NOT in the class; it simply does not add that

property to the instance.

@return CIMInstance of this class appropriately initialized.

EXAMPLE:

CIMInstance createInstance(Boolean includeQualifiers,

Boolean includeClassOrigin,

const CIMPropertyList & propertyList) const;

private:

CIMClassRep* _rep;

#ifdef PEGASUS_INTERNALONLY

CIMClass(CIMClassRep* rep);

void _checkRep() const;

Line 378

Line 358

friend class CIMConstClass;

friend class CIMObject;

friend class CIMConstObject;

#endif

friend class Resolver;

friend class XmlWriter;

friend class MofWriter;

friend class BinaryStreamer;

};

#define PEGASUS_ARRAY_T CIMClass

# include "ArrayInter.h"

#include <Pegasus/Common/ArrayInter.h>

#undef PEGASUS_ARRAY_T

/** CIMConstClass - ATTN: define this.

/// CIMConstClass

class PEGASUS_COMMON_LINKAGE CIMConstClass

{

public:

///

CIMConstClass();

///

CIMConstClass(const CIMConstClass& x);

///

CIMConstClass(const CIMClass& x);

PEGASUS_EXPLICIT CIMConstClass(const CIMObject& x)

///

throw(DynamicCastFailed);

PEGASUS_EXPLICIT CIMConstClass(const CIMObject& x);

PEGASUS_EXPLICIT CIMConstClass(const CIMConstObject& x)

///

throw(DynamicCastFailed);

PEGASUS_EXPLICIT CIMConstClass(const CIMConstObject& x);

// Throws IllegalName if className argument not legal CIM identifier.

///

CIMConstClass(

const CIMReference& reference,

const CIMName& className,

const String& superClassName = String::EMPTY);

const CIMName& superClassName = CIMName());

///

CIMConstClass& operator=(const CIMConstClass& x);

///

CIMConstClass& operator=(const CIMClass& x);

///

~CIMConstClass();

///

Boolean isAssociation() const;

///

Boolean isAbstract() const;

const String& getClassName() const;

///

const CIMName& getClassName() const;

const Boolean equalClassName(const String& classname) const;

///

const CIMObjectPath& getPath() const;

const CIMReference& getPath() const;

///

const CIMName& getSuperClassName() const;

const String& getSuperClassName() const;

///

Uint32 findQualifier(const CIMName& name) const;

Uint32 findQualifier(const String& name) const;

///

CIMConstQualifier getQualifier(Uint32 index) const;

CIMConstQualifier getQualifier(Uint32 pos) const;

Boolean isTrueQualifier(const String& name) const;

///

Uint32 getQualifierCount() const;

Uint32 findProperty(const String& name) const;

///

Uint32 findProperty(const CIMName& name) const;

CIMConstProperty getProperty(Uint32 pos) const;

///

CIMConstProperty getProperty(Uint32 index) const;

///

Uint32 getPropertyCount() const;

Uint32 findMethod(const String& name) const;

///

Uint32 findMethod(const CIMName& name) const;

CIMConstMethod getMethod(Uint32 pos) const;

///

CIMConstMethod getMethod(Uint32 index) const;

///

Uint32 getMethodCount() const;

void getKeyNames(Array<String>& keyNames) const;

///

void getKeyNames(Array<CIMName>& keyNames) const;

///

Boolean hasKeys() const;

///

CIMClass clone() const;

///

Boolean identical(const CIMConstClass& x) const;

#ifdef PEGASUS_INTERNALONLY

///

operator int() const;

Boolean isUninitialized() const;

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

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

#endif

private:

CIMClassRep* _rep;

#ifdef PEGASUS_INTERNALONLY

void _checkRep() const;

friend class CIMClassRep;

Line 475

Line 470

friend class CIMInstanceRep;

friend class CIMObject;

friend class CIMConstObject;

#endif

friend class XmlWriter;

friend class MofWriter;

friend class BinaryStreamer;

};

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.39
changed lines
	Added in v.1.65

No CVS admin address has been configured