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 }