Пример #1
0
void serviceRegistry_ungetServices(service_registry_pt registry, bundle_pt bundle) {
	array_list_pt fusages;
	array_list_pt usages;
	unsigned int i;

	celixThreadMutex_lock(&registry->mutex);
	usages = hashMap_get(registry->inUseMap, bundle);
	celixThreadMutex_unlock(&registry->mutex);

	if (usages == NULL || arrayList_isEmpty(usages)) {
		return;
	}

	// usage arrays?
	fusages = arrayList_clone(usages);
	
	for (i = 0; i < arrayList_size(fusages); i++) {
		usage_count_pt usage = arrayList_get(fusages, i);
		service_reference_pt reference = usage->reference;
		bool ungetResult = true;
		while (ungetResult) {
			serviceRegistry_ungetService(registry, bundle, reference, &ungetResult);
		}
	}

	arrayList_destroy(fusages);
}
Пример #2
0
service_pt serviceComponent_create(bundle_context_pt context, dependency_manager_pt manager) {
    service_pt service;
    apr_pool_t *pool;
	apr_pool_t *mypool;

	bundleContext_getMemoryPool(context, &pool);
	apr_pool_create(&mypool, pool);

	if (mypool) {
        service = (service_pt) apr_pcalloc(mypool, sizeof(*service));
        service->pool = mypool;
        service->impl = NULL;
        service->serviceName = NULL;
        service->serviceRegistration = NULL;
        service->dependencies = NULL;
        arrayList_create(&service->dependencies);

        service->init = service_init;
        service->start= service_start;
        service->stop = service_stop;
        service->destroy = service_destroy;

        service->context = context;
        service->manager = manager;
        service->state = state_create(arrayList_clone(service->dependencies), false);
        service->executor = executor_create(mypool);

		apr_thread_mutex_create(&service->mutex, APR_THREAD_MUTEX_UNNESTED, mypool);
	}

	return service;
}
Пример #3
0
celix_status_t serviceRegistry_ungetServiceReferences(service_registry_pt registry, bundle_pt owner) {
    celix_status_t status = CELIX_SUCCESS;

    celixThreadMutex_lock(&registry->referencesMapMutex);
    array_list_pt references = hashMap_get(registry->serviceReferences, owner);
    celixThreadMutex_unlock(&registry->referencesMapMutex);

    if (references != NULL) {
        array_list_pt referencesClone = arrayList_clone(references);
        int refIdx = 0;
        for (refIdx = 0; refIdx < arrayList_size(referencesClone); refIdx++) {
            service_reference_pt reference = arrayList_get(referencesClone, refIdx);
            serviceRegistry_ungetServiceReference(registry, owner, reference);
        }
        arrayList_destroy(referencesClone);
    }

    return status;
}
Пример #4
0
celix_status_t deploymentPackage_getBundleInfos(deployment_package_pt package, array_list_pt *infos) {
	*infos = arrayList_clone(package->bundleInfos);
	return CELIX_SUCCESS;
}