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.6.2.2 and 1.6.2.11

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

version 1.6.2.11, 2013/11/20 00:31:51

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

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

#ifndef Pegasus_CIMResponseData_h

Line 39

Line 46

#include <Pegasus/Common/SCMOClass.h>

#include <Pegasus/Common/SCMOInstance.h>

#include <Pegasus/Common/SCMODump.h>

#include <Pegasus/Common/Mutex.h> // KS_TODO Remove

#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

//// KS_TODO REMOVE THIS _Temp test for size validity DELETE when done

//// With development of pull extensions that use the size() function

#define TEST_SIZE_VALID PEGASUS_ASSERT(sizeValid());

////#define TEST_SIZE_VALID

#define TEST_SIZE_VALID {printf("TEST_SIZE_VALID Error line %u\n",__LINE__); \

PEGASUS_ASSERT(sizeValid());}

#define TEST_SIZE_VALID {if(!sizeValid(){

printf("TEST_SIZE_VALID Error line %u\n",__LINE__);

PEGASUS_ASSERT(false);}}

class PEGASUS_COMMON_LINKAGE CIMResponseData

{

public:

Line 68

Line 88

};

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

//_propertyList is initialized to an empty propertylist to enable

// sending all properties by default.

// sending all properties by default. _isClassOperation set false and

// only reset by selected operations (ex. associator response builder)

CIMResponseData(ResponseDataContent content):

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

_encoding(0),_dataType(content),_size(0), _includeQualifiers(true),

_includeQualifiers(true),_includeClassOrigin(true),

_includeClassOrigin(true),

_isClassOperation(false),

_propertyList(CIMPropertyList())

{

PEGASUS_ASSERT(valid()); // KS_TEMP

/// KS_TODO the following is all test code.

PEGASUS_DEBUG_ASSERT(valid()); // KS_TEMP KS_TODO DELETE THIS

size();

}

CIMResponseData(const CIMResponseData & x):

Line 95

Line 119

_scmoInstances(x._scmoInstances),

_includeQualifiers(x._includeQualifiers),

_includeClassOrigin(x._includeClassOrigin),

_isClassOperation(x._isClassOperation),

_propertyList(x._propertyList),

_magic(x._magic)

{

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

PEGASUS_DEBUG_ASSERT(valid()); // KS_TEMP

PEGASUS_ASSERT(valid()); // KS_TEMP

}

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

Line 112

Line 136

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

_includeQualifiers(true), _includeClassOrigin(true),

_propertyList(CIMPropertyList())

{}

{

PEGASUS_DEBUG_ASSERT(valid()); // KS_TEMP

}

/**

* Move CIM objects from another CIMResponse data object to this

Line 134

Line 161

Uint32 size();

/** Set the internal size variable based on the current count

* of what is in the CIMResponseData. This operation

* required after users have played with the arrays. See

* CQLOperationRequestDispatcher for example */

void setSize();

/** Determine if there is any binary content in the CIM

ResponseData object

@return Boolean true if binary data exists in content.

Boolean hasBinaryData() const;

~CIMResponseData()

{

}

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

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

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

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

_dataType = content;

return true;

Line 155

Line 195

// get the datatype property

ResponseDataContent getResponseDataContent()

{

PEGASUS_ASSERT(valid()); // KS_TEMP KS_TODO

PEGASUS_DEBUG_ASSERT(valid()); // KS_TEMP KS_TODO

return _dataType;

}

// C++ objects interface handling

Line 165

Line 205

void setInstanceNames(const Array<CIMObjectPath>& x)

{

//// AutoMutex autoMut(testLock);

_instanceNames=x;

_encoding |= RESP_ENC_CIM;

_size += x.size();

Line 175

Line 216

void setInstance(const CIMInstance& x)

{

SVALID();

//// AutoMutex autoMut(testLock);

TEST_SIZE_VALID;

_instances.clear();

_instances.append(x);

_size++;

_encoding |= RESP_ENC_CIM;

SVALID();

TEST_SIZE_VALID;

}

// Instances handling

Line 200

Line 242

void setInstances(const Array<CIMInstance>& x)

{

SVALID();

//// AutoMutex autoMut(testLock);

TEST_SIZE_VALID;

_instances=x;

_encoding |= RESP_ENC_CIM;

_size += x.size();

SVALID();

TEST_SIZE_VALID;

}

void appendInstance(const CIMInstance& x)

{

PEGASUS_ASSERT(valid());

//// AutoMutex autoMut(testLock);

PEGASUS_DEBUG_ASSERT(valid());

_instances.append(x);

_encoding |= RESP_ENC_CIM;

_size += 1;

Line 217

Line 261

void appendInstances(const Array<CIMInstance>& x)

{

PEGASUS_ASSERT(valid());

//// AutoMutex autoMut(testLock);

PEGASUS_DEBUG_ASSERT(valid());

_instances.appendArray(x);

_encoding |= RESP_ENC_CIM;

_size += x.size();

Line 227

Line 272

Array<CIMObject>& getObjects();

void setObjects(const Array<CIMObject>& x)

{

PEGASUS_ASSERT(valid());

//// AutoMutex autoMut(testLock);

PEGASUS_DEBUG_ASSERT(valid());

_objects=x;

_encoding |= RESP_ENC_CIM;

_size += x.size();

}

void appendObject(const CIMObject& x)

{

PEGASUS_ASSERT(valid());

//// AutoMutex autoMut(testLock);

PEGASUS_DEBUG_ASSERT(valid());

_objects.append(x);

_encoding |= RESP_ENC_CIM;

_size += 1;

Line 248

Line 295

void appendSCMO(const Array<SCMOInstance>& x)

{

PEGASUS_ASSERT(valid());

//// AutoMutex autoMut(testLock);

PEGASUS_DEBUG_ASSERT(valid());

_scmoInstances.appendArray(x);

_encoding |= RESP_ENC_SCMO;

_size += x.size();

Line 277

Line 325

// Function primarily used by CIMOperationRequestDispatcher to complete

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

// OperationAggregator

// OperationAggregator. Note that behavior is different for pull operations

void completeHostNameAndNamespace(

const String & hn,

const CIMNamespaceName & ns);

const CIMNamespaceName & ns,

Boolean isPullOperation = false);

// Encoding responses

Line 298

Line 347

void encodeXmlResponse(Buffer& out, Boolean isPull);

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

Boolean valid();

Boolean valid() const;

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

void encodeXmlResponse(Buffer& out);

Line 311

Line 360

const Boolean includeClassOrigin,

const CIMPropertyList& propertyList);

// Used with association and reference operations (i.e. operations that

// return CIMObject or CIMObjectPath to set a parameter to define whether

// responseData is for operation on a class or instance.

// Allows building the correct path (classPath or instancePath) and

// object type (Class or Instance) on response.

void setIsClassOperation(Boolean b);

void setPropertyList(const CIMPropertyList& propertyList)

{

_propertyList = propertyList;

Line 320

Line 376

return _propertyList;

}

void SVALID(); //KS_TEMP

bool sizeValid(); //KS_TEMP KS_TODO REMOVE

void traceResponseData(); // KS_TODO Diagnostic. remove

void resolveBinaryToSCMO();

private:

Line 331

Line 391

void _resolveToCIM();

void _resolveToSCMO();

void _resolveBinary();

void _resolveBinaryToSCMO();

void _resolveXmlToSCMO();

void _resolveXmlToCIM();

Line 344

Line 404

SCMOInstance _getSCMOFromCIMObject(const CIMObject& cimObj);

SCMOInstance _getSCMOFromCIMObjectPath(const CIMObjectPath& cimPath);

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

void _deserializeInstance(Uint32 idx,CIMInstance& cimInstance);

void _deserializeObject(Uint32 idx,CIMObject& cimObject);

Boolean _deserializeReference(Uint32 idx,CIMObjectPath& cimObjectPath);

Boolean _deserializeInstanceName(Uint32 idx,CIMObjectPath& cimObjectPath);

// Bitflags in this integer will reflect what data representation types

// Bitflags in this integer reflect what data representation types

// are currently stored in this CIMResponseData object

Uint32 _encoding;

Line 359

Line 423

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

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

// representations

// representations. Note that there are a couple of cases where the

// CIMResponseData can be used in a way that makes this not 100% accurate.

Uint32 _size;

// unused arrays are represented by ArrayRepBase _empty_rep

Line 385

Line 450

// SCMO encoding

Array<SCMOInstance> _scmoInstances;

// Request characteristics that are carried through operation for

// modification of response generation.

Boolean _includeQualifiers;

Boolean _includeClassOrigin;

// Defines whether response CIMObjects or ObjectPaths are class or instance.

// because associators, etc. operations provide both class and instance

// responses. Default is false and should only be set to true by

// operation requests such as associators (which could return either

// instances or classes) when the operation is to return class information.

Boolean _isClassOperation;

CIMPropertyList _propertyList;

// Function lock used for debugging cases where there might have been an

// issue with multithreading and CIMResponseData.

//// KS_TODO remove before pull checkin

Mutex testLock;

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

// of response data.

Magic<0x57D11323> _magic;

};

PEGASUS_NAMESPACE_END

Legend:

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

No CVS admin address has been configured