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

Diff for /pegasus/src/Pegasus/ProviderManager2/SimpleResponseHandler.h between version 1.2 and 1.8

version 1.2, 2004/07/28 01:24:50 version 1.8, 2005/03/11 01:51:56
Line 1 
Line 1 
 //%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
Line 25 
Line 29 
 // //
 // 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
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 41 
Line 47 
  
 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:
Line 54 
Line 75 
  
     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 (const Exception &)  
       // 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
Line 100 
Line 123 
     {     {
     }     }
  
     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)
Line 122 
Line 167 
  
     const Array<CIMInstance> getObjects(void) const     const Array<CIMInstance> getObjects(void) const
     {     {
         return _objects;          return(_objects);
     }     }
  
 private: private:
Line 137 
Line 182 
     {     {
     }     }
  
     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)
Line 158 
Line 226 
  
     const Array<CIMObjectPath> getObjects(void) const     const Array<CIMObjectPath> getObjects(void) const
     {     {
         return _objects;          return(_objects);
     }     }
  
 private: private:
Line 173 
Line 241 
     {     {
     }     }
  
     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)
Line 192 
Line 283 
  
     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:
Line 221 
Line 318 
     {     {
     }     }
  
     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)
Line 245 
Line 364 
         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);
     }     }
Line 264 
Line 386 
  
     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:
Line 281 
Line 405 
     {     {
     }     }
  
     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)
Line 303 
Line 449 
  
     const Array<CIMObject> getObjects(void) const     const Array<CIMObject> getObjects(void) const
     {     {
         return _objects;          return(_objects);
     }     }
  
 private: private:
Line 318 
Line 464 
     {     {
     }     }
  
     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)
Line 340 
Line 509 
  
     const Array<CIMObject> getObjects(void) const     const Array<CIMObject> getObjects(void) const
     {     {
         return _objects;          return(_objects);
     }     }
  
 private: private:
Line 355 
Line 524 
     {     {
     }     }
  
     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
   

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