Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members  

servicemanager.cpp

Go to the documentation of this file.
00001 
00002 #include <kore/version.h>
00003 #include <kore/servicemanager.h>
00004 
00005 #define SM_MAJOR 0
00006 #define SM_MINOR 0
00007 #define SM_REVISION 1
00008 #define SM_VERSION "0.0.1"
00009 #define SM_API_MAJOR 0
00010 #define SM_API_MINOR 0
00011 #define SM_API_REVISION 1
00012 #define SM_API_VERSION "0.0.1"
00013 #define SM_NAME "Service Manager"
00014 #define SM_TYPE "Service Manager"
00015 #define SM_DESCRIPTION "Default Kore Service Manager"
00016 #define SM_SERVICE "Kore/Kernel/Service Manager"
00017 #define SM_SERVICE_DESCRIPTION "Kore Service Manager"
00018 
00019 using namespace kore;
00020 
00021 ServiceManager::ServiceManager()
00022 {
00023     _smVersion = new Version(SM_MAJOR,SM_MINOR,SM_REVISION,SM_VERSION);
00024     _smAPIVersion = new Version(SM_API_MAJOR,SM_API_MINOR,SM_API_REVISION,SM_API_VERSION);
00025     _smInfo = new Info(this, SM_NAME, SM_TYPE, SM_DESCRIPTION, _smVersion, _smAPIVersion);
00026     setInfo(_smInfo);
00027     _smService = new Service(this, SM_SERVICE, SM_SERVICE_DESCRIPTION);
00028     addService(_smService);
00029 }
00030 ServiceManager::~ServiceManager()
00031 {
00032     unregisterServices();
00033     unregisterProviders();
00034     delete _smInfo;
00035     delete _smVersion;
00036     delete _smAPIVersion;
00037     delete _smService;
00038 }
00039 
00040 void ServiceManager::registerService(const ServiceProvider::Service* srv)
00041 {
00042     if( !srv->provider() )
00043         return;
00044     srv->provider()->registeringService(this, srv);
00045     _services.insert(srv_hash_type::value_type(srv->name(),srv));
00046     srv->provider()->serviceRegistered(this, srv);
00047 }
00048 
00049 void ServiceManager::unregisterService(const ServiceProvider::Service* srv)
00050 {
00051     pair<srv_hash_type::iterator, srv_hash_type::iterator> p = _services.equal_range(srv->name());
00052     vector<srv_hash_type::iterator> rm;
00053     for( srv_hash_type::iterator i = p.first; i != p.second; ++i )
00054         if( i->second == srv )
00055             rm.push_back(i);
00056     int n = rm.size();
00057     for(int j = 0; j<n; j++)
00058     {
00059         srv->provider()->unregisteringService(this, srv);
00060         _services.erase(rm[j]);
00061         srv->provider()->serviceUnregistered(this, srv);
00062     }
00063 }
00064 
00065 void ServiceManager::registerProvider(ServiceProvider *provider)
00066 {
00067     provider->registeringProvider(this);
00068     const Service** srvs = provider->services();
00069     for(int i=0; srvs[i]; i++)
00070         registerService(srvs[i]);
00071     delete[] srvs;
00072     provider->providerRegistered(this);
00073 }
00074 
00075 void ServiceManager::unregisterProvider(ServiceProvider *provider)
00076 {
00077     provider->unregisteringProvider(this);
00078     const Service** srvs = provider->services();
00079     for(int i=0; srvs[i]; i++)
00080         unregisterService(srvs[i]);
00081     delete[] srvs;
00082     provider->providerUnregistered(this);
00083 }
00084 
00085 const ServiceProvider::Service** ServiceManager::registeredServices() const
00086 {
00087     int n = _services.size();
00088     const Service** srvs = new const Service*[n+1];
00089     srv_hash_type::const_iterator b,e;
00090     b = _services.begin();
00091     e = _services.end();
00092     int i = 0;
00093     for( srv_hash_type::const_iterator j = b; j != e; ++j, ++i )
00094         srvs[i] = j->second;
00095     srvs[i] = 0;
00096     return srvs;
00097 }
00098 
00099 const ServiceProvider::Service** ServiceManager::registeredServices(ServiceProvider* prov) const
00100 {
00101     vector<const Service*> srvs;
00102     srv_hash_type::const_iterator b,e;
00103     b = _services.begin();
00104     e = _services.end();
00105     for( srv_hash_type::const_iterator j = b; j != e; ++j )
00106         if( j->second->provider() == prov )
00107             srvs.push_back( j->second );
00108     int n = srvs.size();
00109     const Service** res = new const Service*[n+1];
00110     int i;
00111     for( i= 0; i < n; i++ )
00112         res[i] = srvs[i];
00113     res[i] = 0;
00114     return res;
00115 }
00116 
00117 const ServiceProvider::Service** ServiceManager::registeredServices(const Service* service) const
00118 {
00119     return registeredServices(service->name());
00120 }
00121 
00122 const ServiceProvider::Service** ServiceManager::registeredServices(const char* service) const
00123 {
00124     int n = _services.count(service);
00125     const Service** srvs = new const Service*[n+1];
00126     pair<srv_hash_type::const_iterator, srv_hash_type::const_iterator> p = _services.equal_range(service);
00127     int i = 0;
00128     for( srv_hash_type::const_iterator j = p.first; j != p.second; ++j, ++i )
00129         srvs[i] = j->second;
00130     srvs[i] = 0;
00131     return srvs;
00132 }
00133 
00134 const ServiceProvider::Service* ServiceManager::registeredService(const Service* service) const
00135 {
00136     return registeredService(service->name());
00137 }
00138 
00139 const ServiceProvider::Service* ServiceManager::registeredService(const char* service) const
00140 {
00141     pair<srv_hash_type::const_iterator, srv_hash_type::const_iterator> p = _services.equal_range(service);
00142     for( srv_hash_type::const_iterator j = p.first; j != p.second; ++j)
00143         return j->second;
00144     return 0;
00145 }
00146 
00147 ServiceProvider* ServiceManager::registeredProvider(const Service* service) const
00148 {
00149     return registeredProvider(service->name());
00150 }
00151 
00152 ServiceProvider* ServiceManager::registeredProvider(const char* service) const
00153 {
00154     const Service* srv = registeredService(service);
00155     if( srv )
00156         return srv->provider();
00157     else
00158         return 0;
00159 }
00160 
00161 ServiceProvider** ServiceManager::registeredProviders(const Service* service) const
00162 {
00163     return registeredProviders(service->name());
00164 }
00165 
00166 ServiceProvider** ServiceManager::registeredProviders(const char* service) const
00167 {
00168     sp_set_type sps;
00169     const Service** srvs = registeredServices(service);
00170     int i = 0;
00171     for(i = 0; srvs[i]; i++)
00172         sps.insert(srvs[i]->provider());
00173     delete[] srvs;
00174     int n = sps.size();
00175     ServiceProvider** res = new ServiceProvider*[n+1];
00176     i = 0;
00177     sp_set_type::const_iterator b,e;
00178     b = sps.begin();
00179     e = sps.end();
00180     for( sp_set_type::const_iterator j = b; j != e; ++j, ++i )
00181         res[i] = *j;
00182     res[i] = 0;
00183     return res;
00184 }
00185 
00186 ServiceProvider** ServiceManager::registeredProviders() const
00187 {
00188     sp_set_type sps;
00189     const Service** srvs = registeredServices();
00190     int i = 0;
00191     for(i = 0; srvs[i]; i++)
00192         sps.insert(srvs[i]->provider());
00193     delete[] srvs;
00194     int n = sps.size();
00195     ServiceProvider** res = new ServiceProvider*[n+1];
00196     i = 0;
00197     sp_set_type::const_iterator b,e;
00198     b = sps.begin();
00199     e = sps.end();
00200     for( sp_set_type::const_iterator j = b; j != e; ++j, ++i )
00201         res[i] = *j;
00202     res[i] = 0;
00203     return res;
00204 }
00205 
00206 void ServiceManager::registerServices(const Service** srvs)
00207 {
00208     for( int i = 0; srvs[i]; i++ )
00209         registerService(srvs[i]);
00210 }
00211 void ServiceManager::unregisterServices()
00212 {
00213     const Service** srvs = registeredServices();
00214     for(int i = 0; srvs[i]; i++)
00215         unregisterService(srvs[i]);
00216     delete[] srvs;
00217 }
00218 
00219 void ServiceManager::registerProviders(ServiceProvider** providers)
00220 {
00221     for( int i = 0; providers[i]; i++ )
00222         registerProvider(providers[i]);
00223 }
00224 void ServiceManager::unregisterProviders()
00225 {
00226     ServiceProvider** srvs = registeredProviders();
00227     for(int i = 0; srvs[i]; i++)
00228         unregisterProvider(srvs[i]);
00229     delete[] srvs;
00230 }

Generated on Sat Feb 16 04:46:03 2002 for Korelib by doxygen1.2.12 written by Dimitri van Heesch, © 1997-2001