version 1.1.2.1, 2004/03/10 14:19:29
|
version 1.8, 2005/03/11 01:51:56
|
|
|
//%2003//////////////////////////////////////////////////////////////////////// |
//%2005//////////////////////////////////////////////////////////////////////// |
// | // |
// Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Development |
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development |
// Company, L. P., IBM Corp., The Open Group, Tivoli Systems. |
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. |
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; | // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.; |
// IBM Corp.; EMC Corporation, The Open Group. | // IBM Corp.; EMC Corporation, The Open Group. |
|
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.; |
|
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. |
|
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
|
// EMC Corporation; VERITAS Software Corporation; The Open Group. |
// | // |
// Permission is hereby granted, free of charge, to any person obtaining a copy | // Permission is hereby granted, free of charge, to any person obtaining a copy |
// of this software and associated documentation files (the "Software"), to | // of this software and associated documentation files (the "Software"), to |
|
|
// | // |
// Author: Chip Vincent (cvincent@us.ibm.com) | // Author: Chip Vincent (cvincent@us.ibm.com) |
// | // |
// Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) |
// Modified By: |
|
// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) |
// Dave Rosckes (rosckes@us.ibm.com) | // Dave Rosckes (rosckes@us.ibm.com) |
|
// Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase2 |
// | // |
//%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
| |
|
|
| |
PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
| |
|
// |
|
// ValueResponseHandler (used internally to implement property operations) |
|
// |
|
class PEGASUS_PPM_LINKAGE ValueResponseHandler : virtual public ResponseHandler |
|
{ |
|
public: |
|
virtual void deliver(const CIMValue & value) = 0; |
|
|
|
virtual void deliver(const Array<CIMValue> & values) = 0; |
|
}; |
|
|
|
|
|
// |
|
// SimpleResponseHandler |
|
// |
class PEGASUS_PPM_LINKAGE SimpleResponseHandler : virtual public ResponseHandler | class PEGASUS_PPM_LINKAGE SimpleResponseHandler : virtual public ResponseHandler |
{ | { |
public: | public: |
|
|
| |
virtual void processing(void) | virtual void processing(void) |
{ | { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
Logger::put( |
"SimpleResponseHandler: processing()"); |
Logger::STANDARD_LOG, |
|
System::CIMSERVER, |
|
Logger::TRACE, |
|
"SimpleResponseHandler::processing()"); |
|
|
// do nothing | // do nothing |
} | } |
| |
virtual void complete(void) | virtual void complete(void) |
{ | { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
Logger::put( |
"SimpleResponseHandler: complete()"); |
Logger::STANDARD_LOG, |
|
System::CIMSERVER, |
|
Logger::TRACE, |
|
"SimpleResponseHandler::complete()"); |
| |
// do nothing |
send(true); |
} | } |
| |
// l10n |
// return the number of objects in this handler |
ContentLanguages getLanguages(void) |
virtual Uint32 size(void) const |
{ | { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
return(0); |
"SimpleResponseHandler: getLanguages()"); |
|
|
|
ContentLanguages langs; |
|
try |
|
{ |
|
// Try to get the ContentLanguages out of the OperationContext |
|
// in the base ResponseHandler. |
|
OperationContext context = getContext(); |
|
ContentLanguageListContainer cntr = context.get |
|
(ContentLanguageListContainer::NAME); |
|
langs = cntr.getLanguages(); |
|
} | } |
catch (Exception & e) |
|
|
// clear any objects in this handler |
|
virtual void clear(void) |
{ | { |
// The content language container must not exist. |
|
// Return the empty ContentLanguages. |
|
} | } |
| |
return langs; |
// l10n |
} |
ContentLanguages getLanguages(void); |
|
|
|
protected: |
|
|
|
// send (deliver) asynchronously with restrictions |
|
virtual void send(Boolean isComplete); |
|
|
}; | }; |
| |
class PEGASUS_PPM_LINKAGE SimpleInstanceResponseHandler : public SimpleResponseHandler, public InstanceResponseHandler | class PEGASUS_PPM_LINKAGE SimpleInstanceResponseHandler : public SimpleResponseHandler, public InstanceResponseHandler |
|
|
{ | { |
} | } |
| |
void processing(void) { SimpleResponseHandler::processing(); } |
virtual void processing(void) |
void complete(void) { SimpleResponseHandler::complete(); } |
{ |
|
SimpleResponseHandler::processing(); |
|
} |
|
|
|
virtual void complete(void) |
|
{ |
|
SimpleResponseHandler::complete(); |
|
} |
|
|
|
virtual Uint32 size(void) const |
|
{ |
|
return(_objects.size()); |
|
} |
|
|
|
virtual void clear(void) |
|
{ |
|
_objects.clear(); |
|
} |
| |
virtual void deliver(const CIMInstance & instance) | virtual void deliver(const CIMInstance & instance) |
{ | { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
Logger::put( |
"SimpleResponseHandler: deliver()"); |
Logger::STANDARD_LOG, |
|
System::CIMSERVER, |
|
Logger::TRACE, |
|
"SimpleInstanceResponseHandler::deliver()"); |
| |
_objects.append(instance); | _objects.append(instance); |
|
|
|
send(false); |
} | } |
| |
virtual void deliver(const Array<CIMInstance> & instances) | virtual void deliver(const Array<CIMInstance> & instances) |
|
|
| |
const Array<CIMInstance> getObjects(void) const | const Array<CIMInstance> getObjects(void) const |
{ | { |
return _objects; |
return(_objects); |
} | } |
| |
private: | private: |
|
|
{ | { |
} | } |
| |
void processing(void) { SimpleResponseHandler::processing(); } |
virtual void processing(void) |
void complete(void) { SimpleResponseHandler::complete(); } |
{ |
|
SimpleResponseHandler::processing(); |
|
} |
|
|
|
virtual void complete(void) |
|
{ |
|
SimpleResponseHandler::complete(); |
|
} |
|
|
|
virtual Uint32 size(void) const |
|
{ |
|
return(_objects.size()); |
|
} |
|
|
|
virtual void clear(void) |
|
{ |
|
_objects.clear(); |
|
} |
| |
virtual void deliver(const CIMObjectPath & objectPath) | virtual void deliver(const CIMObjectPath & objectPath) |
{ | { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
Logger::put( |
"SimpleResponseHandler: deliver()"); |
Logger::STANDARD_LOG, |
|
System::CIMSERVER, |
|
Logger::TRACE, |
|
"SimpleObjectPathResponseHandler::deliver()"); |
|
|
_objects.append(objectPath); | _objects.append(objectPath); |
|
|
|
send(false); |
} | } |
| |
virtual void deliver(const Array<CIMObjectPath> & objectPaths) | virtual void deliver(const Array<CIMObjectPath> & objectPaths) |
|
|
| |
const Array<CIMObjectPath> getObjects(void) const | const Array<CIMObjectPath> getObjects(void) const |
{ | { |
return _objects; |
return(_objects); |
} | } |
| |
private: | private: |
|
|
{ | { |
} | } |
| |
void processing(void) { SimpleResponseHandler::processing(); } |
virtual void processing(void) |
void complete(void) { SimpleResponseHandler::complete(); } |
{ |
|
SimpleResponseHandler::processing(); |
|
} |
|
|
|
virtual void complete(void) |
|
{ |
|
SimpleResponseHandler::complete(); |
|
} |
|
|
|
// NOTE: this is the total size (count) of ALL parameters! |
|
virtual Uint32 size(void) const |
|
{ |
|
return(_objects.size()); |
|
} |
|
|
|
virtual void clear(void) |
|
{ |
|
_objects.clear(); |
|
|
|
_returnValue.clear(); |
|
} |
| |
virtual void deliverParamValue(const CIMParamValue & outParamValue) | virtual void deliverParamValue(const CIMParamValue & outParamValue) |
{ | { |
_objects.append(outParamValue); | _objects.append(outParamValue); |
|
|
|
// async delivers not yet supported for parameters |
|
//send(false); |
} | } |
| |
virtual void deliverParamValue(const Array<CIMParamValue> & outParamValues) | virtual void deliverParamValue(const Array<CIMParamValue> & outParamValues) |
|
|
| |
virtual void deliver(const CIMValue & returnValue) | virtual void deliver(const CIMValue & returnValue) |
{ | { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
Logger::put( |
"SimpleResponseHandler: deliver()"); |
Logger::STANDARD_LOG, |
|
System::CIMSERVER, |
|
Logger::TRACE, |
|
"SimpleMethodResultResponseHandler::deliver()"); |
|
|
_returnValue = returnValue; | _returnValue = returnValue; |
|
|
|
send(false); |
} | } |
| |
const Array<CIMParamValue> getParamValues(void) const | const Array<CIMParamValue> getParamValues(void) const |
{ | { |
return _objects; |
return(_objects); |
} | } |
| |
const CIMValue getReturnValue(void) const | const CIMValue getReturnValue(void) const |
{ | { |
return _returnValue; |
return(_returnValue); |
} | } |
| |
private: | private: |
|
|
{ | { |
} | } |
| |
void processing(void) { SimpleResponseHandler::processing(); } |
virtual void processing(void) |
void complete(void) { SimpleResponseHandler::complete(); } |
{ |
|
SimpleResponseHandler::processing(); |
|
} |
|
|
|
virtual void complete(void) |
|
{ |
|
SimpleResponseHandler::complete(); |
|
} |
|
|
|
virtual Uint32 size(void) const |
|
{ |
|
return(_objects.size()); |
|
} |
|
|
|
virtual void clear(void) |
|
{ |
|
_objects.clear(); |
|
} |
| |
virtual void deliver(const CIMIndication & indication) | virtual void deliver(const CIMIndication & indication) |
{ | { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
Logger::put( |
"SimpleResponseHandler: deliver()"); |
Logger::STANDARD_LOG, |
|
System::CIMSERVER, |
|
Logger::TRACE, |
|
"SimpleIndicationResponseHandler::deliver()"); |
| |
_objects.append(indication); | _objects.append(indication); |
|
|
|
send(false); |
} | } |
| |
virtual void deliver(const Array<CIMIndication> & indications) | virtual void deliver(const Array<CIMIndication> & indications) |
|
|
const OperationContext & context, | const OperationContext & context, |
const CIMIndication & indication) | const CIMIndication & indication) |
{ | { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
Logger::put( |
"SimpleResponseHandler: deliver()"); |
Logger::STANDARD_LOG, |
|
System::CIMSERVER, |
|
Logger::TRACE, |
|
"SimpleIndicationResponseHandler::deliver()"); |
| |
_objects.append(indication); | _objects.append(indication); |
} | } |
|
|
| |
const Array<CIMIndication> getObjects(void) const | const Array<CIMIndication> getObjects(void) const |
{ | { |
return _objects; |
return(_objects); |
} | } |
| |
|
// ATTN: why is this variable public? |
|
|
CIMInstance _provider; | CIMInstance _provider; |
| |
private: | private: |
|
|
{ | { |
} | } |
| |
void processing(void) { SimpleResponseHandler::processing(); } |
virtual void processing(void) |
void complete(void) { SimpleResponseHandler::complete(); } |
{ |
|
SimpleResponseHandler::processing(); |
|
} |
|
|
|
virtual void complete(void) |
|
{ |
|
SimpleResponseHandler::complete(); |
|
} |
|
|
|
virtual Uint32 size(void) const |
|
{ |
|
return(_objects.size()); |
|
} |
|
|
|
virtual void clear(void) |
|
{ |
|
_objects.clear(); |
|
} |
| |
virtual void deliver(const CIMObject & object) | virtual void deliver(const CIMObject & object) |
{ | { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
Logger::put( |
"SimpleResponseHandler: deliver()"); |
Logger::STANDARD_LOG, |
|
System::CIMSERVER, |
|
Logger::TRACE, |
|
"SimpleObjectResponseHandler::deliver()"); |
| |
_objects.append(object); | _objects.append(object); |
|
|
|
send(false); |
} | } |
| |
virtual void deliver(const Array<CIMObject> & objects) | virtual void deliver(const Array<CIMObject> & objects) |
|
|
| |
const Array<CIMObject> getObjects(void) const | const Array<CIMObject> getObjects(void) const |
{ | { |
return _objects; |
return(_objects); |
} | } |
| |
private: | private: |
|
|
{ | { |
} | } |
| |
void processing(void) { SimpleResponseHandler::processing(); } |
virtual void processing(void) |
void complete(void) { SimpleResponseHandler::complete(); } |
{ |
|
SimpleResponseHandler::processing(); |
|
} |
|
|
|
virtual void complete(void) |
|
{ |
|
SimpleResponseHandler::complete(); |
|
} |
|
|
|
virtual Uint32 size(void) const |
|
{ |
|
return(_objects.size()); |
|
} |
|
|
|
virtual void clear(void) |
|
{ |
|
_objects.clear(); |
|
} |
| |
virtual void deliver(const CIMInstance & object) | virtual void deliver(const CIMInstance & object) |
{ | { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
Logger::put( |
"SimpleResponseHandler: deliver()"); |
Logger::STANDARD_LOG, |
|
System::CIMSERVER, |
|
Logger::TRACE, |
|
"SimpleInstance2ObjectResponseHandler::deliver()"); |
| |
_objects.append(CIMObject(object)); | _objects.append(CIMObject(object)); |
|
|
|
// async delivers not yet supported |
|
//send(false); |
} | } |
| |
virtual void deliver(const Array<CIMInstance> & objects) | virtual void deliver(const Array<CIMInstance> & objects) |
|
|
| |
const Array<CIMObject> getObjects(void) const | const Array<CIMObject> getObjects(void) const |
{ | { |
return _objects; |
return(_objects); |
} | } |
| |
private: | private: |
|
|
{ | { |
} | } |
| |
void processing(void) { SimpleResponseHandler::processing(); } |
virtual void processing(void) |
void complete(void) { SimpleResponseHandler::complete(); } |
|
|
|
virtual void deliver(const CIMValue & value) |
|
{ | { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
SimpleResponseHandler::processing(); |
"SimpleResponseHandler: deliver()"); |
|
|
|
_objects.append(value); |
|
} | } |
| |
virtual void deliver(const Array<CIMValue> & values) |
virtual void complete(void) |
{ |
|
// call deliver for each object in the array |
|
for(Uint32 i = 0, n = values.size(); i < n; i++) |
|
{ | { |
deliver(values[i]); |
SimpleResponseHandler::complete(); |
} |
|
} | } |
| |
const Array<CIMValue> getObjects(void) const |
virtual Uint32 size(void) const |
{ | { |
return _objects; |
return(_objects.size()); |
} | } |
| |
private: |
virtual void clear(void) |
Array<CIMValue> _objects; |
|
|
|
}; |
|
|
|
class PEGASUS_PPM_LINKAGE SimpleClassResponseHandler : public SimpleResponseHandler, public ClassResponseHandler |
|
{ |
|
public: |
|
SimpleClassResponseHandler(void) |
|
{ | { |
|
_objects.clear(); |
} | } |
| |
void processing(void) { SimpleResponseHandler::processing(); } |
virtual void deliver(const CIMValue & value) |
void complete(void) { SimpleResponseHandler::complete(); } |
|
|
|
virtual void deliver(const CIMClass & classObj) |
|
{ | { |
Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE, |
Logger::put( |
"SimpleResponseHandler: deliver()"); |
Logger::STANDARD_LOG, |
|
System::CIMSERVER, |
|
Logger::TRACE, |
|
"SimpleValueResponseHandler::deliver()"); |
| |
_objects.append(classObj); |
_objects.append(value); |
|
|
|
send(false); |
} | } |
| |
virtual void deliver(const Array<CIMClass> & classObjs) |
virtual void deliver(const Array<CIMValue> & values) |
{ | { |
// call deliver for each object in the array | // call deliver for each object in the array |
for(Uint32 i = 0, n = classObjs.size(); i < n; i++) |
for(Uint32 i = 0, n = values.size(); i < n; i++) |
{ | { |
deliver(classObjs[i]); |
deliver(values[i]); |
} | } |
} | } |
| |
const Array<CIMClass> getObjects(void) const |
const Array<CIMValue> getObjects(void) const |
{ | { |
return _objects; |
return(_objects); |
} | } |
| |
private: | private: |
Array<CIMClass> _objects; |
Array<CIMValue> _objects; |
| |
}; | }; |
| |
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |
| |
#endif | #endif |
|
|