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

Return to CIMMethod.h CVS log

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

Diff for /pegasus/src/Pegasus/Common/CIMMethod.h between version 1.33 and 1.40

version 1.33, 2002/08/14 17:41:16

version 1.40, 2003/11/20 14:50:46

Line 1

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

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

// The Open Group, Tivoli Systems

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

Line 48

class CIMConstMethod;

class CIMMethodRep;

// ATTN: remove the classOrigin and propagated parameters.

/** The CIMMethod class is used to represent CIM methods in Pegasus. A CIMMethod

/** Class CIMMethod - This class defines the operations associated with

consists of the following entities:

manipulation of the Pegasus implementation of the CIM CIMMethod. Within

<ul>

this class, methods are provides for creation, deletion, and manipulation

<li>Name of the method, a CIMName. Functions are provided to manipulate the name.

of method declarations.

The name must be a legal name for a CIMProperty or Method \Ref{CIMName}.

<li>CIM type of the return value of the method, a \Ref{CIMType}. This is any

of the predefined CIM types (for example: Boolean);

<li>Optional qualifiers (see \Ref{CIMQualifier}) for the method. A method

can contain zero or more CIMQualifiers and functions are provided to

manipulate the list of CIMQualifiers.

<li>Optional parameters (see \Ref{CIMParameter} for the method which are

the parameters to be placed on a CIM Method operation. A CIMMethod can

contain zero or more CIMParameters and functions are provided in CIMMethod

to manipulate the list of CIMParameters.

</ul>

In addition, internally, there are the following additional attributes

that are part of a CIMMethod including:

<ul>

<li>propagated - An attribute defining whether this CIMMethod is

propagated from a superclass. Note that this is normally set as part of

completing the definition of objects (resolving) when they are placed in a

repository and is NOT automatically set when creating a local object. It

is part of the context of the object within the repository. It can only

logically be set in context of the superclass of which this CIMMethod is

defined.

<li>ClassOrigin - An attribute defining the superclass in which this

CIMMethod was originally defined. This is normally set as part of

resolving Class and instances in the context of other objects (for example, a

repository). This attribute is available from objects retrieved from the

repository, for example and indicates the Class/Instance in the hiearchy

(this object or a superclass or instance of a superclass)was originally

defined. Together the propagated and ClassOrigin attributes can be used

to determine if methods originated with the current object or were

inherited from higher levels in the hiearchy.

</ul>

Normally CIMMethods are defined in the context of CIMClasses. A CIMClass can include

zero or more CIMMethods

CIMMethod is a shared class so that assignment and copy operators do not

create new copies of the data representing a CIMMethod object but point

back to the original object and the lifecycle of the original object is

controlled by the accumulative lifecycle of any copies and assigned

objects.

{@link Shared Classes}

@see CIMConstMethod

@see CIMParameters

@see CIMQualifiers

@see CIMType

class PEGASUS_COMMON_LINKAGE CIMMethod

{

public:

/** Creates and instantiates a CIM method. */

/** Creates a new default CIMMethod object. The object created is

empty. The only thing that can be done with this constructor

is to copy another object into it. Other methods such as setName, etc.

will fail. The object has the state unitialized which can be tested with

the Unitialized method.

@exception throws UninitializedObjectException() if any method except the copy

function is executed against.

@see CIMConstMethod()

@see Unitialized()

CIMMethod();

/** Creates and instantiates a CIM method from another method instance

/** Creates a new CIMMethod object from another CIMmethod instance. This method

@return pointer to the new method instance

assigns the new object to the representation in the parameter and increments the

representation count. It does NOT create a new independent object but creates

a reference from the assigned object to the representation of the object being

assigned.

@param x CIMMethod object from which to create CIMMethod object.

<pre>

CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);

const CIMMethod cm1(m1);

</pre>

CIMMethod(const CIMMethod& x);

/** Creates a CIM method with the specified name, type, and classOrigin

/** Creates a CIMMethod object with the specified name and other input parameters.

@param name for the method

@param name CIMName defining the name for the method.

@param type CIM data type of method to create

@param classOrigin

@param type CIMType defining data type of the method to be created.

@param propagated

@param classOrigin (optional) CIMName representing the class origin. Note

that this should normally not be used. If not provided set to

CIMName() (Null name).

@param propagated Optional flag indicating whether the definition of the

CIM Method is local to the CIM Class (respectively, Instance) in which

it appears, or was propagated without modification from the a

Superclass. Default is false.

Example:

<pre>

CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);

</pre>

CIMMethod(

const CIMName& name,

Line 76

Line 148

const CIMName& classOrigin = CIMName(),

Boolean propagated = false);

/** Desctructor. */

/** Destructor for the CIMMethod. Since this is a shared class, the destructor

only releases when there are no more objects pointing to the representation

of this object.

~CIMMethod();

/** Assignment operator */

/** The assignment operator assigns one CIM method to another. This method performs

the assignment by incrementing the reference count for the representation of

the CIMMethod, not by creating a deep copy of the object.

Example:

<pre>

CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);

CIMMethod m2 = m1;

</pre>

CIMMethod& operator=(const CIMMethod& x);

/** getName - Gets the name of the method

/** Gets the name of the method.

@return CIMName with the name of the method

@return CIMName with the name of the method.

Example:

<pre>

CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);

assert(m1.getName() == CIMName ("getHostName"));

</pre>

const CIMName& getName() const;

/** setName - Set the method name

/** Sets the method name.

@param name

@param name - CIMName for the method name. Replaces any

previously defined name for this method object.

Example:

<pre>

CIMMethod m2(CIMName ("test"), CIMTYPE_STRING);

m2.setName(CIMName ("getVersion"));

</pre>

void setName(const CIMName& name);

/** getType - gets the method type

/** Gets the method type.

@return The CIM method type for this method.

@return The CIMType containing the method type for this method.

This is the type returned as the return value of a method operation.

Example:

<pre>

CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);

assert(m1.getType() == CIMTYPE_STRING);

</pre>

CIMType getType() const;

/** setType - Sets the method type to the specified CIM method

/** Sets the method type to the specified CIM method type

type as defined in CIMType /Ref{TYPE}

as defined in CIMType. This is the type of the CIMValue

that is returned on a CIMMethod operation

@param type CIMType to be set into the method object.

Example:

<pre>

CIMMethod m1();

m1.setName(CIMName ("getVersion"));

assert(m1.setType(CIMTYPE_STRING));

</pre>

void setType(CIMType type);

/** getClassOrigin - Returns the class in which this method

/** Gets the class in which this method was defined. This information

was defined.

is available after the class containing the method has been

resolved and is part of the class repository.

@return CIMName containing the classOrigin field.

const CIMName& getClassOrigin() const;

/** setClassOrigin - Set the ClassOrigin attribute with

/** Sets the ClassOrigin attribute with the classname defined on

the classname defined on input

the input parameter. Normally this function is used internally

as part of the use objects containing methods (classes

and instances) in a context such as a repository.

@param classOrigin - CIMName parameter defining the name

of the class origin

of the class origin.

void setClassOrigin(const CIMName& classOrigin);

/** getPropagated - Tests the propagated qualifier

/** Tests the propagated qualifier. The propagated attribute

@return - returns True if method is propagated

indicates if this method was propagated from a higher level

class. Normally this attribute is set as part of putting

classes into the repository (resolving the class). It is

available on methods in classes read from the repository and

on instances that are read from the instance repository.

@return True if method is propagated; otherwise,false.

Boolean getPropagated() const;

/** setPropagated - Sets the Propagaged Qualifier */

/** Sets the Propagaged Qualifier. Normally this is used by the functions

that resolve classes and instances as part of the installation into

a repository.

@param propagated Flag indicating method is propagated from superclass propagation.

True means that the method was propagated from superclass.

void setPropagated(Boolean propagated);

/** addQualifier - Adds a Qualifier to the method object.

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

@param CIMQualifier to be added

qualifier count.

@return Throws AlreadyExists excetpion if the qualifier already exists

@param x CIMQualifier object representing the qualifier

in the method

to be added.

@exception AlreadyExists exception

@return the CIMMethod object after adding the specified qualifier.

@exception AlreadyExistsException if the qualifier already exists.

Example:

<pre>

CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);

m1.addQualifier(CIMQualifier(CIMName ("stuff"), true));

</pre>

CIMMethod& addQualifier(const CIMQualifier& x);

/** findQualifier - returns the position of the qualifier with

/** Searches for a qualifier with the specified input name.

the given name.

@param name CIMName of the qualifier to be found.

@param name Name of qualifier to be found.

@return Index of the qualifier found or PEG_NOT_FOUND

@return index of the parameter if found; otherwise PEG_NOT_FOUND.

if not found.

Example:

<pre>

CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);

m1.addQualifier(CIMQualifier(CIMName ("stuff"), true));

assert(m1.findQualifier(CIMName ("stuff")) != PEG_NOT_FOUND);

</pre>

Uint32 findQualifier(const CIMName& name) const;

/** getQualifier - Gets the CIMQualifier defined by the index

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

input as a parameter.

@param index Index of the qualifier requested.

@param Index of the qualifier requested.

@return CIMQualifier object representing the qualifier found.

@return CIMQualifier object or exception

@exception IndexOutOfBoundsException exception if the index is

@exception OutOfBounds exception if the index is outside the range of

outside the range of parameters available from the CIMMethod.

parameters available from the CIMMethod.

Example:

<pre>

CIMQualifier getQualifier(Uint32 pos);

CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);

m1.addQualifier(CIMQualifier(CIMName ("stuff"), true));

CIMConstQualifier getQualifier(Uint32 pos) const;

Uint32 posQualifier;

posQualifier = m1.findQualifier(CIMName ("stuff"));

/** removeQualifier - Removes the CIMQualifier defined by the

CIMQualifier q = m1.getQualifier(posQualifier);

position input as a parameter.

</pre>

@param Position of the qualifier requested.

@return CIMQualifier object or exception

CIMQualifier getQualifier(Uint32 index);

@exception OutOfBounds exception if the index is outside the range of

parameters available from the CIMMethod.

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

@param index Index of the qualifier requested.

void removeQualifier(Uint32 pos);

@return CIMConstQualifier object representing the qualifier found.

@exception IndexOutOfBoundsException exception if the index is

/** getQualifierCount - Returns the number of Qualifiers attached

outside the range of parameters available from the CIMMethod.

to this CIMMethod object.

Example:

@return integer representing number of Qualifiers.

<pre>

CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);

m1.addQualifier(CIMQualifier(CIMName ("stuff"), true));

Uint32 posQualifier;

posQualifier = m1.findQualifier(CIMName ("stuff"));

CIMQualifier q = m1.getQualifier(posQualifier);

</pre>

CIMConstQualifier getQualifier(Uint32 index) const;

/** Removes the specified CIMQualifier from this method.

@param index Index of the qualifier to remove.

@exception IndexOutOfBoundsException exception if the index is

outside the range of parameters available from the CIMMethod.

void removeQualifier(Uint32 index);

/** Returns the number of Qualifiers attached to this CIMMethod object.

@return the number of qualifiers in the CIM Method.

Example:

<pre>

CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);

m1.addQualifier(CIMQualifier(CIMName ("stuff"), true));

m1.addQualifier(CIMQualifier(CIMName ("stuff2"), true));

assert(m1.getQualifierCount() == 2);

</pre>

Uint32 getQualifierCount() const;

/** addParameter - Adds the parameter defined by the input

/** Adds the parameter defined by the input to the CIMMethod.

to the CIMMethod

@param x CIMParameter to be added to the CIM Method.

@return CIMMethod object after the specified parameter is added.

Example:

<pre>

CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);

m1.addParameter(CIMParameter(CIMName ("ipaddress"), CIMTYPE_STRING));

</pre>

CIMMethod& addParameter(const CIMParameter& x);

/** findParameter - Finds the parameter whose name is given

/** Finds the parameter with the specified name.

by the name parameter.

@param name CIMName of parameter to be found.

@param name Name of parameter to be found.

@return Index of the parameter object found or PEG_NOT_FOUND

@return index of the parameter if found; otherwise PEG_NOT_FOUND.

if the property is not found.

Example:

<pre>

Uint32 posParameter;

posParameter = m1.findParameter(CIMName ("ipaddress"));

if (posParameter != PEG_NOT_FOUND)

...

</pre>

Uint32 findParameter(const CIMName& name) const;

/** getParameter - Gets the parameter defined by the index

/** Gets the parameter defined by the specified index.

input as a parameter.

@param index Index for the parameter to be returned.

@param index for the parameter to be returned.

@return CIMParameter object requested.

@return CIMParameter requested.

@exception IndexOutOfBoundsException if the index is outside

@Exception OutOfBounds exception is thrown if the index is outside the

the range of available parameters.

range of available parameters

Example:

<pre>

CIMParameter cp = m1.getParameter(m1.findParameter(CIMName ("ipaddress")));

</pre>

CIMParameter getParameter(Uint32 index);

/** Gets the parameter defined for the specified index.

@param index Index for the parameter to be returned.

@return CIMConstParameter object requested.

@exception IndexOutOfBoundsException if the index is outside

the range of available parameters

CIMConstParameter getParameter(Uint32 index) const;

/** Removes the CIMParameter defined by the specified index.

@param index Index of the parameter to be removed.

@exception IndexOutOfBoundsException if the index is outside the

range of parameters available from the CIMMethod.

CIMParameter getParameter(Uint32 pos);

void removeParameter (Uint32 index);

/** getParameter - const form */

CIMConstParameter getParameter(Uint32 pos) const;

/** removeParameter - Removes the CIMParameter defined by the

specified index

@param pos index of the parameter to be removed

/** Gets the count of Parameters defined in the CIMMethod.

@return Count of the number of parameters attached to the CIMMethod.

@exception OutOfBounds if the index is outside the range of

parameters available from the CIMMethod

void removeParameter (Uint32 pos);

/** getParameterCount - Gets the count of the numbeer of

Parameters attached to the CIMMethod.

@retrun - count of the number of parameters attached to the CIMMethod.

Uint32 getParameterCount() const;

/**

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

Determines if the object has not been initialized.

@return True if the object has not been initialized,

False otherwise

false otherwise false.

Boolean isUninitialized() const;

/** identical - Returns true if this method is identical to the

/** Compares with another CIMConstMethod.

one given by the argument x.

@param x CIMConstMethod object for the method to be compared.

@return true if this method is identical to the one specified.

Example:

<pre>

CIMMethod m1(CIMName ("getHostName"), CIMTYPE_STRING);

CIMMethod m2(CIMName ("test"), CIMTYPE_STRING);

assert(!m1.identical(m2));

</pre>

Boolean identical(const CIMConstMethod& x) const;

/** CIMMethod clone - makes a distinct replica of this method */

/** Makes a clone (deep copy) of this method. This creates

a new copy of all of the components of the method including

parameters and qualifiers.

@return copy of the CIMMethod object.

CIMMethod clone() const;

private:

Line 235

Line 420

friend class MofWriter;

};

/** The CIMConstMethod class is used to represent CIM methods in the

same manner as the CIMMethod class except that the const attribute

is applied to the objects created. This class includes equivalents

to the methods from CIMMethod that are usable in a const object including

constructors, (for example: getter methods) and the destructor.

REVIEWERS: ATTN: Complete the explanation of why.

class PEGASUS_COMMON_LINKAGE CIMConstMethod

{

public:

/** Creates a new default CIMConstMethod object.

@see CIMMethod()

CIMConstMethod();

/// @see CIMMethod()

CIMConstMethod(const CIMConstMethod& x);

/** Creates a new CIMConstMethod object from an

existing CIMMethod object. Creates a pointer

to the existing representation.

@return CIMConstMethod object reference.

@see CIMMethod()

CIMConstMethod(const CIMMethod& x);

///

CIMConstMethod(

const CIMName& name,

CIMType type,

const CIMName& classOrigin = CIMName(),

Boolean propagated = false);

/// destructor. CIMMethod objects are destroyed when

~CIMConstMethod();

/** assigns one CIMMethod object to another. Because this

is a shared class, an assignment does not create a copy to

the assigned object but sets a refernce in the assigned object

to the same object as the CIMMethod object that was assigned.

Note that the return is really CIMConstMethod, not CIMMethod to

prevent unplanned modification of the object

@param x CIMMethod object that is to be assigned to another

CIMMethod object.

Example:

<pre>

CIMMethod cm1("putthing");

</pre>

CIMConstMethod& operator=(const CIMConstMethod& x);

/// assignment operator.

CIMConstMethod& operator=(const CIMMethod& x);

/** gets CIMMethod name. Operation is the same as

CIMMethod getName().

@see CIMMethod

const CIMName& getName() const;

/** gets CIMMethod CIMType. Functions the same as

CIMMethod getType();

@see CIMMethod

CIMType getType() const;

/** gets ClassOrigin attribute. Functions the same

as CIMMethod getClassOrigin()

@see CIMMethod

const CIMName& getClassOrigin() const;

/** gets Propagated attribute. Functions the same

as CIMMethod getPropagated()

@see CIMMethod

Boolean getPropagated() const;

Uint32 findQualifier(const CIMName& name) const;

/** finds qualifier based on name. Functions the

same as the CIMMethod findQualifier() method.

CIMConstQualifier getQualifier(Uint32 pos) const;

@see CIMMethod

Uint32 findQualifier(const CIMName& name) const;

/** gets qualifier based on index. Functions the

same as the CIMMethod getQualifier() method.

@see CIMMethod

CIMConstQualifier getQualifier(Uint32 index) const;

/** gets qualifier count based on name. Functions the

same as the CIMMethod getQualifierCount() method.

@see CIMMethod

Uint32 getQualifierCount() const;

/** finds method parameter based on name. Functions the

same as the CIMMethod findParameter() method.

@see CIMMethod

Uint32 findParameter(const CIMName& name) const;

CIMConstParameter getParameter(Uint32 pos) const;

/** gets method parameter based on index. Functions the

same as the CIMMethod getParameter() method.

@see CIMMethod

CIMConstParameter getParameter(Uint32 index) const;

/** finds method parameter count based on name. Functions the

same as the CIMMethod getParameterCount() method.

@see CIMMethod

Uint32 getParameterCount() const;

/** Determines if CIMMethod is unitinitialized. Functions the

same as corresponding funtion in CIMMethod class.

@see CIMMethod

Boolean isUninitialized() const;

/** Determines if CIMMethod is identical to object define in parameter.

Functions the same as corresponding funtion in CIMMethod class.

@see CIMMethod

Boolean identical(const CIMConstMethod& x) const;

/** clones a CIMMethod object by making a deep copy. Functions the

same as corresponding funtion in CIMMethod class.

@see CIMMethod

CIMMethod clone() const;

private:

Legend:

Removed from v.1.33
changed lines
	Added in v.1.40

No CVS admin address has been configured