Method Unregister

Modules/CppMicroServices/src/usServiceRegistrationBase.cpp:144–241

}

void ServiceRegistrationBase::Unregister()
{
  if (!d) throw std::logic_error("ServiceRegistrationBase object invalid");

  if (d->unregistering) return; // Silently ignore redundant unregistration.
  {
    MutexLock lock(d->eventLock);
    if (d->unregistering) return;
    d->unregistering = true;

    if (d->available)
    {
      if (d->module)
      {
        d->module->coreCtx->services.RemoveServiceRegistration(*this);
      }
    }
    else
    {
      throw std::logic_error("Service is unregistered");
    }
  }

  if (d->module)
  {
    ServiceListeners::ServiceListenerEntries listeners;
    ServiceEvent unregisteringEvent(ServiceEvent::UNREGISTERING, d->reference);
    d->module->coreCtx->listeners.GetMatchingServiceListeners(unregisteringEvent, listeners);
    d->module->coreCtx->listeners.ServiceChanged(
          listeners,
          unregisteringEvent);
  }

  // Copy service data under lock, then call UngetService outside the lock
  // to avoid potential deadlock if the factory callback accesses properties.
  ServiceFactory* serviceFactory = nullptr;
  ServiceRegistrationBasePrivate::ModuleToServicesMap prototypesCopy;
  ServiceRegistrationBasePrivate::ModuleToServiceMap moduleSvcCopy;

  {
    MutexLock lock(d->eventLock);
    {
      MutexLock lock2(d->propsLock);
      d->available = false;
      InterfaceMap::const_iterator factoryIter = d->service.find("org.cppmicroservices.factory");
      if (d->module && factoryIter != d->service.end())
      {
        serviceFactory = reinterpret_cast<ServiceFactory*>(factoryIter->second);
        prototypesCopy = d->prototypeServiceInstances;
        moduleSvcCopy = d->moduleServiceInstance;
      }
      d->module = nullptr;
      d->dependents.clear();
      d->service.clear();
      d->prototypeServiceInstances.clear();
      d->moduleServiceInstance.clear();
      // increment the reference count, since "d->reference" was used originally
      // to keep d alive.