PEGASUS_NAMESPACE_BEGIN
// This operator is needed to allow BubbleSort to operate on CIMQualifierDecls.
Boolean operator>(const CIMQualifierDecl& q1, const CIMQualifierDecl& q2)
{
return q1.getName().getString() > q2.getName().getString();
}
Boolean ProcessValueObjectElement(CIMRepository& repository, XmlParser& parser)
{
XmlEntry entry;
if (!XmlReader::testStartTag(parser, entry, "VALUE.OBJECT"))
return false;
CIMClass cimClass;
CIMQualifierDecl qualifierDecl;
if (XmlReader::getClassElement(parser, cimClass))
{
cout << "Creating: class ";
cout << cimClass.getClassName() << endl;
repository.createClass(CIMV2_NAMESPACE, cimClass);
repository.createClass(ROOT_NAMESPACE, cimClass);
}
else if (XmlReader::getQualifierDeclElement(parser, qualifierDecl))
{
cout << "Creating: qualifier ";
cout << qualifierDecl.getName() << endl;
repository.setQualifier(CIMV2_NAMESPACE, qualifierDecl);
repository.setQualifier(ROOT_NAMESPACE, qualifierDecl);
}
XmlReader::expectEndTag(parser, "VALUE.OBJECT");
return true;
}
void TestQualifiers()
{
// -- Create repository and qualifier test namespace:
const CIMNamespaceName QNS = CIMNamespaceName ("TestQualifiers");
try
{
r->createNameSpace(QNS);
}
catch (AlreadyExistsException&)
{
// Ignore this!
}
// -- Construct a qualifier declaration:
CIMQualifierDecl q(CIMName ("abstract"), true, CIMScope::CLASS);
r->setQualifier(QNS, q);
CIMQualifierDecl qq = r->getQualifier(QNS, CIMName ("abstract"));
PEGASUS_TEST_ASSERT(qq.identical(q));
PEGASUS_TEST_ASSERT(q.identical(qq));
// -- Delete the qualifier:
r->deleteQualifier(QNS, CIMName ("abstract"));
// -- Delete the namespace:
r->deleteNameSpace(QNS);
}
void CIMQualifierList::resolve(
DeclContext* declContext,
const CIMNamespaceName & nameSpace,
CIMScope scope, // Scope of the entity being resolved.
Boolean isInstancePart,
CIMQualifierList& inheritedQualifiers,
Boolean propagateQualifiers)
{
_keyIndex = PEGASUS_ORDEREDSET_INDEX_UNKNOWN;
PEG_METHOD_ENTER(TRC_OBJECTRESOLUTION, "CIMQualifierList::resolve()");
// For each qualifier in the qualifiers array, the following
// is checked:
//
// 1. Whether it is declared (can be obtained from the declContext).
//
// 2. Whether it has the same type as the declaration.
//
// 3. Whether the qualifier is valid for the given scope.
//
// 4. Whether the qualifier can be overriden (the flavor is
// ENABLEOVERRIDE on the corresponding reference qualifier).
//
// 5. Whether the qualifier should be propagated to the subclass.
//
// If the qualifier should be overriden, then it is injected into the
// qualifiers array (from the inheritedQualifiers array).
for (Uint32 i = 0, n = _qualifiers.size(); i < n; i++)
{
CIMQualifier q = _qualifiers[i];
//----------------------------------------------------------------------
// 1. Check to see if it's declared.
//----------------------------------------------------------------------
// set this back to CIMConstQualifierDecl
CIMQualifierDecl qd = declContext->lookupQualifierDecl(
nameSpace, q.getName());
if (qd.isUninitialized())
{
PEG_METHOD_EXIT();
throw UndeclaredQualifier(q.getName().getString ());
}
//----------------------------------------------------------------------
// 2. Check the type and isArray. Must be the same:
//----------------------------------------------------------------------
if (!(q.getType() == qd.getType() && q.isArray() == qd.isArray()))
{
PEG_METHOD_EXIT();
throw BadQualifierType(q.getName().getString ());
}
//----------------------------------------------------------------------
// 3. If the qualifier is the EmbeddedInstance qualifier, then check
// that the class specified by the qualifier exists in the namespace.
//----------------------------------------------------------------------
if (q.getName().equal(PEGASUS_QUALIFIERNAME_EMBEDDEDINSTANCE))
{
String className;
q.getValue().get(className);
CIMClass classDef = declContext->lookupClass(nameSpace,
CIMName(className));
if (classDef.isUninitialized())
{
String embeddedInstType("EmbeddedInstance(\"");
embeddedInstType = embeddedInstType + className + "\")";
PEG_METHOD_EXIT();
throw BadQualifierType(embeddedInstType);
}
}
//----------------------------------------------------------------------
// 4. Check the scope: Must be legal for this qualifier
//----------------------------------------------------------------------
// ATTN: These lines throw a bogus exception if the qualifier has
// a valid scope (such as Scope::ASSOCIATION) which is not Scope::CLASS
// ks Mar 2002. Reinstalled 23 March 2002 to test.
if (!(qd.getScope().hasScope (scope)))
{
PEG_METHOD_EXIT();
throw BadQualifierScope
(qd.getName().getString (), scope.toString ());
}
//----------------------------------------------------------------------
// Resolve the qualifierflavor. Since Flavors are a combination of
// inheritance and input characteristics, resolve the inherited
// characteristics against those provided with the creation. If
// there is a superclass the flavor is resolved against that
// superclass. If not, it is resolved against the declaration. If
// the flavor is disableoverride and tosubclass the resolved
// qualifier value must be identical to the original
//----------------------------------------------------------------------
// Test for Qualifier found in SuperClass. If found and qualifier
// is not overridable.
// Abstract (not Overridable and restricted) can be found in subclasses
// Can have nonabstracts below abstracts. That is function of
// nottosubclass Association (notOverridable and tosubclass) can be
// found in subclasses but cannot be changed. No non-associatons below
// associations. In other words once a class becomes an association,
// no subclass can override that definition apparently
// Throw exception if DisableOverride and tosubclass and different
// value. Gets the source from superclass if qualifier exists or from
// declaraction.
// If we do not throw the exception, resolve the flavor from the
// inheritance point and resolve against current input.
// Diableoverride is defined in the CIM Spec to mean that the value
// cannot change.
// The other characteristics including the flavor can change
// apparently. Thus, we need only confirm that the value is the same
// (2.2 pp 33). Strange since we would think that override implies
// that you cannot override any of the characteristics (value, type,
// flavor, etc.) This also leaves the question of NULL or no values.
// The implication is that we must move the value from the superclass
// or declaration.
Uint32 index = inheritedQualifiers.find(q.getName());
if (index == PEG_NOT_FOUND)
{ // Qualifier does not exist in superclass
/* If from declaration, we can override the default value.
However, we need some way to get the value if we have a Null.
if (!qd.getFlavor().hasFlavor(CIMFlavor::OVERRIDABLE) &&
qd.getFlavor().hasFlavor(CIMFlavor::TOSUBCLASS))
{
//throw BadQualifierOverride(q.getName());
}
*/
// Do not allow change from disable override to enable override.
if ((!qd.getFlavor ().hasFlavor(CIMFlavor::OVERRIDABLE))
&& (q.getFlavor ().hasFlavor(CIMFlavor::OVERRIDABLE)))
{
PEG_METHOD_EXIT();
throw BadQualifierOverride(q.getName().getString ());
}
Resolver::resolveQualifierFlavor(
q, CIMFlavor (qd.getFlavor ()), false);
}
else // qualifier exists in superclass
{ ////// Make Const again
CIMQualifier iq = inheritedQualifiers.getQualifier(index);
// don't allow change override to notoverride.
if (!(iq.getFlavor ().hasFlavor(CIMFlavor::OVERRIDABLE))
&& q.getFlavor ().hasFlavor (CIMFlavor::OVERRIDABLE))
{
PEG_METHOD_EXIT();
throw BadQualifierOverride(q.getName().getString ());
}
if (!(iq.getFlavor ().hasFlavor(CIMFlavor::OVERRIDABLE))
&& iq.getFlavor ().hasFlavor(CIMFlavor::TOSUBCLASS))
{
// test if values the same.
CIMValue qv = q.getValue();
CIMValue iqv = iq.getValue();
if (!(qv == iqv))
{
PEG_METHOD_EXIT();
throw BadQualifierOverride(q.getName().getString());
}
}
Resolver::resolveQualifierFlavor(
q, CIMFlavor(iq.getFlavor()), true);
}
} // end of this objects qualifier loop
//--------------------------------------------------------------------------
// Propagate qualifiers to subclass or to instance that do not have
// already have those qualifiers:
//--------------------------------------------------------------------------
if (propagateQualifiers)
{
for (Uint32 i = 0, n = inheritedQualifiers.getCount(); i < n; i++)
{
CIMQualifier iq = inheritedQualifiers.getQualifier(i);
if (isInstancePart)
{
if (!(iq.getFlavor().hasFlavor(CIMFlavor::TOINSTANCE)))
continue;
}
else
{
if (!(iq.getFlavor().hasFlavor(CIMFlavor::TOSUBCLASS)))
continue;
}
// If the qualifiers list does not already contain this qualifier,
// then propagate it (and set the propagated flag to true). Else
// we keep current value. Note we have already eliminated any
// possibility that a nonoverridable qualifier can be in the list.
if (find(iq.getName()) != PEG_NOT_FOUND)
continue;
CIMQualifier q = iq.clone();
q.setPropagated(true);
_qualifiers.insert(0, q);
}
}
PEG_METHOD_EXIT();
}
