version 1.49, 2002/07/30 16:14:53
|
version 1.60, 2004/06/30 21:07:54
|
|
|
//%///////////////////////////////////////////////////////////////////////////// |
//%2003//////////////////////////////////////////////////////////////////////// |
// | // |
// Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM, |
// Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Development |
// The Open Group, Tivoli Systems |
// 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. |
// | // |
// Permission is hereby granted, free of charge, to any person obtaining a copy | // Permission is hereby granted, free of charge, to any person obtaining a copy |
// of this software and associated documentation files (the "Software"), to | // of this software and associated documentation files (the "Software"), to |
|
|
#include "XmlWriter.h" | #include "XmlWriter.h" |
#include "MofWriter.h" | #include "MofWriter.h" |
#include <Pegasus/Common/Tracer.h> | #include <Pegasus/Common/Tracer.h> |
|
#include <Pegasus/Common/MessageLoader.h> //l10n |
| |
PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
PEGASUS_USING_STD; | PEGASUS_USING_STD; |
|
|
| |
Boolean CIMClassRep::isAssociation() const | Boolean CIMClassRep::isAssociation() const |
{ | { |
Uint32 pos = findQualifier(CIMQualifierNames::ASSOCIATION); |
Uint32 index = findQualifier(CIMQualifierNames::ASSOCIATION); |
| |
if (pos == PEG_NOT_FOUND) |
if (index == PEG_NOT_FOUND) |
return false; | return false; |
| |
Boolean flag; | Boolean flag; |
| |
const CIMValue& value = getQualifier(pos).getValue(); |
const CIMValue& value = getQualifier(index).getValue(); |
| |
if (value.getType() != CIMTYPE_BOOLEAN) | if (value.getType() != CIMTYPE_BOOLEAN) |
return false; | return false; |
|
|
| |
Boolean CIMClassRep::isAbstract() const | Boolean CIMClassRep::isAbstract() const |
{ | { |
Uint32 pos = findQualifier(CIMQualifierNames::ABSTRACT); |
Uint32 index = findQualifier(CIMQualifierNames::ABSTRACT); |
| |
if (pos == PEG_NOT_FOUND) |
if (index == PEG_NOT_FOUND) |
return false; | return false; |
| |
Boolean flag; | Boolean flag; |
const CIMValue& value = getQualifier(pos).getValue(); |
const CIMValue& value = getQualifier(index).getValue(); |
| |
if (value.getType() != CIMTYPE_BOOLEAN) | if (value.getType() != CIMTYPE_BOOLEAN) |
return false; | return false; |
|
|
value.get(flag); | value.get(flag); |
return flag; | return flag; |
} | } |
|
|
Boolean CIMClassRep::isTrueQualifier(const CIMName& name) const |
|
{ |
|
Uint32 pos = findQualifier(name); |
|
|
|
if (pos == PEG_NOT_FOUND) |
|
return false; |
|
|
|
Boolean flag; |
|
const CIMValue& value = getQualifier(pos).getValue(); |
|
|
|
if (value.getType() != CIMTYPE_BOOLEAN) |
|
return false; |
|
|
|
value.get(flag); |
|
return flag; |
|
} |
|
|
|
void CIMClassRep::setSuperClassName(const CIMName& superClassName) | void CIMClassRep::setSuperClassName(const CIMName& superClassName) |
{ | { |
_superClassName = superClassName; | _superClassName = superClassName; |
|
|
| |
void CIMClassRep::addProperty(const CIMProperty& x) | void CIMClassRep::addProperty(const CIMProperty& x) |
{ | { |
if (x.isNull()) |
if (x.isUninitialized()) |
throw UninitializedHandle(); |
throw UninitializedObjectException(); |
| |
// Reject addition of duplicate property name: | // Reject addition of duplicate property name: |
| |
if (findProperty(x.getName()) != PEG_NOT_FOUND) |
if (findProperty(x.getName()) != PEG_NOT_FOUND){ |
throw AlreadyExists(); |
//l10n |
|
//throw AlreadyExistsException |
|
//("property \"" + x.getName().getString () + "\""); |
|
MessageLoaderParms parms("Common.CIMClassRep.PROPERTY", |
|
"property \"$0\"", |
|
x.getName().getString()); |
|
throw AlreadyExistsException(parms); |
| |
// Reject addition of references to non-associations: |
} |
|
|
|
// Reject addition of a reference property without a referenceClassName |
| |
if (!isAssociation() && x.getValue().getType() == CIMTYPE_REFERENCE) |
if ((x.getType() == CIMTYPE_REFERENCE) && |
throw AddedReferenceToClass(_reference.getClassName()); |
(x.getReferenceClassName().isNull())) |
|
{ |
|
throw TypeMismatchException(); |
|
} |
| |
// Set the class origin: | // Set the class origin: |
// ATTN: put this check in other places: | // ATTN: put this check in other places: |
|
|
| |
void CIMClassRep::addMethod(const CIMMethod& x) | void CIMClassRep::addMethod(const CIMMethod& x) |
{ | { |
if (x.isNull()) |
if (x.isUninitialized()) |
throw UninitializedHandle(); |
throw UninitializedObjectException(); |
| |
// Reject duplicate method names: | // Reject duplicate method names: |
| |
if (findMethod(x.getName()) != PEG_NOT_FOUND) |
if (findMethod(x.getName()) != PEG_NOT_FOUND){ |
throw AlreadyExists(); |
//l10n |
|
//throw AlreadyExistsException |
|
//("method \"" + x.getName().getString() + "\""); |
|
MessageLoaderParms parms("Common.CIMClassRep.METHOD", |
|
"method \"$0\"", |
|
x.getName().getString()); |
|
throw AlreadyExistsException(parms); |
|
|
|
} |
| |
// Add the method: | // Add the method: |
| |
|
|
return PEG_NOT_FOUND; | return PEG_NOT_FOUND; |
} | } |
| |
CIMMethod CIMClassRep::getMethod(Uint32 pos) |
CIMMethod CIMClassRep::getMethod(Uint32 index) |
{ | { |
if (pos >= _methods.size()) |
if (index >= _methods.size()) |
throw OutOfBounds(); |
throw IndexOutOfBoundsException(); |
| |
return _methods[pos]; |
return _methods[index]; |
} | } |
| |
Uint32 CIMClassRep::getMethodCount() const | Uint32 CIMClassRep::getMethodCount() const |
|
|
return _methods.size(); | return _methods.size(); |
} | } |
| |
void CIMClassRep::removeMethod(Uint32 pos) |
void CIMClassRep::removeMethod(Uint32 index) |
{ | { |
if (pos >= _methods.size()) |
if (index >= _methods.size()) |
throw OutOfBounds(); |
throw IndexOutOfBoundsException(); |
| |
_methods.remove(pos); |
_methods.remove(index); |
} | } |
| |
void CIMClassRep::resolve( | void CIMClassRep::resolve( |
|
|
| |
PEG_TRACE_STRING(TRC_OBJECTRESOLUTION, Tracer::LEVEL3, | PEG_TRACE_STRING(TRC_OBJECTRESOLUTION, Tracer::LEVEL3, |
String("CIMClassRep::resolve class = ") + | String("CIMClassRep::resolve class = ") + |
_reference.getClassName() + ", superclass = " + |
_reference.getClassName().getString() + ", superclass = " + |
_superClassName); |
_superClassName.getString()); |
| |
if (!_superClassName.isNull()) | if (!_superClassName.isNull()) |
{ | { |
|
|
CIMConstClass superClass | CIMConstClass superClass |
= context->lookupClass(nameSpace, _superClassName); | = context->lookupClass(nameSpace, _superClassName); |
| |
if (superClass.isNull()) |
if (superClass.isUninitialized()) |
throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_SUPERCLASS,_superClassName); |
throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_SUPERCLASS, |
|
_superClassName.getString()); |
|
|
| |
#if 0 | #if 0 |
if (!superClass._rep->_resolved) | if (!superClass._rep->_resolved) |
|
|
// set the class-origin: | // set the class-origin: |
//---------------------------------------------------------------------- | //---------------------------------------------------------------------- |
| |
|
Boolean isAssociationClass = isAssociation(); |
|
|
for (Uint32 i = 0, n = _properties.size(); i < n; i++) | for (Uint32 i = 0, n = _properties.size(); i < n; i++) |
{ | { |
CIMProperty& property = _properties[i]; | CIMProperty& property = _properties[i]; |
Uint32 pos = superClass.findProperty(property.getName()); |
|
| |
if (pos == PEG_NOT_FOUND) |
if (!isAssociationClass && |
|
property.getValue().getType() == CIMTYPE_REFERENCE) |
|
{ |
|
//l10n |
|
//throw PEGASUS_CIM_EXCEPTION(CIM_ERR_INVALID_PARAMETER, |
|
//"Non-assocation class contains reference property"); |
|
throw PEGASUS_CIM_EXCEPTION_L(CIM_ERR_INVALID_PARAMETER, |
|
MessageLoaderParms("Common.CIMClassRep.NON_ASSOCIATION_CLASS_CONTAINS_REFERENCE_PROPERTY", |
|
"Non-assocation class contains reference property")); |
|
|
|
} |
|
|
|
Uint32 index = superClass.findProperty(property.getName()); |
|
|
|
if (index == PEG_NOT_FOUND) |
{ | { |
Resolver::resolveProperty (property, context, | Resolver::resolveProperty (property, context, |
nameSpace, false, true); | nameSpace, false, true); |
|
|
else | else |
{ | { |
CIMConstProperty superClassProperty = | CIMConstProperty superClassProperty = |
superClass.getProperty(pos); |
superClass.getProperty(index); |
Resolver::resolveProperty (property, context, | Resolver::resolveProperty (property, context, |
nameSpace, false, superClassProperty, true); | nameSpace, false, superClassProperty, true); |
} | } |
|
|
// insert it (setting the propagated flag). Otherwise, change | // insert it (setting the propagated flag). Otherwise, change |
// the class-origin and propagated flag accordingly. | // the class-origin and propagated flag accordingly. |
| |
Uint32 pos = PEG_NOT_FOUND; |
Uint32 index = PEG_NOT_FOUND; |
/* ATTN: KS move to simpler version of the find | /* ATTN: KS move to simpler version of the find |
for (Uint32 j = m, n = _properties.size(); j < n; j++) | for (Uint32 j = m, n = _properties.size(); j < n; j++) |
{ | { |
if (CIMName::equal(_properties[j].getName(), | if (CIMName::equal(_properties[j].getName(), |
superClassProperty.getName())) | superClassProperty.getName())) |
{ | { |
pos = j; |
index = j; |
break; | break; |
} | } |
} | } |
*/ | */ |
pos = findProperty(superClassProperty.getName()); |
index = findProperty(superClassProperty.getName()); |
| |
// If property exists in super class but not in this one, then | // If property exists in super class but not in this one, then |
// clone and insert it. Otherwise, the properties class | // clone and insert it. Otherwise, the properties class |
// origin was set above. | // origin was set above. |
| |
CIMProperty superproperty = superClassProperty.clone(true); |
CIMProperty superproperty = superClassProperty.clone(); |
| |
if (pos == PEG_NOT_FOUND) |
if (index == PEG_NOT_FOUND) |
{ | { |
superproperty.setPropagated(true); | superproperty.setPropagated(true); |
_properties.insert(m++, superproperty); | _properties.insert(m++, superproperty); |
|
|
// If a qualifier is defined on the superclass's property | // If a qualifier is defined on the superclass's property |
// but not on the subclass's, then add it to the subclass's | // but not on the subclass's, then add it to the subclass's |
// property's qualifier list. | // property's qualifier list. |
CIMProperty subproperty = _properties[pos]; |
CIMProperty subproperty = _properties[index]; |
for (Uint32 i = 0, n = superproperty.getQualifierCount(); | for (Uint32 i = 0, n = superproperty.getQualifierCount(); |
i < n; i++) | i < n; i++) |
{ | { |
Uint32 pos = PEG_NOT_FOUND; |
Uint32 index = PEG_NOT_FOUND; |
CIMQualifier superClassQualifier = | CIMQualifier superClassQualifier = |
superproperty.getQualifier(i); | superproperty.getQualifier(i); |
const CIMName name = superClassQualifier.getName(); | const CIMName name = superClassQualifier.getName(); |
|
|
CIMConstQualifier q = subproperty.getQualifier(j); | CIMConstQualifier q = subproperty.getQualifier(j); |
if (name.equal(q.getName())) | if (name.equal(q.getName())) |
{ | { |
pos = j; |
index = j; |
break; | break; |
} | } |
} // end comparison of subclass property's qualifiers | } // end comparison of subclass property's qualifiers |
if (pos == PEG_NOT_FOUND) |
if (index == PEG_NOT_FOUND) |
{ | { |
subproperty.addQualifier(superClassQualifier); | subproperty.addQualifier(superClassQualifier); |
} | } |
/* | /* |
if ((pos = subproperty.findQualifier(name)) == PEG_NOT_FOUND) |
if ((index = subproperty.findQualifier(name)) == PEG_NOT_FOUND) |
{ | { |
subproperty.addQualifier(superClassQualifier); | subproperty.addQualifier(superClassQualifier); |
} | } |
|
|
for (Uint32 i = 0, n = _methods.size(); i < n; i++) | for (Uint32 i = 0, n = _methods.size(); i < n; i++) |
{ | { |
CIMMethod& method = _methods[i]; | CIMMethod& method = _methods[i]; |
Uint32 pos = superClass.findMethod(method.getName()); |
Uint32 index = superClass.findMethod(method.getName()); |
| |
if (pos == PEG_NOT_FOUND) |
if (index == PEG_NOT_FOUND) |
{ | { |
Resolver::resolveMethod (method, context, | Resolver::resolveMethod (method, context, |
nameSpace); | nameSpace); |
} | } |
else | else |
{ | { |
CIMConstMethod superClassMethod = superClass.getMethod(pos); |
CIMConstMethod superClassMethod = superClass.getMethod(index); |
Resolver::resolveMethod (method, context, | Resolver::resolveMethod (method, context, |
nameSpace, superClassMethod); | nameSpace, superClassMethod); |
} | } |
|
|
// insert it (setting the propagated flag). Otherwise, change | // insert it (setting the propagated flag). Otherwise, change |
// the class-origin and propagated flag accordingly. | // the class-origin and propagated flag accordingly. |
| |
Uint32 pos = PEG_NOT_FOUND; |
Uint32 index = PEG_NOT_FOUND; |
/********************** KS move to simpler version | /********************** KS move to simpler version |
for (Uint32 j = m, n = _methods.size(); j < n; j++) | for (Uint32 j = m, n = _methods.size(); j < n; j++) |
{ | { |
if (CIMName::equal(_methods[j].getName(), | if (CIMName::equal(_methods[j].getName(), |
superClassMethod.getName())) | superClassMethod.getName())) |
{ | { |
pos = j; |
index = j; |
break; | break; |
} | } |
} | } |
|
|
// clone and insert it. Otherwise, the method's class origin | // clone and insert it. Otherwise, the method's class origin |
// has already been set above. | // has already been set above. |
| |
if (pos == PEG_NOT_FOUND) |
if (index == PEG_NOT_FOUND) |
{ | { |
CIMMethod method = superClassMethod.clone(); | CIMMethod method = superClassMethod.clone(); |
method.setPropagated(true); | method.setPropagated(true); |
_methods.insert(m++, method); | _methods.insert(m++, method); |
} | } |
*/ | */ |
if((pos = findMethod(superClassMethod.getName())) == PEG_NOT_FOUND) |
if((index = findMethod(superClassMethod.getName())) == PEG_NOT_FOUND) |
{ | { |
CIMMethod method = superClassMethod.clone(); | CIMMethod method = superClassMethod.clone(); |
method.setPropagated(true); | method.setPropagated(true); |
|
|
// _resolved = true; | // _resolved = true; |
} | } |
| |
|
CIMInstance CIMClassRep::createInstance(Boolean includeQualifiers, |
|
Boolean includeClassOrigin, |
|
const CIMPropertyList& propertyList) const |
|
{ |
|
|
|
// Create the new instance |
|
CIMInstance newInstance(_reference.getClassName()); |
|
|
|
// Copy qualifiers if required |
|
if (includeQualifiers) |
|
{ |
|
for (Uint32 i = 0 ; i < getQualifierCount() ; i++) |
|
{ |
|
newInstance.addQualifier(getQualifier(i).clone()); |
|
} |
|
} |
|
|
|
// Copy Properties |
|
for (Uint32 i = 0 ; i < _properties.size() ; i++) |
|
{ |
|
CIMConstProperty p = getProperty(i); |
|
CIMName name = p.getName(); |
|
Array<CIMName> pl = propertyList.getPropertyNameArray(); |
|
if (propertyList.isNull() || Contains(pl, name)) |
|
{ |
|
CIMProperty p = getProperty(i).clone(); |
|
if (!includeQualifiers && p.getQualifierCount() != 0) |
|
{ |
|
for (Uint32 j = 0 ; j < getQualifierCount() ; j++) |
|
{ |
|
p.removeQualifier(i - 1); |
|
} |
|
} |
|
if (!includeClassOrigin) |
|
{ |
|
p.setClassOrigin(CIMName()); |
|
} |
|
newInstance.addProperty(p); |
|
|
|
// Delete class origin attribute if required |
|
} |
|
} |
|
|
|
return(newInstance); |
|
} |
|
|
void CIMClassRep::toXml(Array<Sint8>& out) const | void CIMClassRep::toXml(Array<Sint8>& out) const |
{ | { |
// Class opening element: | // Class opening element: |
|
|
// format the Properties: | // format the Properties: |
for (Uint32 i = 0, n = _properties.size(); i < n; i++) | for (Uint32 i = 0, n = _properties.size(); i < n; i++) |
{ | { |
// Generate MOF if this property not propogated |
// Generate MOF if this property not propagated |
// Note that the test is required only because | // Note that the test is required only because |
// there is an error in getclass that does not | // there is an error in getclass that does not |
// test the localOnly flag. | // test the localOnly flag. |
|
|
if (!tmprep) | if (!tmprep) |
return false; | return false; |
| |
if (_superClassName != tmprep->_superClassName) |
if (!_superClassName.equal (tmprep->_superClassName)) |
return false; | return false; |
| |
// | // |
|
|
if (!tmp1[i].identical(tmp2[i])) | if (!tmp1[i].identical(tmp2[i])) |
return false; | return false; |
| |
if (tmp1[i].getClassOrigin() != tmp2[i].getClassOrigin()) |
if (!tmp1[i].getClassOrigin().equal (tmp2[i].getClassOrigin())) |
return false; | return false; |
| |
if (tmp1[i].getPropagated() != tmp2[i].getPropagated()) | if (tmp1[i].getPropagated() != tmp2[i].getPropagated()) |
|
|
{ | { |
CIMConstProperty property = getProperty(i); | CIMConstProperty property = getProperty(i); |
| |
if (property.isKey()) |
Uint32 index; |
|
if ((index = property.findQualifier (CIMName ("key"))) != PEG_NOT_FOUND) |
|
{ |
|
CIMValue value; |
|
value = property.getQualifier (index).getValue (); |
|
if (!value.isNull ()) |
|
{ |
|
Boolean isKey; |
|
value.get (isKey); |
|
if (isKey) |
keyNames.append(property.getName()); | keyNames.append(property.getName()); |
} | } |
} | } |
|
} |
|
} |
| |
Boolean CIMClassRep::hasKeys() const | Boolean CIMClassRep::hasKeys() const |
{ | { |
|
|
{ | { |
CIMConstProperty property = getProperty(i); | CIMConstProperty property = getProperty(i); |
| |
if (getProperty(i).isKey()) |
Uint32 index; |
|
if ((index = property.findQualifier (CIMName ("key"))) != PEG_NOT_FOUND) |
|
{ |
|
CIMValue value; |
|
value = property.getQualifier (index).getValue (); |
|
if (!value.isNull ()) |
|
{ |
|
Boolean isKey; |
|
value.get (isKey); |
|
if (isKey) |
return true; | return true; |
} | } |
|
} |
|
} |
| |
return false; | return false; |
} | } |