version 1.11, 2001/05/06 13:16:16
|
version 1.72, 2006/01/30 16:16:46
|
|
|
//%///////////////////////////////////////////////////////////////////////////// |
//%2006//////////////////////////////////////////////////////////////////////// |
// | // |
// Copyright (c) 2000 The Open Group, BMC Software, Tivoli Systems, IBM |
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development |
|
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. |
|
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.; |
|
// IBM Corp.; EMC Corporation, The Open Group. |
|
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.; |
|
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. |
|
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
|
// EMC Corporation; VERITAS Software Corporation; The Open Group. |
|
// Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
|
// EMC Corporation; Symantec Corporation; The Open Group. |
// | // |
// 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 SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN |
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED |
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT |
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR |
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT |
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
// DEALINGS IN THE SOFTWARE. |
// 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: |
|
// |
|
//%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
| |
#ifndef Pegasus_CIMClass_h | #ifndef Pegasus_CIMClass_h |
#define Pegasus_CIMClass_h | #define Pegasus_CIMClass_h |
| |
#include <Pegasus/Common/Config.h> | #include <Pegasus/Common/Config.h> |
#include <Pegasus/Common/CIMClassRep.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 | PEGASUS_NAMESPACE_BEGIN |
| |
class CIMConstClass; | class CIMConstClass; |
|
class CIMClassRep; |
|
class Resolver; |
| |
/** 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 |
|
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). |
|
*/ |
|
| |
|
/** The CIMClass class is used to represent CIM classes in Pegasus. |
|
*/ |
class PEGASUS_COMMON_LINKAGE CIMClass | class PEGASUS_COMMON_LINKAGE CIMClass |
{ | { |
public: | 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(); |
|
|
|
/** 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); |
|
|
|
/** Creates a new CIMClass object representing a CIMClass from the given |
|
CIMObject Object. |
|
@param x CIMObject object from which to create the CIMClass object. |
|
@exception DynamicCastFailedException If a CIMClass can not be |
|
created from the given CIMObject. |
|
*/ |
|
PEGASUS_EXPLICIT CIMClass(const CIMObject& x); |
|
|
|
/** 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 NewClass("MyClass", "YourClass"); |
|
</pre> |
*/ | */ |
CIMClass() : _rep(0) |
CIMClass( |
{ |
const CIMName& className, |
|
const CIMName& superClassName = CIMName()); |
| |
} |
/// |
|
CIMClass& operator=(const CIMClass& x); |
| |
/** Constructor - Creates a class from a previous class |
/// Destructor |
*/ |
~CIMClass(); |
CIMClass(const CIMClass& x) |
|
{ |
|
Inc(_rep = x._rep); |
|
} |
|
| |
/// Operator = Assigns the CIM Class constructor. |
/** Identifies whether or not this CIM class is an association. An |
CIMClass& operator=(const CIMClass& x) |
association is a relationship between two (or more) classes or |
{ |
instances of two classes. The properties of an association class |
if (x._rep != _rep) |
include pointers, or references, to the two (or more) instances. |
{ |
All CIM classes can be included in one or more associations. |
Dec(_rep); |
@return true if this CIM class is an association, false |
Inc(_rep = x._rep); |
otherwise. |
} |
*/ |
return *this; |
Boolean isAssociation() const; |
} |
|
|
|
/** Constructor - Creates a Class from inputs of a classname and |
|
SuperClassName |
|
@param className String representing name of the class being created |
|
@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> |
|
| |
|
/** Tests if the CIMClass is abstract. |
|
@return true if the CIMClass Object is abstract, false otherwise. |
*/ | */ |
CIMClass( |
Boolean isAbstract() const; |
const String& className, |
|
const String& superClassName = String()) |
|
{ |
|
_rep = new CIMClassRep(className, superClassName); |
|
} |
|
| |
/// Destructor |
|
~CIMClass() |
|
{ |
|
Dec(_rep); |
|
} |
|
| |
/** isAssociation - Identifies whether or not this CIM class |
/** Gets the name of the class represented by this CIM object. |
is an association. An association is a relationship between two |
@return CIMName with the class name. |
(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 |
|
@return Boolean True if this CIM class belongs to an association; |
|
otherwise, false. |
|
*/ | */ |
Boolean isAssociation() const |
const CIMName& getClassName() const; |
{ |
|
_checkRep(); |
|
return _rep->isAssociation(); |
|
} |
|
| |
/// CIMMethod isAbstract |
/// |
Boolean isAbstract() const |
const CIMObjectPath& getPath() const; |
{ |
|
_checkRep(); |
/** Sets the object path for the class. |
return _rep->isAbstract(); |
@param path CIMObjectPath containing the object path. |
} |
|
|
|
/** 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 |
void setPath (const CIMObjectPath & path); |
{ |
|
_checkRep(); |
|
return _rep->getClassName(); |
|
} |
|
| |
/** CIMMethod getSuperClassName - Gets the name of the Parent |
/** Gets the name of the Parent class of this CIM Object. |
@return String with parent class name. |
@return CIMName with parent class name. |
*/ | */ |
const String& getSuperClassName() const |
const CIMName& getSuperClassName() const; |
{ |
|
_checkRep(); |
/** Sets the name of the parent class from the input |
return _rep->getSuperClassName(); |
parameter. |
} |
@param superClassName - CIMName defining parent class name. |
|
|
/** CIMMethod setSuperClassName - Sets the name of the parent class from |
|
the input parameter. \REF{CLASSNAME}. ATTN: Define legal classnames |
|
@param String defining parent name. |
|
@return Throws IllegalName if superClassName argument not legal CIM |
|
identifier |
|
@exception throws IllegalName if the name is not correct. See |
|
\URL[ClassNames]{DefinitionofTerms.html#CLASSNAME} |
|
*/ | */ |
void setSuperClassName(const String& superClassName) |
void setSuperClassName(const CIMName& superClassName); |
{ |
|
_checkRep(); |
/** Adds the specified qualifier to the class and increments the |
_rep->setSuperClassName(superClassName); |
qualifier count. It is illegal to add the same qualifier more |
} |
than one time. |
|
@param qualifier CIMQualifier object representing the qualifier |
/** addQualifier - Adds the specified qualifier to the class |
to be added. |
and increments the qualifier count. It is illegal to add the same |
@return the CIMClass object. |
qualifier more than one time. |
@exception AlreadyExistsException if the qualifier already exists. |
@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) |
CIMClass& addQualifier(const CIMQualifier& qualifier); |
{ |
|
_checkRep(); |
/** Searches for a qualifier with the specified input name if it |
_rep->addQualifier(qualifier); |
exists in the class. |
return *this; |
@param name CIMName of the qualifier to be found |
} |
@return Index of the qualifier found or PEG_NOT_FOUND |
|
if not found. |
/** 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 -1 if not found. |
|
*/ | */ |
Uint32 findQualifier(const String& name) |
Uint32 findQualifier(const CIMName& name) const; |
{ |
|
_checkRep(); |
/** Gets the CIMQualifier object defined by the input parameter. |
return _rep->findQualifier(name); |
@param index Index of the qualifier in the class from the |
} |
findQualifier method. |
/// |
|
Uint32 findQualifier(const String& name) const |
|
{ |
|
_checkRep(); |
|
return _rep->findQualifier(name); |
|
} |
|
|
|
/** 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. |
ATTN: what is error return here? |
On error, CIMQualifier object will be null. |
|
@exception IndexOutOfBoundsException exception if the index is |
|
outside the range of parameters available from the CIMClass. |
*/ | */ |
CIMQualifier getQualifier(Uint32 pos) |
CIMQualifier getQualifier(Uint32 index); |
{ |
|
_checkRep(); |
|
return _rep->getQualifier(pos); |
|
} |
|
| |
/// getQualifier - ATTN: |
/** Gets the qualifier defined by the input parameter from the |
CIMConstQualifier getQualifier(Uint32 pos) const |
qualifier list for this CIMClass. |
{ |
@param index Index of the qualifier in the CIM class. |
_checkRep(); |
@return CIMConstQualifier object representing the qualifier |
return _rep->getQualifier(pos); |
found. On error, CIMConstQualifier object will be null. |
} |
@exception IndexOutOfBoundsException exception if the index is |
|
outside the range of parameters available from the CIMClass. |
/** getQualifierCount - Returns the number of qualifiers |
|
in the class. |
|
@return ATTN: |
|
*/ | */ |
Uint32 getQualifierCount() const |
CIMConstQualifier getQualifier(Uint32 index) const; |
{ |
|
_checkRep(); |
|
return _rep->getQualifierCount(); |
|
} |
|
| |
/** addProperty - Adds the specified property object to the |
/** Removes the qualifier defined by the index parameter. |
properties in the CIM class |
@param index Defines the index of the qualifier to be removed. |
|
@exception IndexOutOfBoundsException if the index is outside |
|
the range of existing qualifier objects for this class. |
*/ | */ |
CIMClass& addProperty(const CIMProperty& x) |
void removeQualifier(Uint32 index); |
{ |
|
_checkRep(); |
/** Gets the count of the number of qualifiers defined in the class. |
_rep->addProperty(x); |
@return the number of qualifiers in the class definition (not |
return *this; |
those on properties or methods) |
} |
|
|
|
/** 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) |
Uint32 getQualifierCount() const; |
{ |
|
_checkRep(); |
/** Adds the specified property object to the properties in |
_rep->removeProperty(pos); |
the CIM class |
} |
@param x CIMProperty to be added to the CIM Class. |
|
@return CIMClass object after the specified property is added. |
/** 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 or -1 if the |
|
property is not found. |
|
*/ | */ |
Uint32 findProperty(const String& name) |
CIMClass& addProperty(const CIMProperty& x); |
{ |
|
_checkRep(); |
|
return _rep->findProperty(name); |
|
} |
|
| |
Uint32 findProperty(const String& name) const |
/** Finds the property object with the name defined by the |
{ |
input parameter in the class. |
_checkRep(); |
@param name CIMName with the property name to be found. |
return _rep->findProperty(name); |
@return Index of the property object found or |
} |
PEG_NOT_FOUND if the property is not found. |
|
|
/** 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) |
Uint32 findProperty(const CIMName& name) const; |
{ |
|
_checkRep(); |
/** Gets a property object from the CIMClass. |
return _rep->getProperty(pos); |
@param index Index for the property object to get. |
} |
@return CIMProperty object requested. |
|
@exception IndexOutOfBoundsException if the index is outside |
/**getProperty Gets a property object from the CIMClass |
the range of properties in this class. |
@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 |
CIMProperty getProperty(Uint32 index); |
{ |
|
_checkRep(); |
/** Gets a property object from the CIMClass. |
return _rep->getProperty(pos); |
@param index Index for the property object to get. |
} |
@return CIMProperty object requested. |
|
@exception IndexOutOfBoundsException if the index is outside |
/** getProperty - Gets the count of the number of properties |
the range of properties in this class. |
defined in the class. |
|
@return count of number of proerties in the class |
|
*/ | */ |
Uint32 getPropertyCount() const |
CIMConstProperty getProperty(Uint32 index) const; |
{ |
|
_checkRep(); |
/** Removes the specified property from the class. |
return _rep->getPropertyCount(); |
@param index Index of the property to be removed. |
} |
@exception IndexOutOfBoundsException if the index is outside |
|
the range of properties in this class. |
/** 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 |
|
@return Returns the CIMClass object to which the method was added. |
|
@exception Throws AlreadyExists if the method already exists and throws |
|
UnitializedHandle if the handle is not initialized |
|
*/ | */ |
CIMClass& addMethod(const CIMMethod& x) |
void removeProperty(Uint32 index); |
{ |
|
_checkRep(); |
/** Gets the count of the number of properties defined in the class. |
_rep->addMethod(x); |
@return count of number of properties in the class. |
return *this; |
|
} |
|
|
|
/** findMethod - Located 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 getPropertyCount() const; |
{ |
|
_checkRep(); |
|
return _rep->findMethod(name); |
|
} |
|
| |
Uint32 findMethod(const String& name) const |
/** Adds the method object defined by the input parameter to the |
{ |
class and increments the count of the number of methods in the class. |
_checkRep(); |
@param name CIMMethod object representing the method to be added. |
return _rep->findMethod(name); |
@return the CIMClass object to which the method was added. |
} |
@exception AlreadyExistsException if the method already exists. |
|
@exception UninitializedObjectException if the object is not initialized. |
/** getMethod - Gets the method object defined by the |
|
input parameter. |
|
@param pos Index to the CIMMethod object to get |
|
@return Returns handle of the CIMMethod requested |
|
@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) |
CIMClass& addMethod(const CIMMethod& x); |
{ |
|
_checkRep(); |
|
return _rep->getMethod(pos); |
|
} |
|
| |
/** 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. |
_checkRep(); |
@return CIMMethod object of the method requested. |
return _rep->getMethod(pos); |
@exception IndexOutOfBoundsException if the index is outside |
} |
the range of methods in this class. |
|
*/ |
|
CIMMethod getMethod(Uint32 index); |
| |
/** CIMMethod 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; |
{ |
|
_checkRep(); |
|
return _rep->getMethodCount(); |
|
} |
|
|
|
/** Resolve - Resolve the class: inherit any properties and |
|
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( |
|
DeclContext* declContext, |
|
const String& nameSpace) |
|
{ |
|
_checkRep(); |
|
_rep->resolve(declContext, nameSpace); |
|
} |
|
| |
/// operator - ATTN: |
/** Removes the method defined by the index parameter. |
operator int() const { return _rep != 0; } |
@param index Defines the index of the method to be removed. |
|
@exception IndexOutOfBoundsException if the index is outside |
|
the range of methods in this class. |
|
*/ |
|
void removeMethod(Uint32 index); |
| |
/// CIMMethod toXML |
/** Gets the count of the number of methods in the class. |
void toXml(Array<Sint8>& out) const |
@return the count of the number of methods in the class object. |
{ |
*/ |
_checkRep(); |
Uint32 getMethodCount() const; |
_rep->toXml(out); |
|
} |
|
| |
/// CIMMethod print |
/// Get names of all keys of this class. |
void print(std::ostream &o=std::cout) const |
void getKeyNames(Array<CIMName>& keyNames) const; |
{ |
|
_checkRep(); |
/** Determines if the object has keys. |
_rep->print(o); |
@return true if the object has keys, false otherwise. |
} |
*/ |
|
Boolean hasKeys() const; |
/** CIMMethod identical - Compares with another class |
|
ATTN: Clarify exactly what identical means |
/** Makes a deep copy (clone) of the given object. |
@param Class object for the class to be compared |
@return copy of the CIMClass object. |
@return True if the classes are identical |
*/ |
|
CIMClass clone() const; |
|
|
|
/** Compares with another CIM class. |
|
@param x Class object for the class to be compared. |
|
@return true if the classes are identical, false otherwise. |
*/ | */ |
Boolean identical(const CIMConstClass& x) const; | Boolean identical(const CIMConstClass& x) const; |
| |
/// CIMMethod clone - ATTN: |
/** Determines if the object has not been initialized. |
CIMClass clone() const |
@return true if the object has not been initialized, |
{ |
false otherwise. |
return CIMClass(_rep->clone()); |
*/ |
} |
Boolean isUninitialized() const; |
|
|
|
#ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES |
|
/** <I><B>Experimental Interface</B></I><BR> |
|
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. |
| |
void getKeyNames(Array<String>& keyNames) const |
@return CIMInstance of this class appropriately initialized. |
{ |
<p><b>Example:</b> |
_checkRep(); |
<pre> |
_rep->getKeyNames(keyNames); |
CIMClass myClass .. a defined and complete CIMClass. |
} |
// create instance with qualifiers, class origin and all properties |
|
CIMInstance myInstance = |
|
myClass.buildInstance(true, true, CIMPropertyList()); |
|
</pre> |
|
*/ |
|
CIMInstance buildInstance(Boolean includeQualifiers, |
|
Boolean includeClassOrigin, |
|
const CIMPropertyList & propertyList) const; |
|
#endif |
| |
private: | private: |
| |
CIMClass(CIMClassRep* rep) : _rep(rep) |
CIMClassRep* _rep; |
{ |
|
} |
|
| |
void _checkRep() const |
CIMClass(CIMClassRep* rep); |
{ |
|
if (!_rep) |
void _checkRep() const; |
throw UnitializedHandle(); |
|
} |
|
| |
CIMClassRep* _rep; |
|
friend class CIMConstClass; | friend class CIMConstClass; |
|
friend class CIMObject; |
|
friend class CIMConstObject; |
|
friend class Resolver; |
|
friend class XmlWriter; |
|
friend class MofWriter; |
|
friend class BinaryStreamer; |
}; | }; |
| |
/** CIMConstClass - ATTN: define this. |
#define PEGASUS_ARRAY_T CIMClass |
|
#include <Pegasus/Common/ArrayInter.h> |
*/ |
#undef PEGASUS_ARRAY_T |
| |
|
/// CIMConstClass |
class PEGASUS_COMMON_LINKAGE CIMConstClass | class PEGASUS_COMMON_LINKAGE CIMConstClass |
{ | { |
public: | public: |
| |
CIMConstClass() : _rep(0) |
/// |
{ |
CIMConstClass(); |
| |
} |
/// |
|
CIMConstClass(const CIMConstClass& x); |
| |
CIMConstClass(const CIMConstClass& x) |
/// |
{ |
CIMConstClass(const CIMClass& x); |
Inc(_rep = x._rep); |
|
} |
|
| |
CIMConstClass(const CIMClass& x) |
/// |
{ |
PEGASUS_EXPLICIT CIMConstClass(const CIMObject& x); |
Inc(_rep = x._rep); |
|
} |
|
| |
CIMConstClass& operator=(const CIMConstClass& x) |
/// |
{ |
PEGASUS_EXPLICIT CIMConstClass(const CIMConstObject& x); |
if (x._rep != _rep) |
|
{ |
|
Dec(_rep); |
|
Inc(_rep = x._rep); |
|
} |
|
return *this; |
|
} |
|
| |
CIMConstClass& operator=(const CIMClass& x) |
/// |
{ |
CIMConstClass( |
if (x._rep != _rep) |
const CIMName& className, |
{ |
const CIMName& superClassName = CIMName()); |
Dec(_rep); |
|
Inc(_rep = x._rep); |
|
} |
|
return *this; |
|
} |
|
| |
// Throws IllegalName if className argument not legal CIM identifier. |
/// |
|
CIMConstClass& operator=(const CIMConstClass& x); |
| |
CIMConstClass( |
/// |
const String& className, |
CIMConstClass& operator=(const CIMClass& x); |
const String& superClassName = String()) |
|
{ |
|
_rep = new CIMClassRep(className, superClassName); |
|
} |
|
| |
~CIMConstClass() |
/// |
{ |
~CIMConstClass(); |
Dec(_rep); |
|
} |
|
| |
Boolean isAssociation() const |
/// |
{ |
Boolean isAssociation() const; |
_checkRep(); |
|
return _rep->isAssociation(); |
|
} |
|
| |
Boolean isAbstract() const |
/// |
{ |
Boolean isAbstract() const; |
_checkRep(); |
|
return _rep->isAbstract(); |
|
} |
|
| |
const String& getClassName() const |
/// |
{ |
const CIMName& getClassName() const; |
_checkRep(); |
|
return _rep->getClassName(); |
|
} |
|
| |
const String& getSuperClassName() const |
/// |
{ |
const CIMObjectPath& getPath() const; |
_checkRep(); |
|
return _rep->getSuperClassName(); |
|
} |
|
| |
Uint32 findQualifier(const String& name) const |
/// |
{ |
const CIMName& getSuperClassName() const; |
_checkRep(); |
|
return _rep->findQualifier(name); |
|
} |
|
| |
CIMConstQualifier getQualifier(Uint32 pos) const |
/// |
{ |
Uint32 findQualifier(const CIMName& name) const; |
_checkRep(); |
|
return _rep->getQualifier(pos); |
|
} |
|
| |
Uint32 getQualifierCount() const |
/// |
{ |
CIMConstQualifier getQualifier(Uint32 index) const; |
_checkRep(); |
|
return _rep->getQualifierCount(); |
|
} |
|
| |
Uint32 findProperty(const String& name) const |
/// |
{ |
Uint32 getQualifierCount() const; |
_checkRep(); |
|
return _rep->findProperty(name); |
|
} |
|
| |
CIMConstProperty getProperty(Uint32 pos) const |
/// |
{ |
Uint32 findProperty(const CIMName& name) const; |
_checkRep(); |
|
return _rep->getProperty(pos); |
|
} |
|
| |
Uint32 getPropertyCount() const |
/// |
{ |
CIMConstProperty getProperty(Uint32 index) const; |
_checkRep(); |
|
return _rep->getPropertyCount(); |
|
} |
|
| |
Uint32 findMethod(const String& name) const |
/// |
{ |
Uint32 getPropertyCount() const; |
_checkRep(); |
|
return _rep->findMethod(name); |
|
} |
|
| |
CIMConstMethod getMethod(Uint32 pos) const |
/// |
{ |
Uint32 findMethod(const CIMName& name) const; |
_checkRep(); |
|
return _rep->getMethod(pos); |
|
} |
|
| |
Uint32 getMethodCount() const |
/// |
{ |
CIMConstMethod getMethod(Uint32 index) const; |
_checkRep(); |
|
return _rep->getMethodCount(); |
|
} |
|
| |
operator int() const { return _rep != 0; } |
/// |
|
Uint32 getMethodCount() const; |
| |
void toXml(Array<Sint8>& out) const |
/// |
{ |
void getKeyNames(Array<CIMName>& keyNames) const; |
_checkRep(); |
|
_rep->toXml(out); |
|
} |
|
| |
void print(std::ostream &o=std::cout) const |
/// |
{ |
Boolean hasKeys() const; |
_checkRep(); |
|
_rep->print(o); |
|
} |
|
| |
Boolean identical(const CIMConstClass& x) const |
/// |
{ |
CIMClass clone() const; |
x._checkRep(); |
|
_checkRep(); |
|
return _rep->identical(x._rep); |
|
} |
|
| |
CIMClass clone() const |
/// |
{ |
Boolean identical(const CIMConstClass& x) const; |
return CIMClass(_rep->clone()); |
|
} |
|
| |
void getKeyNames(Array<String>& keyNames) const |
/// |
{ |
Boolean isUninitialized() const; |
_checkRep(); |
|
_rep->getKeyNames(keyNames); |
|
} |
|
| |
private: | private: |
| |
void _checkRep() const |
|
{ |
|
if (!_rep) |
|
throw UnitializedHandle(); |
|
} |
|
|
|
CIMClassRep* _rep; | CIMClassRep* _rep; |
| |
|
void _checkRep() const; |
|
|
friend class CIMClassRep; | friend class CIMClassRep; |
friend class CIMClass; | friend class CIMClass; |
friend class CIMInstanceRep; | friend class CIMInstanceRep; |
|
friend class CIMObject; |
|
friend class CIMConstObject; |
|
friend class XmlWriter; |
|
friend class MofWriter; |
|
friend class BinaryStreamer; |
}; | }; |
| |
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |
| |
#endif /* Pegasus_CIMClass_h */ | #endif /* Pegasus_CIMClass_h */ |
|
|
|
|