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.27 and 1.37

version 1.27, 2002/03/28 02:57:54

version 1.37, 2002/07/23 17:01:48

Line 1

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

// The Open Group, Tivoli Systems

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

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

Line 23

Line 24

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

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

// Carol Ann Krug Graves, Hewlett-Packard Company

// (carolann_graves@hp.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>

PEGASUS_NAMESPACE_BEGIN

PEGASUS_USING_STD;

Line 48

Line 54

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

{

if (!qualifier)

if (qualifier.isNull())

throw UnitializedHandle();

throw UninitializedHandle();

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

throw AlreadyExists();

Line 80

Line 86

return PEG_NOT_FOUND;

}

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

{

Uint32 pos = find(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;

}

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

{

Line 100

Line 122

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 127

Line 150

CIMQualifierDecl qd = declContext->lookupQualifierDecl(

nameSpace, q.getName());

if (!qd)

if (qd.isNull())

throw UndeclaredQualifier(q.getName());

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

Line 156

Line 179

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

Line 177

Line 198

// 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 pos = inheritedQualifiers.find(q.getName());

Line 198

Line 217

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

<< " Not override " << !qd.isFlavor(CIMFlavor::OVERRIDABLE)

<< " tosubclass " << qd.isFlavor(CIMFlavor::TOSUBCLASS) << endl;

qd.print(); q.print();

XmlWriter::printQualifierDeclElement(qd);

XmlWriter::printQualifierElement(q);

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

}

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

Line 206

Line 226

if(!qd.isFlavor(CIMFlavor::OVERRIDABLE) && q.isFlavor(CIMFlavor::OVERRIDABLE ))

throw BadQualifierOverride(q.getName());

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

Resolver::resolveQualifierFlavor (q, qd.getFlavor (),

false);

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

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

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

<< " Not override " << !qd.isFlavor(CIMFlavor::OVERRIDABLE)

<< " tosubclass " << qd.isFlavor(CIMFlavor::TOSUBCLASS) << endl;

qd.print(); q.print(); */

XmlWriter::printQualifierDeclElement(qd);

XmlWriter::printQualifierElement(q); */

}

else // qualifier exists in superclass

{ ////// Make Const again

Line 229

Line 251

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

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

<< endl;

iq.print(); q.print();*/

XmlWriter::printQualifierElement(iq);

XmlWriter::printQualifierElement(q); */

// test if values the same.

CIMValue qv = q.getValue();

CIMValue iqv = iq.getValue();

Line 238

Line 261

}

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

q.resolveFlavor(iq.getFlavor(), true);

Resolver::resolveQualifierFlavor (q, iq.getFlavor (),

true);

}

} // end of this objects qualifier loop

Line 246

Line 270

// Propagate qualifiers to subclass or to instance that do not have

// already have those qualifiers:

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

//cout << "KSTEST. Loop of inherited qualifiers. Number = "

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

// << inheritedQualifiers.getCount() << endl;

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

{

Line 255

Line 278

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

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

// ATTN-DE-P1-This next test is incorrect. It is a temporary, hard-coded

// HACK to avoid propagating the "Abstract" Qualifier to subclasses

//if (CIMName::equal(iq.getName(), "Abstract"))

// continue;

//<< " flavor= " << iq.getFlavor()

//<< " TOSUBCLASS " << (iq.getFlavor() && CIMFlavor::TOSUBCLASS) << endl;

if (isInstancePart)

{

if (!iq.isFlavor(CIMFlavor::TOINSTANCE))

Line 290

Line 306

void CIMQualifierList::toXml(Array<Sint8>& 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.

Line 316

Line 332

// if second or greater, add comma separator

if (i > 0)

out << ", \n";

_qualifiers[i].toMof(out);

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

}

// Terminating bracket

Line 351

Line 367

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.27
changed lines
	Added in v.1.37

No CVS admin address has been configured