pegasus/src/Pegasus/Common/CIMQualifierList.cpp - diff

Return to CIMQualifierList.cpp CVS log

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

Diff for /pegasus/src/Pegasus/Common/CIMQualifierList.cpp between version 1.13 and 1.55

version 1.13, 2001/06/16 23:10:03

version 1.55, 2006/01/30 16:16:47

Line 1

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

//%2006////////////////////////////////////////////////////////////////////////

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

// IBM Corp.; EMC Corporation, The Open Group.

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; Symantec 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 22

Line 31

// Author: Mike Brasher (mbrasher@bmc.com)

// Modified By:

// Modified By: Karl Schopmeyer (k.schopmeyer@opengroup.org)

// Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.com)

// David Dillard, VERITAS Software Corp.

// (david.dillard@veritas.com)

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

#include "CIMQualifierList.h"

#include "DeclContext.h"

#include "Resolver.h"

#include "CIMQualifierDecl.h"

#include "CIMName.h"

#include "Indentor.h"

#include "XmlWriter.h"

#include "MofWriter.h"

#include <Pegasus/Common/Tracer.h>

#include <Pegasus/Common/MessageLoader.h> //l10n

#include "StrLit.h"

#include "ArrayIterator.h"

PEGASUS_NAMESPACE_BEGIN

PEGASUS_USING_STD;

CIMQualifierList::CIMQualifierList()

{

Line 47

Line 67

CIMQualifierList& CIMQualifierList::add(const CIMQualifier& qualifier)

{

if (!qualifier)

if (qualifier.isUninitialized())

throw UnitializedHandle();

throw UninitializedObjectException();

if (find(qualifier.getName()) != PEG_NOT_FOUND)

if (find(qualifier.getName()) != PEG_NOT_FOUND){

throw AlreadyExists();

//l10n

//throw AlreadyExistsException

//("qualifier \"" + qualifier.getName().getString () + "\"");

MessageLoaderParms parms("Common.CIMQualifierList.QUALIFIER",

"qualifier \"$0\"",

qualifier.getName().getString());

throw AlreadyExistsException(parms);

}

_qualifiers.append(qualifier);

return *this;

}

//ATTN: Why do we not do the outofbounds check here. KS 18 May 2k

CIMQualifier& CIMQualifierList::getQualifier(Uint32 pos)

CIMQualifier& CIMQualifierList::getQualifier(Uint32 index)

{

return _qualifiers[pos];

return _qualifiers[index];

}

//ATTN: added ks 18 may 2001. Should we have outofbounds?

void CIMQualifierList::removeQualifier(Uint32 pos)

void CIMQualifierList::removeQualifier(Uint32 index)

{

_qualifiers.remove(pos);

_qualifiers.remove(index);

}

Uint32 CIMQualifierList::find(const String& name) const

Uint32 CIMQualifierList::find(const CIMName& name) const

{

for (Uint32 i = 0, n = _qualifiers.size(); i < n; i++)

ConstArrayIterator<CIMQualifier> qualifiers(_qualifiers);

for (Uint32 i = 0, n = qualifiers.size(); i < n; i++)

{

if (CIMName::equal(_qualifiers[i].getName(), name))

if (name.equal(qualifiers[i].getName()))

return i;

}

return PEG_NOT_FOUND;

}

Boolean CIMQualifierList::isTrue(const CIMName& name) const

{

Uint32 index = find(name);

Uint32 CIMQualifierList::findReverse(const String& name) const

if (index == PEG_NOT_FOUND)

return false;

Boolean flag;

const CIMValue& value = getQualifier(index).getValue();

if (value.getType() != CIMTYPE_BOOLEAN)

return false;

value.get(flag);

return flag;

}

Uint32 CIMQualifierList::findReverse(const CIMName& name) const

{

for (Uint32 i = _qualifiers.size(); i; --i)

{

if (CIMName::equal(_qualifiers[i - 1].getName(), name))

if (name.equal(_qualifiers[i-1].getName()))

return i - 1;

}

Line 93

Line 138

void CIMQualifierList::resolve(

DeclContext* declContext,

const String& nameSpace,

const CIMNamespaceName & nameSpace,

Uint32 scope,

CIMScope scope, // Scope of the entity being resolved.

Boolean isInstancePart,

CIMQualifierList& inheritedQualifiers)

CIMQualifierList& inheritedQualifiers,

Boolean propagateQualifiers) // Apparently not used ks 24 mar 2002

{

PEG_METHOD_ENTER(TRC_OBJECTRESOLUTION, "CIMQualifierList::resolve()");

// For each qualifier in the qualifiers array, the following

// is checked:

Line 105

Line 152

// 2. Whether it has the same type as the declaration.

// 3. Whether the the qualifier is valid for the given scope.

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

Line 118

Line 165

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

CIMConstQualifierDecl qd = declContext->lookupQualifierDecl(

CIMQualifierDecl qd = declContext->lookupQualifierDecl(

nameSpace, q.getName());

if (!qd)

if (qd.isUninitialized())

throw UndeclaredQualifier(q.getName());

throw UndeclaredQualifier(q.getName().getString ());

//----------------------------------------------------------------------

// 2. Check the type:

// 2. Check the type and isArray. Must be the same:

//----------------------------------------------------------------------

if (!(q.getType() == qd.getType() && q.isArray() == qd.isArray()))

throw BadQualifierType(q.getName());

throw BadQualifierType(q.getName().getString ());

//----------------------------------------------------------------------

// 3. Check the scope:

// 3. Check the scope: Must be legal for this qualifier

//----------------------------------------------------------------------

#if 0

//#if 0

// ATTN: These lines throw a bogus exception if the qualifier has

// a valid scope (such as Scope::ASSOCIATION) which is not Scope::CLASS

// grb 1/16/01

// ks Mar 2002. Reinstalled 23 March 2002 to test.

if (!(qd.getScope() & scope))

throw BadQualifierScope(qd.getName(), ScopeToString(scope));

if (!(qd.getScope().hasScope (scope)))

#endif

throw BadQualifierScope

(qd.getName().getString (), scope.toString ());

//#endif

//----------------------------------------------------------------------

// See if this qualifier is contained in the inheritedQualifiers. If

// Resolve the qualifierflavor. Since Flavors are a combination of inheritance

// so then we must handle the OVERRIDABLE flavor.

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

// ATTN: there seems to be a problem with the CIM schema that marks the

// is not overridable.

// abstract qualifier as non-overridable but then they override it.

// Abstract (not Overridable and restricted) can be found in subclasses

// For now it is just disabled. This problem exists in both XML and

// Can have nonabstracts below abstracts. That is function of nottosubclass

// CIM schema.

// Association (notOverridable and tosubclass) can be found in subclasses but

// cannot be changed. No non-associatons below associations. In other words

#if 0

// once a class becomes an association, no subclass can override that definition

Uint32 pos = inheritedQualifiers.find(q.getName());

// apparently

// Throw exception if DisableOverride and tosubclass and different value.

if (pos != PEG_NOT_FOUND)

// Gets the source from superclass if qualifier exists or from declaraction

{

// If we do not throw the exception, resolve the flavor from the inheritance

CIMConstQualifier iq = inheritedQualifiers.getQualifier(pos);

// point and resolve against current input.

// Diableoverride is defined in the CIM Spec to mean that the value cannot change

if (!(iq.getFlavor() & CIMFlavor::OVERRIDABLE))

// The other characteristics including the flavor can change apparently. Thus, we

throw BadQualifierOverride(q.getName());

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

#endif

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

//cout << "KSTEST Qualifier resolve inherit test " << q.getName()

//<< " Inherited From " << ((index == PEG_NOT_FOUND) ? "Declaration" : "superclass")

//<< " Flavor " << q.getFlavor()

//<< " inherited Flavor ";

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

{

if(!(q.getValue() == qd.getValue()))

cout << "KSTEST QL err NSCL " << q.getName()

<< " decl flavor " << qd.getFlavor() << " Flavor " << q.getFlavor()

<< " Not override "

<< !(qd.getFlavor ().hasFlavor

(CIMFlavor::OVERRIDABLE))

<< " tosubclass "

<< qd.getFlavor ().hasFlavor

(CIMFlavor::TOSUBCLASS) << endl;

XmlWriter::printQualifierDeclElement(qd);

XmlWriter::printQualifierElement(q);

//throw BadQualifierOverride(q.getName());

}

//cout << qd.getFlavor() << endl;*/

// Do not allow change from disable override to enable override.

if ((!qd.getFlavor ().hasFlavor

(CIMFlavor::OVERRIDABLE))

&& (q.getFlavor ().hasFlavor

(CIMFlavor::OVERRIDABLE)))

throw BadQualifierOverride

(q.getName().getString ());

Resolver::resolveQualifierFlavor

(q, CIMFlavor (qd.getFlavor ()), false);

/*if(!(q.getValue() == qd.getValue()))

cout << "KSTEST Flavor resolved from decl. " << q.getName()

<< " decl flavor " << qd.getFlavor().toString ()

<< " Flavor " << q.getFlavor().toString ()

<< " Not override "

<< !(qd.getFlavor ().hasFlavor

(CIMFlavor::OVERRIDABLE))

<< " tosubclass " << qd.getFlavor ().hasFlavor

(CIMFlavor::TOSUBCLASS) << endl;

XmlWriter::printQualifierDeclElement(qd);

XmlWriter::printQualifierElement(q); */

}

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

throw BadQualifierOverride

(q.getName().getString ());

if (!(iq.getFlavor ().hasFlavor

(CIMFlavor::OVERRIDABLE))

&& iq.getFlavor ().hasFlavor

(CIMFlavor::TOSUBCLASS))

{

/*if(!(q.getValue() == iq.getvalue()))

cout << "KSTEST QL err inherit " << q.getName()

<< " from superclass " << iq.getName()

<< " Superclass flavor " << iq.getFlavor().toString ()

<< " Flavor " << q.getFlavor().toString ()

<< endl;

XmlWriter::printQualifierElement(iq);

XmlWriter::printQualifierElement(q); */

// test if values the same.

CIMValue qv = q.getValue();

CIMValue iqv = iq.getValue();

if(!(qv == iqv)) {

throw BadQualifierOverride

(q.getName().getString ());

}

//cout << iq.getFlavor() << endl;

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:

//--------------------------------------------------------------------------

//cout << "KSTEST. Inherited qualifiers ct = " << inheritedQualifiers.getCount() << endl;

for (Uint32 i = 0, n = inheritedQualifiers.getCount(); i < n; i++)

{

CIMQualifier iq = inheritedQualifiers.getQualifier(i);

//cout << "KSTEST inherited qualifier propagate loop " << iq.getName()

//<< " flavor " << iq.getFlavor << " count " << i << endl;

if (isInstancePart)

{

if (!(iq.getFlavor() & CIMFlavor::TOINSTANCE))

if (!(iq.getFlavor ().hasFlavor

(CIMFlavor::TOINSTANCE)))

continue;

}

else

{

if (!(iq.getFlavor() & CIMFlavor::TOSUBCLASS))

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

// then propagate it (and set the propagated flag to true). Else we

// keep current value. Note we have already eliminated any possibity that

// a nonoverridable qualifier can be in the list.

// Note that there is no exists() function ATTN:KS 25 Mar 2002

if (find(iq.getName()) != PEG_NOT_FOUND)

continue;

Line 201

Line 350

}

void CIMQualifierList::toXml(Array<Sint8>& out) const

void CIMQualifierList::toXml(Buffer& out) const

{

for (Uint32 i = 0, n = _qualifiers.size(); i < n; i++)

_qualifiers[i].toXml(out);

XmlWriter::appendQualifierElement(out, _qualifiers[i]);

}

/** toMof - Generates MOF output for a list of CIM Qualifiers.

The qualifiers may be class, property, parameter, etc.

The BNF for this is:

<pre>

qualifierList = "[" qualifier *( "," qualifier ) "]"

</pre>

Produces qualifiers as a string on without nl.

void CIMQualifierList::toMof(Buffer& out) const

{

// if no qualifiers, return

if (_qualifiers.size() == 0)

return;

// Qualifier leading bracket.

out.append('[');

// Loop to list qualifiers

for (Uint32 i = 0, n = _qualifiers.size(); i < n; i++)

{

// if second or greater, add comma separator

if (i > 0)

out << STRLIT(", \n");

MofWriter::appendQualifierElement(out, _qualifiers[i]);

}

// Terminating bracket

out.append(']');

}

void CIMQualifierList::print(PEGASUS_STD(ostream) &os) const

{

Array<Sint8> tmp;

Buffer tmp;

toXml(tmp);

tmp.append('\0');

os << tmp.getData() << PEGASUS_STD(endl);

Line 223

Line 403

return false;

for (Uint32 i = 0; i < count; i++)

return _qualifiers[i].identical(x._qualifiers[i]);

{

if (!_qualifiers[i].identical(x._qualifiers[i]))

return false;

}

return true;

}

Line 231

Line 414

void CIMQualifierList::cloneTo(CIMQualifierList& x) const

{

x._qualifiers.clear();

x._qualifiers.reserve(_qualifiers.size());

x._qualifiers.reserveCapacity(_qualifiers.size());

for (Uint32 i = 0, n = _qualifiers.size(); i < n; i++)

x._qualifiers.append(_qualifiers[i].clone());

Legend:

Removed from v.1.13
changed lines
	Added in v.1.55

No CVS admin address has been configured