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

Return to CIMResponseData.cpp CVS log

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

Diff for /pegasus/src/Pegasus/Common/CIMResponseData.cpp between version 1.4 and 1.5.2.7

version 1.4, 2010/01/28 09:16:45

version 1.5.2.7, 2013/06/03 22:35:12

Line 27

//////////////////////////////////////////////////////////////////////////

// Class CIMResponseData encapsulates the possible types of response data

// representations and supplies conversion methods between these types.

// PEP#348 - The CMPI infrastructure using SCMO (Single Chunk Memory Objects)

// describes its usage in the server flow.

// The design document can be found on the OpenPegasus website openpegasus.org

// at https://collaboration.opengroup.org/pegasus/pp/documents/21210/PEP_348.pdf

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

#include "CIMResponseData.h"

Line 37

Line 44

#include <Pegasus/Common/CIMInternalXmlEncoder.h>

#include <Pegasus/Common/SCMOInternalXmlEncoder.h>

// KS_TODO_DELETE

#include <Pegasus/Common/Print.h>

PEGASUS_USING_STD;

PEGASUS_NAMESPACE_BEGIN

#define LOCAL_MIN(a, b) ((a < b) ? a : b)

// C++ objects interface handling

// KS_TODO Remove this completely when finished testing.

bool CIMResponseData::sizeValid()

{

TRACELINE;

PEGASUS_ASSERT(valid());

if (_size > 1000000)

{

TRACELINE;

cout << "CIMResponseData::PSVALID _size too big " << _size << endl;

PEG_TRACE((TRC_XML, Tracer::LEVEL4,

"CIMResponseData::PSVALID _size too big %u",_size ));

return false;

}

PEG_TRACE((TRC_XML, Tracer::LEVEL4,

"CIMResponseData Size _size=%u", _size));

return true;

}

// Instance Names handling

Array<CIMObjectPath>& CIMResponseData::getInstanceNames()

{

TRACELINE;

PSVALID;

PEGASUS_DEBUG_ASSERT(

(_dataType==RESP_INSTNAMES || _dataType==RESP_OBJECTPATHS));

_resolveToCIM();

Line 53

Line 84

return _instanceNames;

}

// Instance handling

// Get a single instance as a CIM instance.

// This converts all of the objects in the response data to

// CIM form as part of the conversion.

// If there are no instances in the object, returns CIMInstance(),

// an empty instance.

CIMInstance& CIMResponseData::getInstance()

{

TRACELINE;

PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCE);

_resolveToCIM();

if (0 == _instances.size())

Line 68

Line 104

// Instances handling

Array<CIMInstance>& CIMResponseData::getInstances()

{

TRACELINE;

PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCES);

_resolveToCIM();

return _instances;

}

// Instances handling specifically for the client where the call may

// get either instances or objects and must convert them to instances

// NOTE: This is a temporary solution to satisfy the BinaryCodec passing

// of data to the client where the data could be either instances or

// objects. The correct solution is to convert back when the provider, etc.

// returns the data to the server. We must convert to that solution but

// this keeps it working for the moment.

Array<CIMInstance>& CIMResponseData::getInstancesFromInstancesOrObjects()

{

TRACELINE;

if (_dataType == RESP_INSTANCES)

{

_resolveToCIM();

return _instances;

}

else if (_dataType == RESP_OBJECTS)

{

_resolveToCIM();

for (Uint32 i = 0 ; i < _objects.size() ; i++)

{

_instances.append((CIMInstance)_objects[i]);

}

return _instances;

}

PEGASUS_DEBUG_ASSERT(false);

}

// Objects handling

Array<CIMObject>& CIMResponseData::getObjects()

{

TRACELINE;

PEGASUS_DEBUG_ASSERT(_dataType == RESP_OBJECTS);

_resolveToCIM();

return _objects;

Line 83

Line 149

// SCMO representation, single instance stored as one element array

// object paths are represented as SCMOInstance

// Resolve all of the information in the CIMResponseData container to

// SCMO and return all scmoInstances.

// Note that since the SCMO representation,

// a is single instance stored as one element array and object paths are

// represented as SCMOInstance this returns array of SCMOInstance.

Array<SCMOInstance>& CIMResponseData::getSCMO()

{

TRACELINE;

// This function resolves to instances and so cannot handle responses to

// the associators,etc.requests that return classes (input object path with

// no keys). That issue is resolved however, since CIMResponseData uses the

// _isClassOperation variable (set by the request) to determine whether

// the responses are classpaths or instancepaths and the default is

// false(instancePaths) so that this should always produce instance paths.

_resolveToSCMO();

return _scmoInstances;

}

// set an array of SCMOInstances into the response data object

void CIMResponseData::setSCMO(const Array<SCMOInstance>& x)

{

TRACELINE;

PSVALID;

_scmoInstances=x;

_encoding |= RESP_ENC_SCMO;

_size += x.size();

}

// Binary data is just a data stream

Array<Uint8>& CIMResponseData::getBinary()

{

TRACELINE;

PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_BINARY || _encoding == 0);

return _binaryData;

}

bool CIMResponseData::setBinary(CIMBuffer& in, bool hasLen)

bool CIMResponseData::setBinary(CIMBuffer& in)

{

PEG_METHOD_ENTER(TRC_DISPATCHER,

TRACELINE;

"CIMResponseData::setBinary");

PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::setBinary");

if (hasLen)

// Append all serial data from the CIMBuffer to the local data store.

{

// Returns error if input not a serialized Uint8A

if (!in.getUint8A(_binaryData))

{

PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,

"Failed to get binary object path data!");

"Failed to get binary input data!");

PEG_METHOD_EXIT();

return false;

}

_encoding |= RESP_ENC_BINARY;

PEG_METHOD_EXIT();

return true;

}

else

bool CIMResponseData::setRemainingBinaryData(CIMBuffer& in)

{

size_t remainingDataLength = in.capacity() - in.size();

TRACELINE;

PEG_METHOD_ENTER(TRC_DISPATCHER, "CIMResponseData::setRemainingBinaryData");

// Append any data that has not been deserialized already from

// the CIMBuffer.

size_t remainingDataLength = in.remainingDataLength();

_binaryData.append((Uint8*)in.getPtr(), remainingDataLength);

}

_encoding |= RESP_ENC_BINARY;

PEG_METHOD_EXIT();

return true;

Line 130

Line 223

bool CIMResponseData::setXml(CIMBuffer& in)

{

TRACELINE;

PSVALID;

switch (_dataType)

{

case RESP_INSTANCE:

Line 166

Line 261

return false;

}

_nameSpacesData.insert(0,ns);

_size++;

break;

}

case RESP_INSTANCES:

Line 212

Line 308

_hostsData.append(host);

_nameSpacesData.append(ns);

}

_size += count;

break;

}

case RESP_OBJECTS:

Line 258

Line 355

_hostsData.append(host);

_nameSpacesData.append(ns);

}

_size += count;

break;

}

// internal xml encoding of instance names and object paths not

Line 273

Line 371

return true;

}

// Move the number of objects defined by the input parameter from

// one CIMResponse Object to another CIMResponse Object.

Uint32 CIMResponseData::moveObjects(CIMResponseData & from, Uint32 count)

{

TRACELINE;

PEG_TRACE((TRC_XML, Tracer::LEVEL3,

"CIMResponseData::move(%u)", count));

PEGASUS_ASSERT(valid()); // KS_TEMP

if (_dataType != from._dataType) // KS_TEMP

{

printf("ERROR moveObjects _dataType %u. from._dataType %u\n",

_dataType, from._dataType);

}

PEGASUS_DEBUG_ASSERT(_dataType == from._dataType);

Uint32 rtnSize = 0;

Uint32 toMove = count;

// printf("count to move = %u encoding %u from.size %u to.size %u\n",

// count, from._encoding, from._size, _size);

if (RESP_ENC_XML == (from._encoding & RESP_ENC_XML))

{

switch (_dataType)

{

case RESP_OBJECTPATHS:

case RESP_INSTNAMES:

break;

case RESP_INSTANCE:

{

//// TODO fix this Uint32 moveCount = toMove;

if (from._instanceData.size() > 0)

{

// temp test to assure all sizes are the same.

PEGASUS_ASSERT(from._hostsData.size() ==

from._instanceData.size());

PEGASUS_ASSERT(from._referencesData.size() ==

from._instanceData.size());

PEGASUS_ASSERT(from._nameSpacesData.size() ==

from._instanceData.size());

_instanceData.append(from._instanceData.getData(),1);

from._instanceData.remove(0, 1);

_referencesData.append(

from._referencesData.getData(),1);

from._referencesData.remove(0, 1);

if (_hostsData.size())

{

_hostsData.append(from._hostsData.getData(),1);

from._hostsData.remove(0, 1);

}

if (_nameSpacesData.size())

{

_nameSpacesData.append(

from._nameSpacesData.getData(),1);

from._nameSpacesData.remove(0, 1);

}

rtnSize += 1;

toMove--;

_encoding |= RESP_ENC_XML;

}

break;

// The above should probably be folded into the following.

// Need something like an assert if there is ever more than

// one instance in _instanceData for type RESP_INSTANCE

case RESP_INSTANCES:

case RESP_OBJECTS:

{

Uint32 moveCount = LOCAL_MIN(toMove,

from._instanceData.size());

PEGASUS_ASSERT(from._referencesData.size() ==

from._instanceData.size());

_instanceData.append(from._instanceData.getData(),

moveCount);

from._instanceData.remove(0, moveCount);

_referencesData.append(from._referencesData.getData(),

moveCount);

from._referencesData.remove(0, moveCount);

rtnSize += moveCount;

toMove -= moveCount;

_encoding |= RESP_ENC_XML;

}

break;

}

if (RESP_ENC_BINARY == (from._encoding & RESP_ENC_BINARY))

{

// KS_PULL TBD Add binary move function

// Cannot resolve this one without actually processing

// the data since it is a stream.

rtnSize += 0;

PEGASUS_ASSERT(false);

}

if (RESP_ENC_SCMO == (from._encoding & RESP_ENC_SCMO))

{

Uint32 moveCount = LOCAL_MIN(toMove, from._scmoInstances.size());

_scmoInstances.append(from._scmoInstances.getData(), moveCount);

from._scmoInstances.remove(0, moveCount);

rtnSize += moveCount;

toMove -= moveCount;

_encoding |= RESP_ENC_SCMO;

}

if (RESP_ENC_CIM == (from._encoding & RESP_ENC_CIM))

{

switch (_dataType)

{

case RESP_OBJECTPATHS:

case RESP_INSTNAMES:

{

Uint32 moveCount = LOCAL_MIN(toMove,

from._instanceNames.size());

_instanceNames.append(

from._instanceNames.getData(), moveCount);

from._instanceNames.remove(0, moveCount);

rtnSize += moveCount;

toMove -= moveCount;

_encoding |= RESP_ENC_CIM;

}

break;

case RESP_INSTANCE:

case RESP_INSTANCES:

{

Uint32 moveCount = LOCAL_MIN(toMove,

from._instances.size());

_instances.append(from._instances.getData(), moveCount);

from._instances.remove(0, moveCount);

rtnSize += moveCount;

toMove -= moveCount;

_encoding |= RESP_ENC_CIM;

}

break;

case RESP_OBJECTS:

{

Uint32 moveCount = LOCAL_MIN(toMove,

from._objects.size());

_objects.append(from._objects.getData(), moveCount);

from._objects.remove(0, moveCount);

rtnSize += moveCount;

toMove -= moveCount;

_encoding |= RESP_ENC_CIM;

}

break;

}

PEGASUS_ASSERT(rtnSize == (count - toMove));

_size += rtnSize;

from._size -= rtnSize;

if (rtnSize != _size)

{

PEG_TRACE((TRC_XML, Tracer::LEVEL1,

"Size calc error _size %u rtnSWize = %u", _size, rtnSize));

}

//PEGASUS_ASSERT(rtnSize == _size);

return rtnSize;

}

// Return the number of CIM objects in the CIM Response data object

#define TEMPLOG PEG_TRACE((TRC_XML, Tracer::LEVEL4, \

"rtnSize %u size %u line %u", rtnSize, _size, __LINE__))

//#define TEMPLOG cout << "rtnSize " << rtnSize << " _size " << _size

//<< " line " << __LINE__ << endl

Uint32 CIMResponseData::size()

{

TRACELINE;

PEG_METHOD_ENTER(TRC_XML,"CIMResponseData::size()");

PSVALID;

// If debug mode, add up all the individual size components to

// determine overall size of this object. Then compare this with

// the _size variable. this is a good check on the completeness of the

// size computations. We should be able to remove this at some point

// but there are many sources of size info and we need to be sure we

// have covered them all.

#ifdef PEGASUS_DEBUG

PEGASUS_ASSERT(valid()); //KS_TEMP KS_TODO

Uint32 rtnSize = 0;

TEMPLOG;

if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))

{

TEMPLOG;

switch (_dataType)

{

case RESP_OBJECTPATHS:

case RESP_INSTNAMES:

break;

case RESP_INSTANCE:

rtnSize +=1;

break;

case RESP_INSTANCES:

case RESP_OBJECTS:

rtnSize += _instanceData.size();

break;

}

PSVALID;

TEMPLOG;

}

if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))

{

TEMPLOG;

// KS_PULL_TODO

// Cannot resolve this one without actually processing

// the data since it is a stream.

rtnSize += 0;

//PEGASUS_ASSERT(false);

TEMPLOG;

}

if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))

{

PSVALID;

TEMPLOG;

rtnSize += _scmoInstances.size();

TEMPLOG;

}

if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))

{

PSVALID;

TEMPLOG;

switch (_dataType)

{

case RESP_OBJECTPATHS:

case RESP_INSTNAMES:

rtnSize += _instanceNames.size();

break;

case RESP_INSTANCE:

case RESP_INSTANCES:

rtnSize += _instances.size();

break;

case RESP_OBJECTS:

rtnSize += _objects.size();

break;

}

PSVALID;

TEMPLOG;

}

// Test of actual count against _size variable.

if (rtnSize != _size)

{

TEMPLOG;

PSVALID;

PEG_TRACE((TRC_XML, Tracer::LEVEL1,

"CIMResponseData::size ERROR. debug size mismatch."

"Computed = %u. variable = %u",rtnSize, _size ));

// KS_TEMP

cout << "Size err " << rtnSize << " " << _size << endl;

TEMPLOG;

}

//PEGASUS_TEST_ASSERT(rtnSize == _size);

#endif

PEG_METHOD_EXIT();

return _size;

}

// function used by OperationAggregator to aggregate response data in a

// single ResponseData object

// single ResponseData object. Adds all data in the from ResponseData object

// input variable to the target ResponseData object

// target array

void CIMResponseData::appendResponseData(const CIMResponseData & x)

{

// as the Messages set the data types, this should be impossible

TRACELINE;

// Confirm that the CIMResponseData type matches the type

// of the data being appended

PEGASUS_ASSERT(valid()); // KS_TEMP

PEGASUS_DEBUG_ASSERT(_dataType == x._dataType);

_encoding |= x._encoding;

// add all binary data

_binaryData.appendArray(x._binaryData);

// KS_TBD TODO PULL Add the counter incrementer for binary

// add all the C++ stuff

_instanceNames.appendArray(x._instanceNames);

_size += x._instanceNames.size();

_instances.appendArray(x._instances);

_size += x._instances.size();

_objects.appendArray(x._objects);

_size += x._objects.size();

// add the SCMO instances

_scmoInstances.appendArray(x._scmoInstances);

_size += x._scmoInstances.size();

// add Xml encodings too

// add Xml encodings

// KS_TBD - FIX _Size stuff here also.

_referencesData.appendArray(x._referencesData);

_instanceData.appendArray(x._instanceData);

_hostsData.appendArray(x._hostsData);

_nameSpacesData.appendArray(x._nameSpacesData);

// transfer property list

_propertyList = x._propertyList;

}

// Encoding responses into output format

void CIMResponseData::encodeBinaryResponse(CIMBuffer& out)

{

TRACELINE;

PEG_METHOD_ENTER(TRC_DISPATCHER,

"CIMResponseData::encodeBinaryResponse");

PSVALID;

// Need to do a complete job here by transferring all contained data

// into binary format and handing it out in the CIMBuffer

// KS_TODO

if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))

{

PEGASUS_ASSERT(false); // KS_TEMP

// Binary does NOT need a marker as it consists of C++ and SCMO

const Array<Uint8>& data = _binaryData;

out.putBytes(data.getData(), data.size());

}

if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))

{

out.putTypeMarker(BIN_TYPE_MARKER_CPPD);

Line 369

Line 756

void CIMResponseData::completeNamespace(const SCMOInstance * x)

{

TRACELINE;

const char * ns;

Uint32 len;

ns = x->getNameSpace_l(len);

Line 395

Line 783

p.setNameSpace(nsName);

}

break;

}

case RESP_INSTANCES:

{

Line 456

Line 845

}

void CIMResponseData::completeHostNameAndNamespace(

const String & hn,

const CIMNamespaceName & ns)

{

TRACELINE;

PEG_METHOD_ENTER(TRC_DISPATCHER,

"CIMResponseData::completeHostNameAndNamespace");

PEGASUS_ASSERT(valid()); // KS_TEMP

if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))

{

// On binary need remember hostname and namespace in case someone

Line 489

Line 883

{

switch (_dataType)

{

// Instances added to account for namedInstance in Pull operations.

case RESP_INSTANCES:

for (Uint32 j = 0, n = _instances.size(); j < n; j++)

{

const CIMInstance& instance = _instances[j];

CIMObjectPath& p =

const_cast<CIMObjectPath&>(instance.getPath());

if (p.getHost().size()==0)

{

p.setHost(hn);

}

if (p.getNameSpace().isNull())

{

p.setNameSpace(ns);

}

case RESP_OBJECTS:

{

for (Uint32 j = 0, n = _objects.size(); j < n; j++)

Line 507

Line 918

}

break;

}

// INSTNAMES added to account for instance paths in pull name

// operations

case RESP_INSTNAMES:

case RESP_OBJECTPATHS:

{

for (Uint32 j = 0, n = _instanceNames.size(); j < n; j++)

Line 535

Line 949

Uint32 nsLen = strlen(nsChars);

switch (_dataType)

{

// KS_PULL add Instances and InstNames to cover pull operations

// KS_PULL - Confirm that this OK.

case RESP_INSTNAMES:

case RESP_INSTANCES:

case RESP_OBJECTS:

case RESP_OBJECTPATHS:

{

for (Uint32 j = 0, n = _scmoInstances.size(); j < n; j++)

{

SCMOInstance & scmoInst=_scmoInstances[j];

if (0 == scmoInst.getHostName())

scmoInst.completeHostNameAndNamespace(

{

hnChars,

scmoInst.setHostName_l(hnChars,hnLen);

hnLen,

}

nsChars,

if (0 == scmoInst.getNameSpace())

nsLen);

{

scmoInst.setNameSpace_l(nsChars,nsLen);

}

break;

}

Line 558

Line 973

}

PEG_METHOD_EXIT();

}

void CIMResponseData::encodeXmlResponse(Buffer& out)

// NOTE: The reason for the isPullResponse variable is that there are

// some variations in ouput to Xml depending on whether the responses

// are one of the pull responses or not

void CIMResponseData::encodeXmlResponse(Buffer& out, Boolean isPullResponse)

{

TRACELINE;

PEG_TRACE((TRC_XML, Tracer::LEVEL3,

"CIMResponseData::encodeXmlResponse(encoding=%X,content=%X)",

"CIMResponseData::encodeXmlResponse(encoding=%X,dataType=%X)",

_encoding,

_dataType));

Line 574

Line 995

{

_resolveBinary();

}

if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))

{

switch (_dataType)

Line 592

Line 1012

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

{

if (isPullResponse)

{

out << STRLIT("<VALUE.INSTANCEWITHPATH>\n");

}

else

{

out << STRLIT("<VALUE.NAMEDINSTANCE>\n");

}

out.append((char*)b[i].getData(), b[i].size() - 1);

out.append((char*)a[i].getData(), a[i].size() - 1);

if (isPullResponse)

{

out << STRLIT("</VALUE.INSTANCEWITHPATH>\n");

}

else

{

out << STRLIT("</VALUE.NAMEDINSTANCE>\n");

}

break;

}

case RESP_OBJECTS:

Line 643

Line 1077

{

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

{

XmlWriter::appendInstanceNameElement(out,_instanceNames[i]);

// Element type is different for Pull responses

if (isPullResponse)

{

XmlWriter::appendInstancePathElement(out,

_instanceNames[i]);

}

else

{

XmlWriter::appendInstanceNameElement(out,

_instanceNames[i]);

}

break;

}

Line 651

Line 1095

{

if (_instances.size() > 0)

{

XmlWriter::appendInstanceElement(out, _instances[0]);

XmlWriter::appendInstanceElement(

out,

_instances[0],

_includeQualifiers,

_includeClassOrigin,

_propertyList);

}

break;

}

Line 659

Line 1108

{

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

{

if (isPullResponse)

{

XmlWriter::appendValueInstanceWithPathElement(

out,

_instances[i],

_includeQualifiers,

_includeClassOrigin,

_propertyList);

}

else

{

XmlWriter::appendValueNamedInstanceElement(

out, _instances[i]);

out,

_instances[i],

_includeQualifiers,

_includeClassOrigin,

_propertyList);

}

break;

}

Line 668

Line 1133

{

for (Uint32 i = 0; i < _objects.size(); i++)

{

// If pull, map to instances

if (isPullResponse)

{

CIMInstance x = (CIMInstance)_objects[i];

XmlWriter::appendValueInstanceWithPathElement(

out, x,

_includeQualifiers,

_includeClassOrigin,

_propertyList);

}

else

{

XmlWriter::appendValueObjectWithPathElement(

out,

_objects[i]);

_objects[i],

_includeQualifiers,

_includeClassOrigin,

_isClassOperation,

_propertyList);

}

break;

}

Line 678

Line 1160

{

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

{

// ObjectPaths come from providers for pull operations

// but are encoded as instancePathElements

if (isPullResponse)

{

XmlWriter::appendInstancePathElement(out,

_instanceNames[i]);

}

else

{

out << "<OBJECTPATH>\n";

XmlWriter::appendValueReferenceElement(

out,

_instanceNames[i],

_isClassOperation,

false);

out << "</OBJECTPATH>\n";

}

break;

}

default:

Line 699

Line 1193

{

case RESP_INSTNAMES:

{

if (isPullResponse)

{

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

{

SCMOXmlWriter::appendInstancePathElement(

out,

_scmoInstances[i]);

}

else

{

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

{

SCMOXmlWriter::appendInstanceNameElement(

out,

_scmoInstances[i]);

}

break;

}

Line 711

Line 1219

{

if (_scmoInstances.size() > 0)

{

SCMOXmlWriter::appendInstanceElement(out,_scmoInstances[0]);

if(_propertyList.isNull())

{

Array<Uint32> emptyNodes;

SCMOXmlWriter::appendInstanceElement(

out,

_scmoInstances[0],

false,

emptyNodes);

}

else

{

Array<propertyFilterNodesArray_t> propFilterNodesArrays;

// This searches for an already created array of nodes,

//if not found, creates it inside propFilterNodesArrays

const Array<Uint32> & nodes=

SCMOXmlWriter::getFilteredNodesArray(

propFilterNodesArrays,

_scmoInstances[0],

_propertyList);

SCMOXmlWriter::appendInstanceElement(

out,

_scmoInstances[0],

true,

nodes);

}

break;

}

case RESP_INSTANCES:

{

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

if (isPullResponse)

{

SCMOXmlWriter::appendValueSCMOInstanceElement(

SCMOXmlWriter::appendValueSCMOInstanceWithPathElements(

out,

out, _scmoInstances, _propertyList);

_scmoInstances[i]);

}

else

{

SCMOXmlWriter::appendValueSCMOInstanceElements(

out, _scmoInstances, _propertyList);

}

break;

}

case RESP_OBJECTS:

{

for (Uint32 i = 0; i < _scmoInstances.size(); i++)

if (isPullResponse)

{

SCMOXmlWriter::appendValueSCMOInstanceWithPathElements(

out,_scmoInstances, _propertyList);

}

else

{

// KS_TODO why is this one named element rather than

// elements

SCMOXmlWriter::appendValueObjectWithPathElement(

out,

out, _scmoInstances, _propertyList);

_scmoInstances[i]);

}

break;

}

Line 739

Line 1281

{

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

{

if (isPullResponse)

{

SCMOXmlWriter::appendInstancePathElement(out,

_scmoInstances[i]);

}

else

{

out << "<OBJECTPATH>\n";

SCMOXmlWriter::appendValueReferenceElement(

out,

out, _scmoInstances[i],

_scmoInstances[i],

false);

out << "</OBJECTPATH>\n";

}

break;

}

default:

Line 760

Line 1309

// not usable by clients

void CIMResponseData::encodeInternalXmlResponse(CIMBuffer& out)

{

TRACELINE;

PEG_TRACE((TRC_XML, Tracer::LEVEL3,

"CIMResponseData::encodeInternalXmlResponse(encoding=%X,content=%X)",

_encoding,

_dataType));

// For mixed (CIM+SCMO) responses, we need to tell the receiver the

// total number of instances. The totalSize variable is used to keep track

// of this.

Line 787

Line 1336

if (0 == _instances.size())

{

_instances.append(CIMInstance());

CIMInternalXmlEncoder::_putXMLInstance(

out,

_instances[0]);

break;

}

CIMInternalXmlEncoder::_putXMLInstance(out, _instances[0]);

CIMInternalXmlEncoder::_putXMLInstance(

out,

_instances[0],

_includeQualifiers,

_includeClassOrigin,

_propertyList);

break;

}

case RESP_INSTANCES:

Line 800

Line 1358

{

CIMInternalXmlEncoder::_putXMLNamedInstance(

out,

_instances[i]);

_instances[i],

_includeQualifiers,

_includeClassOrigin,

_propertyList);

}

break;

}

Line 811

Line 1372

out.putUint32(totalSize);

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

{

CIMInternalXmlEncoder::_putXMLObject(out, _objects[i]);

CIMInternalXmlEncoder::_putXMLObject(

out,

_objects[i],

_includeQualifiers,

_includeClassOrigin,

_propertyList);

}

break;

}

Line 835

Line 1401

{

_scmoInstances.append(SCMOInstance());

}

SCMOInternalXmlEncoder::_putXMLInstance(out, _scmoInstances[0]);

SCMOInternalXmlEncoder::_putXMLInstance(

out,

_scmoInstances[0],

_propertyList);

break;

}

case RESP_INSTANCES:

Line 846

Line 1415

{

out.putUint32(n);

}

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

{

SCMOInternalXmlEncoder::_putXMLNamedInstance(

out,

_scmoInstances[i]);

_scmoInstances,

}

_propertyList);

break;

}

case RESP_OBJECTS:

Line 862

Line 1429

{

out.putUint32(n);

}

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

{

SCMOInternalXmlEncoder::_putXMLObject(

out,

_scmoInstances[i]);

_scmoInstances,

}

_propertyList);

break;

}

// internal xml encoding of instance names and object paths not

Line 880

Line 1445

}

void CIMResponseData::_resolveToCIM()

{

TRACELINE;

PEG_TRACE((TRC_XML, Tracer::LEVEL3,

"CIMResponseData::_resolveToCIM(encoding=%X,content=%X)",

_encoding,

Line 907

Line 1474

void CIMResponseData::_resolveToSCMO()

{

TRACELINE;

PEG_TRACE((TRC_XML, Tracer::LEVEL3,

"CIMResponseData::_resolveToSCMO(encoding=%X,content=%X)",

_encoding,

Line 932

Line 1500

// avoided whenever possible

void CIMResponseData::_resolveBinary()

{

TRACELINE;

PEG_METHOD_ENTER(TRC_DISPATCHER,

"CIMResponseData::_resolveBinary");

Line 1044

Line 1613

PEG_METHOD_EXIT();

}

void CIMResponseData::_resolveXmlToCIM()

void CIMResponseData::_deserializeObject(Uint32 idx,CIMObject& cimObject)

{

switch (_dataType)

// Only start the parser when instance data is present.

if (0 != _instanceData[idx].size())

{

// Xml encoding for instance names and object paths not used

CIMInstance cimInstance;

case RESP_OBJECTPATHS:

CIMClass cimClass;

case RESP_INSTNAMES:

XmlParser parser((char*)_instanceData[idx].getData());

if (XmlReader::getInstanceElement(parser, cimInstance))

{

break;

cimObject = CIMObject(cimInstance);

return;

}

case RESP_INSTANCE:

{

if (XmlReader::getClassElement(parser, cimClass))

CIMInstance cimInstance;

// Deserialize instance:

{

XmlParser parser((char*)_instanceData[0].getData());

cimObject = CIMObject(cimClass);

return;

}

PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,

"Failed to resolve XML object data, parser error!");

}

if (!XmlReader::getInstanceElement(parser, cimInstance))

void CIMResponseData::_deserializeInstance(Uint32 idx,CIMInstance& cimInstance)

{

cimInstance = CIMInstance();

// Only start the parser when instance data is present.

if (0 != _instanceData[idx].size())

{

XmlParser parser((char*)_instanceData[idx].getData());

if (XmlReader::getInstanceElement(parser, cimInstance))

{

return;

}

PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,

"Failed to resolve XML instance, parser error!");

}

// reset instance when parsing may not be successfull or

// no instance is present.

cimInstance = CIMInstance();

}

// Deserialize path:

{

XmlParser parser((char*)_referencesData[0].getData());

CIMObjectPath cimObjectPath;

Boolean CIMResponseData::_deserializeReference(

Uint32 idx,

CIMObjectPath& cimObjectPath)

{

// Only start the parser when reference data is present.

if (0 != _referencesData[idx].size())

{

XmlParser parser((char*)_referencesData[idx].getData());

if (XmlReader::getValueReferenceElement(parser, cimObjectPath))

{

if (_hostsData.size())

if (_hostsData[idx].size())

{

cimObjectPath.setHost(_hostsData[0]);

cimObjectPath.setHost(_hostsData[idx]);

}

if (!_nameSpacesData[0].isNull())

if (!_nameSpacesData[idx].isNull())

{

cimObjectPath.setNameSpace(_nameSpacesData[0]);

cimObjectPath.setNameSpace(_nameSpacesData[idx]);

}

cimInstance.setPath(cimObjectPath);

return true;

// only if everything works we add the CIMInstance to the

// array

_instances.append(cimInstance);

}

PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,

"Failed to resolve XML reference, parser error!");

}

break;

return false;

}

case RESP_INSTANCES:

Boolean CIMResponseData::_deserializeInstanceName(

Uint32 idx,

CIMObjectPath& cimObjectPath)

{

for (Uint32 i = 0; i < _instanceData.size(); i++)

// Only start the parser when instance name data is present.

if (0 != _referencesData[idx].size())

{

CIMInstance cimInstance;

XmlParser parser((char*)_referencesData[idx].getData());

// Deserialize instance:

if (XmlReader::getInstanceNameElement(parser, cimObjectPath))

{

XmlParser parser((char*)_instanceData[i].getData());

if (_hostsData[idx].size())

if (!XmlReader::getInstanceElement(parser, cimInstance))

{

cimObjectPath.setHost(_hostsData[idx]);

}

if (!_nameSpacesData[idx].isNull())

{

cimObjectPath.setNameSpace(_nameSpacesData[idx]);

}

return true;

}

PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,

"Failed to resolve XML instance."

"Failed to resolve XML instance name, parser error!");

" Creating empty instance!");

cimInstance = CIMInstance();

}

return false;

}

// Deserialize path:

void CIMResponseData::_resolveXmlToCIM()

{

TRACELINE;

switch (_dataType)

{

// Xml encoding for instance names and object paths not used

case RESP_OBJECTPATHS:

case RESP_INSTNAMES:

{

XmlParser parser((char*)_referencesData[i].getData());

break;

}

case RESP_INSTANCE:

{

CIMInstance cimInstance;

CIMObjectPath cimObjectPath;

if (XmlReader::getInstanceNameElement(parser,cimObjectPath))

_deserializeInstance(0,cimInstance);

if (_deserializeReference(0,cimObjectPath))

{

if (!_nameSpacesData[i].isNull())

cimObjectPath.setNameSpace(_nameSpacesData[i]);

if (_hostsData[i].size())

cimObjectPath.setHost(_hostsData[i]);

cimInstance.setPath(cimObjectPath);

}

// A single CIMInstance has to have an objectpath.

}

// So only add it when an objectpath exists.

_instances.append(cimInstance);

}

break;

}

case RESP_OBJECTS:

case RESP_INSTANCES:

{

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

{

CIMObject cimObject;

for (Uint32 i = 0; i < _instanceData.size(); i++)

// Deserialize Objects:

{

XmlParser parser((char*)_instanceData[i].getData());

CIMInstance cimInstance;

CIMClass cimClass;

CIMObjectPath cimObjectPath;

if (XmlReader::getInstanceElement(parser, cimInstance))

_deserializeInstance(i,cimInstance);

{

if (_deserializeInstanceName(i,cimObjectPath))

cimObject = CIMObject(cimInstance);

}

else if (XmlReader::getClassElement(parser, cimClass))

{

cimObject = CIMObject(cimClass);

cimInstance.setPath(cimObjectPath);

}

else

// enumarate instances can be without name

{

_instances.append(cimInstance);

PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,

"Failed to get XML object data!");

}

break;

}

case RESP_OBJECTS:

// Deserialize paths:

{

XmlParser parser((char*)_referencesData[i].getData());

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

{

CIMObject cimObject;

CIMObjectPath cimObjectPath;

if (XmlReader::getValueReferenceElement(

_deserializeObject(i,cimObject);

parser,

if (_deserializeReference(i,cimObjectPath))

cimObjectPath))

{

if (!_nameSpacesData[i].isNull())

cimObjectPath.setNameSpace(_nameSpacesData[i]);

if (_hostsData[i].size())

cimObjectPath.setHost(_hostsData[i]);

cimObject.setPath(cimObjectPath);

}

_objects.append(cimObject);

}

break;

Line 1198

Line 1789

void CIMResponseData::_resolveXmlToSCMO()

{

TRACELINE;

// Not optimal, can probably be improved

// but on the other hand, since using the binary format this case should

// actually not ever happen.

Line 1207

Line 1799

void CIMResponseData::_resolveSCMOToCIM()

{

TRACELINE;

switch(_dataType)

{

case RESP_INSTNAMES:

Line 1264

Line 1857

void CIMResponseData::_resolveCIMToSCMO()

{

TRACELINE;

CString nsCString=_defaultNamespace.getString().getCString();

const char* _defNamespace = nsCString;

Uint32 _defNamespaceLen;

Line 1338

Line 1932

_instanceNames[i],

_defNamespace,

_defNamespaceLen);

// TODO: More description about this.

if (_isClassOperation)

if (0 == _instanceNames[i].getKeyBindings().size())

{

// if there is no keybinding, this is a class

addme.setIsClassOnly(true);

}

_scmoInstances.append(addme);

Line 1361

Line 1953

_encoding |=RESP_ENC_SCMO;

}

/**

* Validate the magic object for this CIMResponseData. This

* compiles only in debug mode and can be use to validate the

* CIMResponseData object

* @return Boolean True if valid object.

Boolean CIMResponseData::valid()

{

return _magic;

}

void CIMResponseData::setRequestProperties(

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList& propertyList)

{

TRACELINE;

_includeQualifiers = includeQualifiers;

_includeClassOrigin = includeClassOrigin;

_propertyList = propertyList;

}

void CIMResponseData::setIsClassOperation(Boolean b)

{

_isClassOperation = b;

}

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.4
changed lines
	Added in v.1.5.2.7

No CVS admin address has been configured