(file) Return to BasicProviderManagerRouter.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / Attic

Diff for /pegasus/src/Pegasus/ProviderManager2/Attic/BasicProviderManagerRouter.cpp between version 1.28.2.3 and 1.32

version 1.28.2.3, 2006/10/18 19:16:12 version 1.32, 2006/06/19 20:47:39
Line 60 
Line 60 
 # define LIBRARY_NAME_CMPIPM    "QSYS/QYCMCMPIPM" # define LIBRARY_NAME_CMPIPM    "QSYS/QYCMCMPIPM"
 # define LIBRARY_NAME_JMPIPM    "QSYS/QYCMJMPIPM" # define LIBRARY_NAME_JMPIPM    "QSYS/QYCMJMPIPM"
 #else #else
 # define LIBRARY_NAME_DEFAULTPM "DefaultProviderManager"  
 # define LIBRARY_NAME_CMPIPM    "CMPIProviderManager" # define LIBRARY_NAME_CMPIPM    "CMPIProviderManager"
 # define LIBRARY_NAME_JMPIPM    "JMPIProviderManager" # define LIBRARY_NAME_JMPIPM    "JMPIProviderManager"
 #endif #endif
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 // BEGIN TEMP SECTION  
 class ProviderManagerContainer class ProviderManagerContainer
 { {
 public: public:
     ProviderManagerContainer()  
     : _manager(0)  
     {  
     }  
   
     ProviderManagerContainer(const ProviderManagerContainer & container)  
     : _manager(0)  
     {  
         *this = container;  
     }  
  
     ProviderManagerContainer(     ProviderManagerContainer(
         const String& physicalName,         const String& physicalName,
Line 104 
Line 92 
         _logicalName = logicalName;         _logicalName = logicalName;
         _interfaceName = interfaceName;         _interfaceName = interfaceName;
  
         _module = ProviderManagerModule(_physicalName);          _module.reset(new ProviderManagerModule(_physicalName));
         Boolean moduleLoaded = _module.load();          Boolean moduleLoaded = _module->load();
  
         if (moduleLoaded)         if (moduleLoaded)
         {         {
             _manager = _module.getProviderManager(_logicalName);              _manager = _module->getProviderManager(_logicalName);
         }         }
         else         else
         {         {
Line 144 
Line 132 
         _manager->setSubscriptionInitComplete (subscriptionInitComplete);         _manager->setSubscriptionInitComplete (subscriptionInitComplete);
     }     }
  
     ~ProviderManagerContainer()      ProviderManagerContainer(
           const String& interfaceName,
           PEGASUS_INDICATION_CALLBACK_T indicationCallback,
           PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback,
           Boolean subscriptionInitComplete,
           ProviderManager* manager)
           :
           _interfaceName(interfaceName),
           _manager(manager),
           _module(0)
     {     {
         delete _manager;          _manager->setIndicationCallback(indicationCallback);
         _module.unload();          _manager->setResponseChunkCallback(responseChunkCallback);
           _manager->setSubscriptionInitComplete(subscriptionInitComplete);
     }     }
  
     ProviderManagerContainer& operator=(      ~ProviderManagerContainer()
         const ProviderManagerContainer & container)  
     {  
         if (this == &container)  
         {         {
             return *this;          delete _manager;
         }  
   
         _logicalName = container._logicalName;  
         _physicalName = container._physicalName;  
         _interfaceName = container._interfaceName;  
   
         _module = container._module;  
         _manager = container._manager;  
  
         return *this;          if (_module.get())
               _module->unload();
     }     }
  
     ProviderManager* getProviderManager()     ProviderManager* getProviderManager()
Line 173 
Line 161 
         return _manager;         return _manager;
     }     }
  
     const String& getPhysicalName() const  
     {  
         return _physicalName;  
     }  
   
     const String& getLogicalName() const  
     {  
         return _logicalName;  
     }  
   
     const String& getInterfaceName() const     const String& getInterfaceName() const
     {     {
         return _interfaceName;         return _interfaceName;
     }     }
  
   
 private: private:
   
       ProviderManagerContainer();
       ProviderManagerContainer& operator=(const ProviderManagerContainer&);
       ProviderManagerContainer(const ProviderManagerContainer&);
   
     String _physicalName;     String _physicalName;
     String _logicalName;     String _logicalName;
     String _interfaceName;     String _interfaceName;
   
     ProviderManagerModule _module;  
     ProviderManager* _manager;     ProviderManager* _manager;
       AutoPtr<ProviderManagerModule> _module;
 }; };
 // END TEMP SECTION  
   
  
 PEGASUS_INDICATION_CALLBACK_T PEGASUS_INDICATION_CALLBACK_T
     BasicProviderManagerRouter::_indicationCallback = 0;     BasicProviderManagerRouter::_indicationCallback = 0;
Line 205 
Line 186 
 PEGASUS_RESPONSE_CHUNK_CALLBACK_T PEGASUS_RESPONSE_CHUNK_CALLBACK_T
     BasicProviderManagerRouter::_responseChunkCallback = 0;     BasicProviderManagerRouter::_responseChunkCallback = 0;
  
   ProviderManager*
       (*BasicProviderManagerRouter::_createDefaultProviderManagerCallback)() = 0;
   
 BasicProviderManagerRouter::BasicProviderManagerRouter( BasicProviderManagerRouter::BasicProviderManagerRouter(
     PEGASUS_INDICATION_CALLBACK_T indicationCallback,     PEGASUS_INDICATION_CALLBACK_T indicationCallback,
     PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback)      PEGASUS_RESPONSE_CHUNK_CALLBACK_T responseChunkCallback,
       ProviderManager* (*createDefaultProviderManagerCallback)())
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
         "BasicProviderManagerRouter::BasicProviderManagerRouter");         "BasicProviderManagerRouter::BasicProviderManagerRouter");
Line 215 
Line 200 
     _indicationCallback = indicationCallback;     _indicationCallback = indicationCallback;
     _responseChunkCallback = responseChunkCallback;     _responseChunkCallback = responseChunkCallback;
     _subscriptionInitComplete = false;     _subscriptionInitComplete = false;
       _createDefaultProviderManagerCallback =
           createDefaultProviderManagerCallback;
  
     PEG_METHOD_EXIT();     PEG_METHOD_EXIT();
 } }
Line 315 
Line 302 
         {         {
             ProviderManagerContainer* pmc=_providerManagerTable[i];             ProviderManagerContainer* pmc=_providerManagerTable[i];
             Message* resp = pmc->getProviderManager()->processMessage(request);             Message* resp = pmc->getProviderManager()->processMessage(request);
             if (resp)  
             {  
                 delete resp;                 delete resp;
             }             }
         }  
  
         response = request->buildResponse();         response = request->buildResponse();
     }     }
Line 342 
Line 326 
         try         try
         {         {
             // Look up the appropriate ProviderManager by InterfaceType             // Look up the appropriate ProviderManager by InterfaceType
             pm = _getProviderManager(interfaceType);              pm = _lookupProviderManager(interfaceType);
         }         }
         catch (const CIMException& e)         catch (const CIMException& e)
         {         {
Line 378 
Line 362 
 } }
  
 // ATTN: May need to add interfaceVersion parameter to further constrain lookup // ATTN: May need to add interfaceVersion parameter to further constrain lookup
 ProviderManager* BasicProviderManagerRouter::_getProviderManager(  ProviderManager* BasicProviderManagerRouter::_lookupProviderManager(
     const String& interfaceType)     const String& interfaceType)
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,
         "BasicProviderManagerRouter::_getProviderManager");          "BasicProviderManagerRouter::_lookupProviderManager");
  
     //     //
     // Search for this InterfaceType in the table of loaded ProviderManagers     // Search for this InterfaceType in the table of loaded ProviderManagers
Line 390 
Line 374 
     {     {
         ReadLock tableLock(_providerManagerTableLock);         ReadLock tableLock(_providerManagerTableLock);
  
         ProviderManager* pm = _lookupProviderManager(interfaceType);          // find provider manager for specified provider interface type
         if (pm)          for(Uint32 i = 0, n = _providerManagerTable.size(); i < n; i++)
           {
               if (interfaceType == _providerManagerTable[i]->getInterfaceName())
         {         {
                   ProviderManagerContainer* pmc=_providerManagerTable[i];
             PEG_METHOD_EXIT();             PEG_METHOD_EXIT();
             return pm;                  return pmc->getProviderManager();
               }
         }         }
     }     }
  
Line 404 
Line 392 
     {     {
         WriteLock tableLock(_providerManagerTableLock);         WriteLock tableLock(_providerManagerTableLock);
  
         ProviderManager* pm = _lookupProviderManager(interfaceType);  
         if (pm)  
         {  
             PEG_METHOD_EXIT();  
             return pm;  
         }  
   
         // ATTN: this section is a temporary solution to populate the list of         // ATTN: this section is a temporary solution to populate the list of
         // enabled provider managers for a given distribution.  It includes         // enabled provider managers for a given distribution.  It includes
         // another temporary solution for converting a generic file name into         // another temporary solution for converting a generic file name into
         // a file name useable by each platform.         // a file name useable by each platform.
  
           // The DefaultProviderManager is now statically linked rather than
           // dynamically loaded. This code is no longer used but remains for
           // reference purposes.
   
 #if defined(PEGASUS_ENABLE_DEFAULT_PROVIDER_MANAGER) #if defined(PEGASUS_ENABLE_DEFAULT_PROVIDER_MANAGER)
         if (interfaceType == "C++Default")          if (interfaceType == "C++Default" &&
               _createDefaultProviderManagerCallback)
         {         {
               ProviderManager* pm = (*_createDefaultProviderManagerCallback)();
             ProviderManagerContainer* pmc = new ProviderManagerContainer(             ProviderManagerContainer* pmc = new ProviderManagerContainer(
                 LIBRARY_NAME_DEFAULTPM,  
                 "DEFAULT",  
                 "C++Default",                 "C++Default",
                 _indicationCallback,                 _indicationCallback,
                 _responseChunkCallback,                 _responseChunkCallback,
                 _subscriptionInitComplete);                  _subscriptionInitComplete,
                   pm);
             _providerManagerTable.append(pmc);             _providerManagerTable.append(pmc);
             return pmc->getProviderManager();             return pmc->getProviderManager();
         }         }
Line 471 
Line 457 
     return 0;     return 0;
 } }
  
 // NOTE: The caller must lock _providerManagerTableLock before calling this  
 // method.  
 ProviderManager* BasicProviderManagerRouter::_lookupProviderManager(  
     const String& interfaceType)  
 {  
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,  
         "BasicProviderManagerRouter::_lookupProviderManager");  
   
     //  
     // Search for this InterfaceType in the table of loaded ProviderManagers  
     //  
     for (Uint32 i = 0, n = _providerManagerTable.size(); i < n; i++)  
     {  
         if (interfaceType == _providerManagerTable[i]->getInterfaceName())  
         {  
             ProviderManagerContainer* pmc = _providerManagerTable[i];  
             PEG_METHOD_EXIT();  
             return pmc->getProviderManager();  
         }  
     }  
   
     // Not found  
     PEG_METHOD_EXIT();  
     return 0;  
 }  
   
 Boolean BasicProviderManagerRouter::hasActiveProviders() Boolean BasicProviderManagerRouter::hasActiveProviders()
 { {
     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,     PEG_METHOD_ENTER(TRC_PROVIDERMANAGER,

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