(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.31 and 1.32

version 1.31, 2006/04/18 19:08:44 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 410 
Line 397 
         // 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();
         }         }

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