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

Return to CIMResponseData.h CVS log

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

Diff for /pegasus/src/Pegasus/Common/CIMResponseData.h between version 1.3.2.4 and 1.6.2.2

version 1.3.2.4, 2009/10/13 13:39:24

version 1.6.2.2, 2011/10/11 18:18:08

Line 39

#include <Pegasus/Common/SCMOClass.h>

#include <Pegasus/Common/SCMOInstance.h>

#include <Pegasus/Common/SCMODump.h>

#include <Pegasus/Common/Magic.h>

PEGASUS_NAMESPACE_BEGIN

PEGASUS_USING_STD;

typedef Array<Sint8> ArraySint8;

#define PEGASUS_ARRAY_T ArraySint8

# include <Pegasus/Common/ArrayInter.h>

#undef PEGASUS_ARRAY_T

// TODO: Consider a reference counting for this class

// Contra thesis: Mostly used by pointer reference, i.e. never really copied

class PEGASUS_COMMON_LINKAGE CIMResponseData

{

public:

Line 58

Line 56

RESP_ENC_CIM = 1,

RESP_ENC_BINARY = 2,

RESP_ENC_XML = 4,

RESP_ENC_SCMO = 8,

RESP_ENC_SCMO = 8

RESP_ENC_MIXED = 16

};

enum ResponseDataContent {

Line 69

Line 66

RESP_OBJECTS = 4,

RESP_OBJECTPATHS =5

};

//includeClassOrigin & _includeQualifiers are set to true by default.

//_propertyList is initialized to an empty propertylist to enable

// sending all properties by default.

CIMResponseData(ResponseDataContent content):

_encoding(0),

_encoding(0),_mapObjectsToIntances(false),_dataType(content), _size(0),

_dataType(content)

_includeQualifiers(true),_includeClassOrigin(true),

_propertyList(CIMPropertyList())

{

fprintf(stderr,"CIMResponseData() called with content=%X\n",content);

PEGASUS_ASSERT(valid()); // KS_TEMP

fflush(stderr);

}

};

CIMResponseData(const CIMResponseData & x):

_encoding(x._encoding),

_mapObjectsToIntances(x._mapObjectsToIntances),

_dataType(x._dataType),

_size(x._size),

_referencesData(x._referencesData),

_instanceData(x._instanceData),

_hostsData(x._hostsData),

_nameSpacesData(x._nameSpacesData),

_binaryData(x._binaryData),

_defaultNamespace(x._defaultNamespace),

_defaultHostname(x._defaultHostname),

_instanceNames(x._instanceNames),

_instances(x._instances),

_objects(x._objects),

_scmoInstances(x._scmoInstances),

_includeQualifiers(x._includeQualifiers),

_includeClassOrigin(x._includeClassOrigin),

_propertyList(x._propertyList),

_magic(x._magic)

{

/////PEGASUS_ASSERT(x.valid()); // KS_TEMP

PEGASUS_ASSERT(valid()); // KS_TEMP

}

// Construct an empty object. Issue here in that we would like to

// assure that this is invalid but if we add the _dataType parameter

// it must be a valid one. The alternative would be to define an

// invalid enum but that would cost us in all case/if statements.

// Therefore up to the user to create and then use correctly.

// KS_TODO fix this so that the empty state is somehow protected.

CIMResponseData():

_encoding(0),_mapObjectsToIntances(false), _size(0),

_includeQualifiers(true), _includeClassOrigin(true),

_propertyList(CIMPropertyList())

{}

/**

* Move CIM objects from another CIMResponse data object to this

* CIMResponseData object. Moves the number of objects defined

* in the count parameter from one to another. They are removed

* from the from object and inserted into the to object.

* @param CIMResponseData from which the objects are moved

* @param count Uint32 count of objects to move

* @return - Actual number of objects moved.

Uint32 moveObjects(CIMResponseData & x, Uint32 count);

/**

* Return count of the number of CIM objects in the

* CIMResponseData object

* @return Uint32 The count of the number of CIM objects

* (instances, paths, or objects)in the CIMResponsedata object

Uint32 size();

~CIMResponseData()

{

}

// This one may be a hack but we have issue with pull and other operations

// in that the other assoc operations return objects and objectPaths

// and the pulls return instances and instancePaths). The pull operation

// must be able to handle either so we use this to reset the datatype

// KS_TODO -- This should check size and only allow if nothing in the

// object.

Boolean setDataType(ResponseDataContent content)

{

PEGASUS_ASSERT(valid());

PEGASUS_ASSERT(_size == 0); // KS_TODO_TEMP or debug mode.

_dataType = content;

return true;

}

// get the datatype property

ResponseDataContent getResponseDataContent()

{

PEGASUS_ASSERT(valid()); // KS_TEMP KS_TODO

return _dataType;

}

// C++ objects interface handling

// Instance Names handling

Line 87

Line 167

{

_instanceNames=x;

_encoding |= RESP_ENC_CIM;

}

_size += x.size();

void appendInstanceName(const CIMObjectPath& x)

{

_instanceNames.append(x);

_encoding |= RESP_ENC_CIM;

}

// Instance handling

Line 99

Line 175

void setInstance(const CIMInstance& x)

{

SVALID();

_instances.clear();

_instances.append(x);

_size++;

_encoding |= RESP_ENC_CIM;

SVALID();

}

// Instances handling

Array<CIMInstance>& getInstances();

// Get an array of CIMInstances from the CIMResponseData converting from

// any of the internal forms to the C++ format. This will also convert

// CIMObjects to CIMInstances if there are any CIMObjects.

// 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 the BinaryCodec working for the moment.

// Expect that this will be used only in CIMCLient.cpp

Array<CIMInstance>& getInstancesFromInstancesOrObjects();

void setInstances(const Array<CIMInstance>& x)

{

SVALID();

_instances=x;

_encoding |= RESP_ENC_CIM;

_size += x.size();

SVALID();

}

void appendInstance(const CIMInstance& x)

{

PEGASUS_ASSERT(valid());

_instances.append(x);

_encoding |= RESP_ENC_CIM;

_size += 1;

}

void appendInstances(const Array<CIMInstance>& x)

{

PEGASUS_ASSERT(valid());

_instances.appendArray(x);

_encoding |= RESP_ENC_CIM;

_size += x.size();

}

// Objects handling

Array<CIMObject>& getObjects();

void setObjects(const Array<CIMObject>& x)

{

PEGASUS_ASSERT(valid());

_objects=x;

_encoding |= RESP_ENC_CIM;

_size += x.size();

}

void appendObject(const CIMObject& x)

{

PEGASUS_ASSERT(valid());

_objects.append(x);

_encoding |= RESP_ENC_CIM;

_size += 1;

}

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

// object paths are represented as SCMOInstance

Array<SCMOInstance>& getSCMO();

void setSCMO(const Array<SCMOInstance>& x)

void setSCMO(const Array<SCMOInstance>& x);

{

_scmoInstances=x;

_encoding |= RESP_ENC_SCMO;

}

void appendSCMO(const Array<SCMOInstance>& x)

{

PEGASUS_ASSERT(valid());

_scmoInstances.appendArray(x);

_encoding |= RESP_ENC_SCMO;

_size += x.size();

}

// Binary data is just a data stream

Array<Uint8>& getBinary();

bool setBinary(CIMBuffer& in, bool hasLen=true);

// Set the binary stream in the CIMBuffer into the CIMResponseData

bool setBinary(CIMBuffer& in);

// Set any data from the CIMBuffer remaining after the current CIMBuffer

// position pointer into the CIMResponseData Object.

bool setRemainingBinaryData(CIMBuffer& in);

// Xml data is unformatted, no need to differentiate between instance

// instances and object paths or objects

Line 158

Line 271

// single ResponseData object

void appendResponseData(const CIMResponseData & x);

// Function used by CMPI layer to complete the namespace on all data held

// Input (x) has to have a valid namespace

void completeNamespace(const SCMOInstance * x);

// Function primarily used by CIMOperationRequestDispatcher to complete

// namespace and hostname on a,an,r and rn operations in the

// OperationAggregator

void completeHostNameAndNamespace(

const String & hn,

const CIMNamespaceName & ns);

// Encoding responses

// binary format used with Provider Agents and OP Clients

// Encode the CIMResponse data into binary format used with Provider Agents

// and OP Clients in the provider CIMBuffer

void encodeBinaryResponse(CIMBuffer& out);

// Xml format used with Provider Agents only

// Encode the CIMResponse data into Xml format used with Provider Agents

// only in the provided CIMBuffer

void encodeInternalXmlResponse(CIMBuffer& out);

// Encode the CIMResponse data into official Xml format(CIM over Http)

// used to communicate to clients in the provided CIMBuffer.

//Note that the pull responses requires a flag.

void encodeXmlResponse(Buffer& out, Boolean isPull);

// diagnostic tests magic number in context to see if valid object

Boolean valid();

// official Xml format(CIM over Http) used to communicate to clients

void encodeXmlResponse(Buffer& out);

//This function is called from buildResponce to set CIMResponcedata

//with respective values of IncludeQualifiers,IncludeClassOrigin and

//propertyFilter.

void setRequestProperties(

const Boolean includeQualifiers,

const Boolean includeClassOrigin,

const CIMPropertyList& propertyList);

void setPropertyList(const CIMPropertyList& propertyList)

{

_propertyList = propertyList;

}

CIMPropertyList & getPropertyList()

{

return _propertyList;

}

void SVALID(); //KS_TEMP

private:

// helper functions to transform different formats into one-another

Line 186

Line 341

// Helper functions for this class only, do NOT externalize

SCMOInstance _getSCMOFromCIMInstance(const CIMInstance& cimInst);

SCMOInstance _getSCMOFromCIMObject(const CIMObject& cimObj);

SCMOInstance _getSCMOFromCIMObjectPath(const CIMObjectPath& cimPath);

SCMOClass* _getSCMOClass(const char* ns,const char* cls);

Line 193

Line 349

// are currently stored in this CIMResponseData object

Uint32 _encoding;

// Special flag to handle the case where binary data in passed through the

// system but must be mapped to instances in the getInstances. This

// accounts for only one case today, binary data in the BinaryCodec

Boolean _mapObjectsToIntances;

// Storing type of data in this enumeration

ResponseDataContent _dataType;

// Count of objects stored in this CIMResponseData object. This is the

// accumulated count of objects stored in all of the data

// representations

Uint32 _size;

// unused arrays are represented by ArrayRepBase _empty_rep

// which is a 16 byte large static shared across all of them

// so, even though this object looks large, it holds just

Line 209

Line 375

// For binary encoding.

Array<Uint8> _binaryData;

CIMNamespaceName _defaultNamespace;

String _defaultHostname;

// Default C++ encoding

Array<CIMObjectPath> _instanceNames;

Line 217

Line 385

// SCMO encoding

Array<SCMOInstance> _scmoInstances;

Boolean _includeQualifiers;

Boolean _includeClassOrigin;

CIMPropertyList _propertyList;

// magic number to use with valid function to confirm validity

// of response data.

Magic<0x57D11323> _magic;

};

Legend:

Removed from v.1.3.2.4
changed lines
	Added in v.1.6.2.2

No CVS admin address has been configured