(file) Return to ResponseHandler.h CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/ResponseHandler.h between version 1.1.2.1 and 1.9.4.1

version 1.1.2.1, 2001/10/08 17:36:09 version 1.9.4.1, 2003/02/06 20:47:03
Line 1 
Line 1 
 //%/////-*-c++-*-//////////////////////////////////////////////////////////////  //%/////////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,
   // The Open Group, Tivoli Systems
 // //
 // 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
Line 22 
Line 23 
 // //
 // Author: Chip Vincent (cvincent@us.ibm.com) // Author: Chip Vincent (cvincent@us.ibm.com)
 // //
 // Modified By:  // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 30 
Line 31 
 #define Pegasus_ResponseHandler_h #define Pegasus_ResponseHandler_h
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <Pegasus/Common/CIMClass.h>  #include <Pegasus/Common/Array.h>
   #include <Pegasus/Common/Linkage.h>
   
 #include <Pegasus/Common/CIMInstance.h> #include <Pegasus/Common/CIMInstance.h>
   #include <Pegasus/Common/CIMObjectPath.h>
   #include <Pegasus/Common/CIMParamValue.h>
 #include <Pegasus/Common/CIMValue.h> #include <Pegasus/Common/CIMValue.h>
 #include <Pegasus/Common/CIMIndication.h> #include <Pegasus/Common/CIMIndication.h>
 //#include <Pegasus/Common/CIMPredicate.h>  #include <Pegasus/Common/CIMObject.h>
   #include <Pegasus/Common/CIMClass.h>
   #include <Pegasus/Common/OperationContext.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 template<class object_type>  /**
 class ResponseHandler  Callback to deliver results to the CIMOM.
   
   <p>The <tt>ResponseHandler</tt> class allows a provider
   to report operation progress and results to the CIMOM.
   Subclasses are defined for each of the types of object
   that a provider can deliver to the CIMOM.
   A <tt>ResponseHandler</tt> object of the appropriate type
   is passed to provider
   functions that are invoked to process client requests (it
   is not passed to the <tt>{@link initialize initialize}</tt>
   or <tt>{@link terminate terminate}</tt> functions). It
   contains the following public member functions that
   may be used to deliver results to the CIMOM:</p>
   <ul>
   <li><tt>{@link processing processing}</tt> - inform the CIMOM
   that delivery of results is beginning</li>
   <li><tt>{@link deliver deliver}</tt> - deliver an incremental
   result to the CIMOM; the CIMOM accumulates results as
   they are received from the provider</li>
   <li><tt>{@link complete complete}</tt> - inform the CIMOM that
   process of the request is complete and that no further
   results will be delivered</li>
   </ul>
   */
   
   class PEGASUS_COMMON_LINKAGE ResponseHandler
 { {
 public: public:
 //    enum ProcessingClass { POLL, SIGNAL };  
 //    enum FilteringClass { INDISCRETE, DISCRETIONARY };  
  
       ResponseHandler(void) {};      /**
       virtual ~ResponseHandler(void) {};      Destructor.
       */
       virtual void deliver(const object_type & object) = 0;      virtual ~ResponseHandler(void);
       virtual void deliver(const Array<object_type> & objects) = 0;  
       virtual void reserve(const Uint32 size) = 0;      /**
 //    virtual CIMPredicate *processing(      Deliver a possibly partial result to CIMOM.
 //       ProcessingClass pc = POLL,      <p>The <tt>deliver</tt> function is used by providers to
 //       FilteringClass fc = INDISCRETE ) = 0;      deliver results to the CIMOM. For operations that require a
       single element result (<tt>getInstance</tt>, for example),
       <tt>deliver</tt> should be called only once to deliver the
       entire result. For operations that involve
       enumeration, the single-element form shown here may be
       used, each iteration delivering an incremental element
       of the total result. The Array form below may be used
       to deliver a larger set of result elements.</p>
       */
       //virtual void deliver(const T & object);
   
       /**
       Deliver a set of results to CIMOM.
       <p>This form of the <tt>deliver</tt> function may be used
       to return a set of elements to the CIMOM. The set is not
       required to be complete, and the provider may invoke this
       function multiple times, if necessary. This form should only
       be used when the operation requires a result consisting
       of more than one element, such as an enumeration.</p>
       */
       //virtual void deliver(const Array<T> & objects);
   
       /**
       Inform the CIMOM that delivery of results will begin.
       <p>The provider must call <tt>processing</tt> before
       attempting to call <tt>deliver</tt>.
       */
       virtual void processing(void) = 0;       virtual void processing(void) = 0;
   
       /**
       Inform the CIMOM that delivery of results is complete.
       <p>The provider must call <tt>complete</tt> when all
       results have been delivered. It must not call <tt>deliver</tt>
       after calling <tt>complete</tt>.</p>
       */
       virtual void complete(void) = 0;       virtual void complete(void) = 0;
   };
   
  
   //
   // InstanceResponseHandler
   //
   class PEGASUS_COMMON_LINKAGE InstanceResponseHandler : virtual public ResponseHandler
   {
   public:
       virtual void deliver(const CIMInstance & instance) = 0;
   
       virtual void deliver(const Array<CIMInstance> & instances) = 0;
 }; };
  
   
   //
   // ObjectPathResponseHandler
   //
   class PEGASUS_COMMON_LINKAGE ObjectPathResponseHandler : virtual public ResponseHandler
   {
   public:
       virtual void deliver(const CIMObjectPath & objectPath) = 0;
   
       virtual void deliver(const Array<CIMObjectPath> & objectPaths) = 0;
   };
   
   
   //
   // MethodResultResponseHandler
   //
   class PEGASUS_COMMON_LINKAGE MethodResultResponseHandler : virtual public ResponseHandler
   {
   public:
       virtual void deliverParamValue(const CIMParamValue & outParamValue) = 0;
   
       virtual void deliverParamValue(const Array<CIMParamValue> & outParamValues) = 0;
   
       virtual void deliver(const CIMValue & returnValue) = 0;
   };
   
   
   //
   // IndicationResponseHandler
   //
   // NOTE: This class definition should not be considered complete until
   // indication support has been completed in Pegasus.  Implementation of
   // indication support may reveal a need for API changes in this class.
   class PEGASUS_COMMON_LINKAGE IndicationResponseHandler : virtual public ResponseHandler
   {
   public:
       virtual void deliver(const CIMIndication & indication) = 0;
   
       virtual void deliver(const Array<CIMIndication> & indications) = 0;
   
       virtual void deliver(
           const OperationContext & context,
           const CIMIndication & indication) = 0;
   
       virtual void deliver(
           const OperationContext & context,
           const Array<CIMIndication> & indications) = 0;
   };
   
   
   //
   // ObjectResponseHandler
   //
   // NOTE: This class definition should not be considered complete until
   // association provider and/or query provider support has been completed
   // in Pegasus, as those are the only APIs that use this response handler
   // type.  Implementation of support for those provider types may reveal
   // a need for API changes in this class.
   class PEGASUS_COMMON_LINKAGE ObjectResponseHandler : virtual public ResponseHandler
   {
   public:
       virtual void deliver(const CIMObject & object) = 0;
   
       virtual void deliver(const Array<CIMObject> & objects) = 0;
   };
   
   
   
   // This type is used in CIMPropertyProvider which Pegasus does not support
   //
   // ValueResponseHandler
   //
   class PEGASUS_COMMON_LINKAGE ValueResponseHandler : virtual public ResponseHandler
   {
   public:
       virtual void deliver(const CIMValue & value) = 0;
   
       virtual void deliver(const Array<CIMValue> & values) = 0;
   };
   
   
   
   
   // This type is used in CIMClassProvider which Pegasus does not support
   //
   // ClassResponseHandler
   //
   class PEGASUS_COMMON_LINKAGE ClassResponseHandler : virtual public ResponseHandler
   {
   public:
       virtual void deliver(const CIMClass & classObj) = 0;
   
       virtual void deliver(const Array<CIMClass> & classObjs) = 0;
   };
   
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
  
 #endif #endif

Legend:
Removed from v.1.1.2.1  
changed lines
  Added in v.1.9.4.1
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2