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.3 and 1.48

version 1.3, 2001/02/20 05:16:57

version 1.48, 2002/06/01 00:56:22

Line 1

//BEGIN_LICENSE

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

// The Open Group, Tivoli Systems

// Permission is hereby granted, free of charge, to any person obtaining a

// Permission is hereby granted, free of charge, to any person obtaining a copy

// copy of this software and associated documentation files (the "Software"),

// of this software and associated documentation files (the "Software"), to

// to deal in the Software without restriction, including without limitation

// deal in the Software without restriction, including without limitation the

// the rights to use, copy, modify, merge, publish, distribute, sublicense,

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// and/or sell copies of the Software, and to permit persons to whom the

// sell copies of the Software, and to permit persons to whom the Software is

// Software is furnished to do so, subject to the following conditions:

// furnished to do so, subject to the following conditions:

// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED

// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR

// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

//==============================================================================

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

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

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

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

// DEALINGS IN THE SOFTWARE.

//END_LICENSE

//BEGIN_HISTORY

// Author:

// $Log$

// Revision 1.3 2001/02/20 05:16:57 mike

// Implemented CIMInstance::getInstanceName()

// Revision 1.2 2001/02/19 01:47:16 mike

// Renamed names of the form CIMConst to ConstCIM.

// Revision 1.1 2001/02/18 18:39:05 mike

// new

// Revision 1.2 2001/02/18 03:56:00 mike

// Changed more class names (e.g., ConstClassDecl -> ConstCIMClass)

// Revision 1.1 2001/02/16 02:06:06 mike

// Renamed many classes and headers.

// Revision 1.5 2001/01/30 23:39:00 karl

// Add doc++ Documentation to header files

// Revision 1.4 2001/01/28 18:48:07 mike

// fixed typo in comment

// Revision 1.3 2001/01/28 18:46:50 mike

// more docs

// Revision 1.2 2001/01/15 04:31:43 mike

// worked on resolve scheme

// Revision 1.1.1.1 2001/01/14 19:50:37 mike

// Pegasus import

//END_HISTORY

#ifndef Pegasus_ClassDecl_h

#ifndef Pegasus_CIMClass_h

#define Pegasus_ClassDecl_h

#define Pegasus_CIMClass_h

#include <Pegasus/Common/Config.h>

#include <Pegasus/Common/CIMClassRep.h>

#include <Pegasus/Common/CIMObject.h>

#include <Pegasus/Common/CIMMethod.h>

PEGASUS_NAMESPACE_BEGIN

class ConstCIMClass;

class CIMConstClass;

class CIMClassRep;

class DeclContext;

// REVIEW: redocument.

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

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

Line 73

Line 51

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 and instantiates a new object reprenting a CIM

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

class. If you use this constructor, use setName to define a name for

reprenting a CIM class. The class object created by this

the class

constructor can only be used in an operation such as the

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

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

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

object.

@exception Throws an exception "unitialized handle" if this

unitialized handle is used

/REF(HPEGASUS_HANDLES)

CIMClass() : _rep(0)

CIMClass();

{

}

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

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

CIMClass(const CIMClass& x);

CIMClass(const CIMClass& x)

{

Inc(_rep = x._rep);

}

/// Operator = ATTN:

PEGASUS_EXPLICIT CIMClass(const CIMObject& x)

CIMClass& operator=(const CIMClass& x)

throw(DynamicCastFailed);

{

if (x._rep != _rep)

{

Dec(_rep);

Inc(_rep = x._rep);

}

return *this;

}

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

SuperClassName

@param className - String representing name of the class being created

@param className CIMObjectPath representing name of the class being created

@param superClassName - String representing name of the SuperClass

@param superClassName String representing name of the SuperClass

ATTN: Define what makes up legal name.

@return Throws IllegalName if className argument illegal CIM identifier.

<pre>

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

</pre>

CIMClass(

const String& className,

const CIMObjectPath& reference,

const String& superClassName = String())

const String& superClassName = String::EMPTY);

{

_rep = new CIMClassRep(className, superClassName);

/** Assignment operator.

}

CIMClass& operator=(const CIMClass& x);

/// Destructor

~CIMClass()

~CIMClass();

{

Dec(_rep);

}

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

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

is an association. An association is a relationship between two

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

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

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

associations. ATTN: Move the association definition elsewhere

associations.

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

otherwise, false.

Boolean isAssociation() const

Boolean isAssociation() const;

{

_checkRep();

return _rep->isAssociation();

}

/// CIMMethod isAbstract

/** isAbstract Test if the CIMClass is abstract.

Boolean isAbstract() const

@return - True if the CIMClass Object is abstract

{

SeeAlso: Abstract

_checkRep();

return _rep->isAbstract();

Boolean isAbstract() const;

}

/** CIMMethod Gets the name of the class

/** getClassName Gets the name of the class

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

@return Returns string with the class name.

const String& getClassName() const

const String& getClassName() const;

{

_checkRep();

const CIMObjectPath& getPath() const;

return _rep->getClassName();

}

/**

Sets the object path for the class

@param path CIMObjectPath containing the object path

void setPath (const CIMObjectPath & path);

/** CIMMethod getSuperClassName - Gets the name of the Parent

/** getSuperClassName - Gets the name of the Parent

@return String with parent class name.

const String& getSuperClassName() const

const String& getSuperClassName() const;

{

_checkRep();

return _rep->getSuperClassName();

}

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

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

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

@param - String defining parent name.

@param String defining parent name.

@return Throws IllegalName if superClassName argument not legal CIM

identifier.

identifier

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

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

void setSuperClassName(const String& superClassName)

void setSuperClassName(const String& superClassName);

{

_checkRep();

_rep->setSuperClassName(superClassName);

}

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

/** 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 - CIMQualifier object representing the qualifier to be added

@param qualifier CIMQualifier object representing the qualifier to be

ATTN: Pointer to qualifier object.

added

@return Throws AlreadyExists.

@return Returns handle of the class object

@exception Throws AlreadyExists.

CIMClass& addQualifier(const CIMQualifier& qualifier);

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

input name if it exists in the class

@param name CIMName of the qualifier

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

@return Returns index of the qualifier found or PEG_NOT_FOUND

if not found.

Uint32 findQualifier(const String& name) const;

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

specified name exists in the class

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

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

Boolean existsQualifier(const String& name) const;

/** isTrueQualifier - Determines if the qualifier defined by

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

has a value of true.

This function is useful to quickly determine the state of a

qualifier.

@param String containing the qualifier name.

@return Boolean True if the qualifier exists,

CIMClass& addQualifier(const CIMQualifier& qualifier)

Boolean isTrueQualifier(const String& name) const;

{

_checkRep();

_rep->addQualifier(qualifier);

return *this;

}

/** CIMMethod findQualifier - Finds a qualifier with the specified input

name if it exists in the class @param name CIMName of the qualifier

to be found @return Position of the qualifier in the Class ATTN:

Clarify the return. What if not found, etc.

Uint32 findQualifier(const String& name)

{

_checkRep();

return _rep->findQualifier(name);

}

/** CIMMethod FindQualifier - ATTN:

@param name of the qualifier to be found

@return ATTN: Define this

Uint32 findQualifier(const String& name) const

{

_checkRep();

return _rep->findQualifier(name);

}

/** CIMMethod getQualifier - Gets the CIMQualifier object defined

/** getQualifier - Gets the CIMQualifier object defined

by the input parameter

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

findQualifier method

@return CIMQualifier object representing the qualifier found.

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

ATTN: what is error return here?

CIMQualifier handle will be null.

CIMQualifier getQualifier(Uint32 pos)

CIMQualifier getQualifier(Uint32 pos);

{

_checkRep();

return _rep->getQualifier(pos);

}

/// CIMMethod getQualifier - ATTN:

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

CIMConstQualifier getQualifier(Uint32 pos) const

from the qualifier list for this CIMClass.

{

_checkRep();

CIMConstQualifier getQualifier(Uint32 pos) const;

return _rep->getQualifier(pos);

}

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

/** CIMMethod getQualifierCount - Returns the number of qualifiers

/** getQualifierCount - Returns the number of qualifiers

in the class.

@return ATTN:

Uint32 getQualifierCount() const

Uint32 getQualifierCount() const;

{

_checkRep();

return _rep->getQualifierCount();

}

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

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

properties in the CIM class

CIMClass& addProperty(const CIMProperty& x)

CIMClass& addProperty(const CIMProperty& x);

{

_checkRep();

_rep->addProperty(x);

return *this;

}

/** CIMMethod removeProperty - Removes the property represented

/** findProperty - Finds the property object with the

by the position input parameter from the class

@param position parameter for the property to be removed from the

findPropety method

@return ATTN:

void removeProperty(Uint32 pos)

{

_checkRep();

_rep->removeProperty(pos);

}

/** CIMMethod findProperty - Finds the property object with the

name defined by the input parameter in the class.

@param String parameter with the property name.

@return position representing the property object found.

@return position representing the property object found or

ATTN: Clarify case of not found

PEG_NOT_FOUND if the property is not found.

Uint32 findProperty(const String& name)

Uint32 findProperty(const String& name) const;

{

_checkRep();

return _rep->findProperty(name);

}

/// CIMMethod findProperty

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

Uint32 findProperty(const String& name) const

name defined by the input parameter exists in the class.

{

@parm String parameter with the property name.

_checkRep();

@return True if the property object exists.

return _rep->findProperty(name);

}

Boolean existsProperty(const String& name) const;

/** CIMMethod getProperty - Returns a property representing the property

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

CIMProperty getProperty(Uint32 pos);

{

_checkRep();

return _rep->getProperty(pos);

}

/// CIMMethod getProperty - ATTN

/**getProperty Gets a property object from the CIMClass

ConstCIMProperty getProperty(Uint32 pos) const

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

{

@return Returns handle of the property object requested

_checkRep();

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

return _rep->getProperty(pos);

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

/** CIMMethod getProperty - Gets the count of the number of properties

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

Uint32 getPropertyCount() const;

{

_checkRep();

return _rep->getPropertyCount();

}

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

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

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

methods in the class

@param - method object representing the method to be added

@param method object representing the method to be added

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

@exception Throws AlreadyExists if the method already exists and throws

UninitializedHandle if the handle is not initialized

CIMClass& addMethod(const CIMMethod& x)

CIMClass& addMethod(const CIMMethod& x);

{

_checkRep();

_rep->addMethod(x);

return *this;

}

/** CIMMethod findMethod - Located the method object defined by the

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

name input

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

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

subsequent getmethod, etc. operations

Uint32 findMethod(const String& name)

Uint32 findMethod(const String& name) const;

{

_checkRep();

return _rep->findMethod(name);

}

/// CIMMethod findMethod - ATTN:

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

Uint32 findMethod(const String& name) const

name input exists

{

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

_checkRep();

@return True if the method exists

return _rep->findMethod(name);

}

Boolean existsMethod(const String& name) const;

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

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

input parameter.

@param ATTN:

@param pos Index to the method object to get

@ method object representing the method defined

@return Returns handle of the method requested

ATTN: Error???

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

than the number of methods defined in the class object

CIMMethod getMethod(Uint32 pos)

CIMMethod getMethod(Uint32 pos);

{

_checkRep();

return _rep->getMethod(pos);

}

/// CIMMethod getMethod - ATTN:

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

CIMConstMethod getMethod(Uint32 pos) const

parameter. This is the const version.

{

_checkRep();

return _rep->getMethod(pos);

CIMConstMethod getMethod(Uint32 pos) const;

}

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

/** removeMethod - Removes the method defined by the

@return integer representing the number of methods in the class

index parameter.

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

@return There is no return.

@exception Throw OutOfBound exception if the index is outside

the range of existing method objects for this class

Uint32 getMethodCount() const

void removeMethod(Uint32 pos);

{

_checkRep();

return _rep->getMethodCount();

}

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

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

qualifiers. Make sure the superClass really exists and is consistent

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

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

class feature.

ATTN: explain why this here

void resolve(

Uint32 getMethodCount() const;

DeclContext* declContext,

const String& nameSpace)

{

_checkRep();

_rep->resolve(declContext, nameSpace);

}

/// operator - ATTN:

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

operator int() const { return _rep != 0; }

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

/// CIMMethod toXML

Boolean hasKeys() const;

void toXml(Array<Sint8>& out) const

{

_checkRep();

_rep->toXml(out);

}

/// CIMMethod print

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

void print() const

CIMClass clone() const;

{

_checkRep();

_rep->print();

}

/** CIMMethod identical - Compares with another class

/** identical - Compares with another class

ATTN: Clarify exactly what identical means

@parm Class object for the class to be compared

@param Class object for the class to be compared

@return True if the classes are identical

Boolean identical(const ConstCIMClass& x) const;

Boolean identical(const CIMConstClass& x) const;

/// CIMMethod clone - ATTN:

#ifdef PEGASUS_INTERNALONLY

CIMClass clone() const

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

{

qualifiers. Make sure the superClass really exists and is consistent

return CIMClass(_rep->clone());

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

}

class feature.

ATTN: explain why this here

void resolve(

DeclContext* declContext,

const String& nameSpace);

void getKeyNames(Array<String>& keyNames) const

/// isNull - ATTN:

{

Boolean isNull() const;

_checkRep();

#endif

_rep->getKeyNames(keyNames);

}

private:

CIMClass(CIMClassRep* rep) : _rep(rep)

CIMClassRep* _rep;

{

}

void _checkRep() const

CIMClass(CIMClassRep* rep);

{

if (!_rep)

throw UnitializedHandle();

}

CIMClassRep* _rep;

void _checkRep() const;

friend class ConstCIMClass;

friend class CIMConstClass;

friend class CIMObject;

friend class CIMConstObject;

friend class XmlWriter;

friend class MofWriter;

};

/** ConstCIMClass

#define PEGASUS_ARRAY_T CIMClass

#include <Pegasus/Common/ArrayInter.h>

#undef PEGASUS_ARRAY_T

/** CIMConstClass - ATTN: define this.

class PEGASUS_COMMON_LINKAGE ConstCIMClass

class PEGASUS_COMMON_LINKAGE CIMConstClass

{

public:

ConstCIMClass() : _rep(0)

CIMConstClass();

{

}

CIMConstClass(const CIMConstClass& x);

ConstCIMClass(const ConstCIMClass& x)

CIMConstClass(const CIMClass& x);

{

Inc(_rep = x._rep);

}

ConstCIMClass(const CIMClass& x)

PEGASUS_EXPLICIT CIMConstClass(const CIMObject& x)

{

throw(DynamicCastFailed);

Inc(_rep = x._rep);

}

ConstCIMClass& operator=(const ConstCIMClass& x)

PEGASUS_EXPLICIT CIMConstClass(const CIMConstObject& x)

{

throw(DynamicCastFailed);

if (x._rep != _rep)

{

Dec(_rep);

Inc(_rep = x._rep);

}

return *this;

}

ConstCIMClass& operator=(const CIMClass& x)

{

if (x._rep != _rep)

{

Dec(_rep);

Inc(_rep = x._rep);

}

return *this;

}

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

CIMConstClass(

const CIMObjectPath& reference,

const String& superClassName = String::EMPTY);

ConstCIMClass(

CIMConstClass& operator=(const CIMConstClass& x);

const String& className,

const String& superClassName = String())

{

_rep = new CIMClassRep(className, superClassName);

}

~ConstCIMClass()

CIMConstClass& operator=(const CIMClass& x);

{

Dec(_rep);

}

Boolean isAssociation() const

~CIMConstClass();

{

_checkRep();

return _rep->isAssociation();

}

Boolean isAbstract() const

Boolean isAssociation() const;

{

_checkRep();

return _rep->isAbstract();

}

const String& getClassName() const

Boolean isAbstract() const;

{

_checkRep();

return _rep->getClassName();

}

const String& getSuperClassName() const

const String& getClassName() const;

{

_checkRep();

return _rep->getSuperClassName();

}

Uint32 findQualifier(const String& name) const

const CIMObjectPath& getPath() const;

{

_checkRep();

return _rep->findQualifier(name);

}

CIMConstQualifier getQualifier(Uint32 pos) const

const String& getSuperClassName() const;

{

_checkRep();

return _rep->getQualifier(pos);

}

Uint32 getQualifierCount() const

Uint32 findQualifier(const String& name) const;

{

_checkRep();

return _rep->getQualifierCount();

}

Uint32 findProperty(const String& name) const

CIMConstQualifier getQualifier(Uint32 pos) const;

{

_checkRep();

return _rep->findProperty(name);

}

ConstCIMProperty getProperty(Uint32 pos) const

Boolean isTrueQualifier(const String& name) const;

{

_checkRep();

return _rep->getProperty(pos);

}

Uint32 getPropertyCount() const

Uint32 getQualifierCount() const;

{

_checkRep();

return _rep->getPropertyCount();

}

Uint32 findMethod(const String& name) const

Uint32 findProperty(const String& name) const;

{

_checkRep();

return _rep->findMethod(name);

}

CIMConstMethod getMethod(Uint32 pos) const

CIMConstProperty getProperty(Uint32 pos) const;

{

_checkRep();

return _rep->getMethod(pos);

}

Uint32 getMethodCount() const

Uint32 getPropertyCount() const;

{

_checkRep();

return _rep->getMethodCount();

}

operator int() const { return _rep != 0; }

Uint32 findMethod(const String& name) const;

void toXml(Array<Sint8>& out) const

CIMConstMethod getMethod(Uint32 pos) const;

{

_checkRep();

_rep->toXml(out);

}

void print() const

Uint32 getMethodCount() const;

{

_checkRep();

_rep->print();

}

Boolean identical(const ConstCIMClass& x) const

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

{

x._checkRep();

_checkRep();

return _rep->identical(x._rep);

}

CIMClass clone() const

Boolean hasKeys() const;

{

return CIMClass(_rep->clone());

}

void getKeyNames(Array<String>& keyNames) const

CIMClass clone() const;

{

_checkRep();

_rep->getKeyNames(keyNames);

}

private:

Boolean identical(const CIMConstClass& x) const;

void _checkRep() const

#ifdef PEGASUS_INTERNALONLY

{

Boolean isNull() const;

if (!_rep)

#endif

throw UnitializedHandle();

}

private:

CIMClassRep* _rep;

void _checkRep() const;

friend class CIMClassRep;

friend class CIMClass;

friend class CIMInstanceRep;

friend class CIMObject;

friend class CIMConstObject;

friend class XmlWriter;

friend class MofWriter;

};

PEGASUS_NAMESPACE_END

#endif /* Pegasus_ClassDecl_h */

#endif /* Pegasus_CIMClass_h */

Legend:

Removed from v.1.3
changed lines
	Added in v.1.48

No CVS admin address has been configured