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.9 and 1.6.2.19

version 1.3.2.9, 2009/11/10 09:43:32

version 1.6.2.19, 2014/05/05 20:59:42

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

class PEGASUS_COMMON_LINKAGE CIMResponseData

{

public:

Line 66

Line 75

RESP_OBJECTS = 4,

RESP_OBJECTPATHS =5

};

/** Constructor that sets the ResponseDataContent attributes.

includeClassOrigin & _includeQualifiers are set to true by

default. //_propertyList is initialized to an empty

propertylist to enable // sending all properties by default.

_isClassOperation set false and // only reset by selected

operations (ex. associator response builder)

CIMResponseData(ResponseDataContent content):

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

_includeQualifiers(true),

_includeClassOrigin(true),

_isClassOperation(false),

_propertyList(CIMPropertyList())

{}

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

_isClassOperation(x._isClassOperation),

_propertyList(x._propertyList),

_magic(x._magic)

{

PEGASUS_DEBUG_ASSERT(valid());

}

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

{

PEGASUS_DEBUG_ASSERT(valid());

}

/**

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

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

{ }

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

void setDataType(ResponseDataContent content)

{

PEGASUS_DEBUG_ASSERT(valid());

// This assert is temp test since the object should be zero

// size when data type set.

PEGASUS_ASSERT(_size == 0);

_dataType = content;

}

CIMResponseData(ResponseDataContent content):_encoding(0),_dataType(content)

/** Move key attributes from one CIMResponseData object to

{};

another. The attributes include the _dataType,

includeQualifiers and includeClassOrigin and properties

parameters. This used with pull operations to set up

output CIMResponseData from cache.

@param from CIMResponseData object that is source for attributes

void setResponseAttributes(CIMResponseData& from)

{

PEGASUS_DEBUG_ASSERT(valid());

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

_dataType = from._dataType;

_includeQualifiers = from._includeQualifiers;

_includeClassOrigin = from._includeClassOrigin;

_propertyList = from._propertyList;

}

// C++ objects interface handling

/** get the datatype property

@return ResponseDataContent enum value

ResponseDataContent getResponseDataContent()

{

PEGASUS_DEBUG_ASSERT(valid());

return _dataType;

}

/*******************************************************************

** C++ objects interface handling

*******************************************************************/

// Instance Names handling

Array<CIMObjectPath>& getInstanceNames();

Line 79

Line 220

{

_instanceNames=x;

_encoding |= RESP_ENC_CIM;

_size += x.size();

}

void appendInstanceName(const CIMObjectPath& x)

// See also setArrayData with CIMObjects below.

void setArrayData(const Array<CIMObjectPath>& x)

{

_instanceNames.append(x);

setInstanceNames(x);

_encoding |= RESP_ENC_CIM;

}

// Instance handling

Line 93

Line 235

{

_instances.clear();

_instances.append(x);

_size++;

_encoding |= RESP_ENC_CIM;

}

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

{

_instances=x;

_encoding |= RESP_ENC_CIM;

_size += x.size();

}

void appendInstance(const CIMInstance& x)

{

PEGASUS_DEBUG_ASSERT(valid());

_instances.append(x);

_encoding |= RESP_ENC_CIM;

_size += 1;

}

void appendInstances(const Array<CIMInstance>& x)

{

PEGASUS_DEBUG_ASSERT(valid());

_instances.appendArray(x);

_encoding |= RESP_ENC_CIM;

_size += x.size();

}

// Objects handling

Array<CIMObject>& getObjects();

void setObjects(const Array<CIMObject>& x)

{

PEGASUS_DEBUG_ASSERT(valid());

_objects=x;

_encoding |= RESP_ENC_CIM;

_size += x.size();

}

// Sets array of CIMObjects into the CIMResponseData

//// TODO. We could make this name the common function for

//// setObjects.

// NOTE: This was added to provider overloaded

// function for setting arrays of both CIMObject and

// CIMObjectPaths from CIMOperationRequestDispatcher

void setArrayData(const Array<CIMObject>& x)

{

setObjects(x);

}

void appendObject(const CIMObject& x)

{

PEGASUS_DEBUG_ASSERT(valid());

_objects.append(x);

_encoding |= RESP_ENC_CIM;

_size += 1;

}

/*******************************************************************

** SCMO objects interface handling

*******************************************************************/

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

// object paths are represented as SCMOInstance

Array<SCMOInstance>& getSCMO();

Line 131

Line 318

void appendSCMO(const Array<SCMOInstance>& x)

{

PEGASUS_DEBUG_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 153

Line 347

// Function primarily used by CIMOperationRequestDispatcher to complete

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

// OperationAggregator

// OperationAggregator. Behavior is different for pull operations

void completeHostNameAndNamespace(

const String & hn,

const CIMNamespaceName & ns);

const CIMNamespaceName & ns,

Boolean isPullOperation = false);

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

void encodeInternalXmlResponse(CIMBuffer& out);

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

// only in the provided CIMBuffer

void encodeInternalXmlResponse(CIMBuffer& out,

Boolean isPullResponse = false);

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

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

// The pull responses requires a flag (isPull) and the special

// case of encoding OpenQueryInstances and PullInstances a second flag

// (encodeInstanceOnly which only encodes the instance itself)

void encodeXmlResponse(Buffer& out,

Boolean isPull,

Boolean encodeInstanceOnly = false);

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

Boolean valid() const;

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

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

}

CIMPropertyList & getPropertyList()

{

return _propertyList;

}

void traceResponseData(); // KS_TODO Diagnostic. remove

String toStringTraceResponseData(); // KS_TODO Diagnostic remove

void resolveBinaryToSCMO();

private:

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

Line 176

Line 417

void _resolveToCIM();

void _resolveToSCMO();

void _resolveBinary();

void _resolveBinaryToSCMO();

void _resolveXmlToSCMO();

void _resolveXmlToCIM();

Line 189

Line 430

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

void _appendInstanceElement(Buffer& out, SCMOInstance _scmoInstance);

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

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

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

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

Line 210

Line 467

// For binary encoding.

Array<Uint8> _binaryData;

CIMNamespaceName _defaultNamespace;

String _defaultHostname;

// Default C++ encoding

Array<CIMObjectPath> _instanceNames;

Line 219

Line 478

// 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.3.2.9
changed lines
	Added in v.1.6.2.19

No CVS admin address has been configured