celix_status_t wiringAdmin_importWiringEndpoint(wiring_admin_pt admin, wiring_endpoint_description_pt wEndpointDescription) { celix_status_t status = CELIX_SUCCESS; wiring_send_service_pt wiringSendService = calloc(1, sizeof(*wiringSendService)); if (!wiringSendService) { status = CELIX_ENOMEM; } else { service_registration_pt wiringSendServiceReg = NULL; char* wireId = properties_get(wEndpointDescription->properties, WIRING_ENDPOINT_DESCRIPTION_WIRE_ID_KEY); properties_pt props = properties_create(); properties_set(props, (char*) INAETICS_WIRING_WIRE_ID, wireId); wiringSendService->wiringEndpointDescription = wEndpointDescription; wiringSendService->send = wiringAdmin_send; wiringSendService->admin = admin; wiringSendService->errorCount = 0; status = bundleContext_registerService(admin->context, (char *) INAETICS_WIRING_SEND_SERVICE, wiringSendService, props, &wiringSendServiceReg); if (status == CELIX_SUCCESS) { hashMap_put(admin->wiringSendServices, wEndpointDescription, wiringSendService); hashMap_put(admin->wiringSendRegistrations, wEndpointDescription, wiringSendServiceReg); printf("%s: SEND SERVICE sucessfully registered w/ wireId %s\n", TAG, wireId); } else { printf("%s: could not register SEND SERVICE w/ wireId %s\n", TAG, wireId); } } return status; }
void test_hashMap_remove(void) { char * key = "key"; char * value = "value"; char * key2 = NULL; char * value2 = "value2"; char * removeKey; hashMap_clear(map, false, false); // Add one entry hashMap_put(map, key, value); // Add second entry with null key hashMap_put(map, key2, value2); // Remove unexisting entry for map removeKey = "unexisting"; hashMap_remove(map, removeKey); CU_ASSERT_EQUAL(map->size, 2); CU_ASSERT_FALSE(hashMap_isEmpty(map)); hashMap_remove(map, key); CU_ASSERT_EQUAL(map->size, 1); hashMap_remove(map, key2); CU_ASSERT_EQUAL(map->size, 0); CU_ASSERT_TRUE(hashMap_isEmpty(map)); // Remove unexisting entry for empty map removeKey = "unexisting"; hashMap_remove(map, removeKey); CU_ASSERT_EQUAL(map->size, 0); CU_ASSERT_TRUE(hashMap_isEmpty(map)); }
void test_hashMap_resize(void) { int i; char * k; char key[6]; hashMap_clear(map, false, false); CU_ASSERT_EQUAL(map->size, 0); CU_ASSERT_EQUAL(map->tablelength, 16); CU_ASSERT_EQUAL(map->treshold, 12); for (i = 0; i < 12; i++) { char key[6]; sprintf(key, "key%d", i); k = strdup(key); hashMap_put(map, k, k); } CU_ASSERT_EQUAL(map->size, 12); CU_ASSERT_EQUAL(map->tablelength, 16); CU_ASSERT_EQUAL(map->treshold, 12); sprintf(key, "key%d", i); hashMap_put(map, strdup(key), strdup(key)); CU_ASSERT_EQUAL(map->size, 13); CU_ASSERT_EQUAL(map->tablelength, 32); CU_ASSERT_EQUAL(map->treshold, 24); }
void test_hashMap_clear(void) { char * key = "key"; char * value = "value"; char * key2 = "key2"; char * value2 = "value2"; char * key3 = NULL; char * value3 = "value3"; char * key4 = "key4"; char * value4 = NULL; hashMap_clear(map, false, false); // Add one entry hashMap_put(map, key, value); // Add second entry hashMap_put(map, key2, value2); // Add third entry with NULL key hashMap_put(map, key3, value3); // Add fourth entry with NULL value hashMap_put(map, key4, value4); hashMap_clear(map, false, false); CU_ASSERT_EQUAL(map->size, 0); }
void test_hashMap_containsValue(void) { char * key = "key"; char * value = "value"; char * key2 = "key2"; char * value2 = "value2"; char * neValue = "notExisting"; char * key3 = "key3"; char * value3 = NULL; hashMap_clear(map, false, false); // Add one entry hashMap_put(map, key, value); // Add second entry hashMap_put(map, key2, value2); CU_ASSERT_TRUE(hashMap_containsValue(map, value)); CU_ASSERT_TRUE(hashMap_containsValue(map, value2)); CU_ASSERT_FALSE(hashMap_containsValue(map, neValue)); CU_ASSERT_FALSE(hashMap_containsValue(map, NULL)); // Add third entry with NULL value hashMap_put(map, key3, value3); CU_ASSERT_TRUE(hashMap_containsValue(map, value3)); }
void test_hashMap_size(void) { char * key = "key"; char * value = "value"; char * key2 = "key2"; char * value2 = "value2"; char * key3 = strdup("key2"); char * value3 = "value3"; CU_ASSERT_EQUAL(map->size, 0); // Add one entry hashMap_put(map, key, value); CU_ASSERT_EQUAL(map->size, 1); // Add second entry hashMap_put(map, key2, value2); CU_ASSERT_EQUAL(map->size, 2); // Add entry using the same key, this does not overwrite an existing entry hashMap_put(map, key3, value3); CU_ASSERT_EQUAL(map->size, 3); // Clear map hashMap_clear(map, false, false); CU_ASSERT_EQUAL(map->size, 0); }
void test_hashMap_put(void) { char * key = "key"; char * value = "value"; char * key2 = "key2"; char * value2 = "value2"; char * nkey2 = strdup("key2"); char * nvalue2 = "value3"; char * key3 = NULL; char * value3 = "value3"; char * key4 = "key4"; char * value4 = NULL; char * old; char * get; hashMap_clear(map, false, false); // Add one entry hashMap_put(map, key, value); // Add second entry hashMap_put(map, key2, value2); get = hashMap_get(map, key); CU_ASSERT_STRING_EQUAL(get, value); get = hashMap_get(map, key2); CU_ASSERT_STRING_EQUAL(get, value2); // Try to add an entry with the same key, since no explicit hash function is used, // this will not overwrite an existing entry. old = (char *) hashMap_put(map, nkey2, nvalue2); CU_ASSERT_PTR_NULL_FATAL(old); // Retrieving the values will return the correct values get = hashMap_get(map, key2); CU_ASSERT_STRING_EQUAL(get, value2); get = hashMap_get(map, nkey2); CU_ASSERT_STRING_EQUAL(get, nvalue2); // Add third entry with NULL key hashMap_put(map, key3, value3); get = hashMap_get(map, key3); CU_ASSERT_STRING_EQUAL(get, value3); // Add fourth entry with NULL value hashMap_put(map, key4, value4); get = hashMap_get(map, key4); CU_ASSERT_EQUAL(get, value4); }
static celix_status_t topicsub_subscriberTracked(void * handle, service_reference_pt reference, void * service){ celix_status_t status = CELIX_SUCCESS; topic_subscription_pt ts = handle; celixThreadMutex_lock(&ts->ts_lock); if (!hashMap_containsKey(ts->servicesMap, service)) { bundle_pt bundle = NULL; hash_map_pt msgTypes = NULL; serviceReference_getBundle(reference, &bundle); if(ts->serializer != NULL && bundle!=NULL){ ts->serializer->createSerializerMap(ts->serializer->handle,bundle,&msgTypes); if(msgTypes != NULL){ hashMap_put(ts->servicesMap, service, msgTypes); printf("PSA_UDP_MC_TS: New subscriber registered.\n"); } } else{ printf("PSA_UDP_MC_TS: Cannot register new subscriber.\n"); status = CELIX_SERVICE_EXCEPTION; } } celixThreadMutex_unlock(&ts->ts_lock); return status; }
celix_status_t serviceRegistry_ungetServiceReference(service_registry_pt registry, bundle_pt owner, service_reference_pt reference) { celix_status_t status = CELIX_SUCCESS; bool valid = false; serviceRefernce_isValid(reference, &valid); if (valid) { bool ungetResult = true; while (ungetResult) { serviceRegistry_ungetService(registry, owner, reference, &ungetResult); } } celixThreadMutex_lock(®istry->referencesMapMutex); array_list_pt references = hashMap_get(registry->serviceReferences, owner); if (references != NULL) { arrayList_removeElement(references, reference); serviceReference_destroy(&reference); if (arrayList_size(references) > 0) { hashMap_put(registry->serviceReferences, owner, references); } else { array_list_pt removed = hashMap_remove(registry->serviceReferences, owner); arrayList_destroy(removed); } } celixThreadMutex_unlock(®istry->referencesMapMutex); return status; }
/* Service's functions implementation */ celix_status_t pubsub_discovery_announcePublisher(void *handle, pubsub_endpoint_pt pubEP) { celix_status_t status = CELIX_SUCCESS; printf("pubsub_discovery_announcePublisher : %s / %s\n", pubEP->topic, pubEP->endpoint); pubsub_discovery_pt pubsub_discovery = (pubsub_discovery_pt) handle; celixThreadMutex_lock(&pubsub_discovery->discoveredPubsMutex); char *pub_key = createScopeTopicKey(pubEP->scope,pubEP->topic); array_list_pt pubEP_list = (array_list_pt)hashMap_get(pubsub_discovery->discoveredPubs,pub_key); if(pubEP_list==NULL){ arrayList_create(&pubEP_list); hashMap_put(pubsub_discovery->discoveredPubs,strdup(pub_key),pubEP_list); } free(pub_key); pubsub_endpoint_pt p = NULL; pubsubEndpoint_clone(pubEP, &p); arrayList_add(pubEP_list,p); status = etcdWriter_addPublisherEndpoint(pubsub_discovery->writer,p,true); celixThreadMutex_unlock(&pubsub_discovery->discoveredPubsMutex); return status; }
celix_status_t calculatorProxy_registerProxyService(void* proxyFactoryService, endpoint_description_pt endpointDescription, void* rsa, sendToHandle sendToCallback) { celix_status_t status = CELIX_SUCCESS; remote_proxy_factory_service_pt calculatorProxyFactoryService = (remote_proxy_factory_service_pt) proxyFactoryService; calculator_pt calculator = NULL; calculator_service_pt calculatorService = NULL; calculatorProxy_create(calculatorProxyFactoryService->pool, calculatorProxyFactoryService->context, &calculator); calculatorService = apr_palloc(calculatorProxyFactoryService->pool, sizeof(*calculatorService)); calculatorService->calculator = calculator; calculatorService->add = calculatorProxy_add; calculatorService->sub = calculatorProxy_sub; calculatorService->sqrt = calculatorProxy_sqrt; properties_pt srvcProps = properties_create(); properties_set(srvcProps, (char *) "proxy.interface", (char *) CALCULATOR_SERVICE); properties_set(srvcProps, (char *) "endpoint.framework.uuid", (char *) endpointDescription->frameworkUUID); service_registration_pt proxyReg = NULL; calculatorProxy_setEndpointDescription(calculator, endpointDescription); calculatorProxy_setHandler(calculator, rsa); calculatorProxy_setCallback(calculator, sendToCallback); if (bundleContext_registerService(calculatorProxyFactoryService->context, CALCULATOR_SERVICE, calculatorService, srvcProps, &proxyReg) != CELIX_SUCCESS) { printf("CALCULATOR_PROXY: error while registering calculator service\n"); } hashMap_put(calculatorProxyFactoryService->proxy_registrations, endpointDescription, proxyReg); return status; }
celix_status_t pubsub_discovery_tmPublisherAnnounceAdded(void * handle, service_reference_pt reference, void * service) { celix_status_t status = CELIX_SUCCESS; pubsub_discovery_pt pubsub_discovery = (pubsub_discovery_pt)handle; publisher_endpoint_announce_pt listener = (publisher_endpoint_announce_pt)service; celixThreadMutex_lock(&pubsub_discovery->discoveredPubsMutex); celixThreadMutex_lock(&pubsub_discovery->listenerReferencesMutex); /* Notify the PSTM about discovered publisher endpoints */ hash_map_iterator_pt iter = hashMapIterator_create(pubsub_discovery->discoveredPubs); while(hashMapIterator_hasNext(iter)){ array_list_pt pubEP_list = (array_list_pt)hashMapIterator_nextValue(iter); int i; for(i=0;i<arrayList_size(pubEP_list);i++){ pubsub_endpoint_pt pubEP = (pubsub_endpoint_pt)arrayList_get(pubEP_list,i); status += listener->announcePublisher(listener->handle, pubEP); } } hashMapIterator_destroy(iter); hashMap_put(pubsub_discovery->listenerReferences, reference, NULL); celixThreadMutex_unlock(&pubsub_discovery->listenerReferencesMutex); celixThreadMutex_unlock(&pubsub_discovery->discoveredPubsMutex); printf("PSD: pubsub_tm_announce_publisher added.\n"); return status; }
celix_status_t serviceRegistry_registerServiceInternal(service_registry_pt registry, bundle_pt bundle, char * serviceName, void * serviceObject, properties_pt dictionary, bool isFactory, service_registration_pt *registration) { array_list_pt regs; celixThreadMutex_lock(®istry->mutex); if (isFactory) { *registration = serviceRegistration_createServiceFactory(registry, bundle, serviceName, ++registry->currentServiceId, serviceObject, dictionary); } else { *registration = serviceRegistration_create(registry, bundle, serviceName, ++registry->currentServiceId, serviceObject, dictionary); } serviceRegistry_addHooks(registry, serviceName, serviceObject, *registration); regs = (array_list_pt) hashMap_get(registry->serviceRegistrations, bundle); if (regs == NULL) { regs = NULL; arrayList_create(®s); } arrayList_add(regs, *registration); hashMap_put(registry->serviceRegistrations, bundle, regs); celixThreadMutex_unlock(®istry->mutex); if (registry->serviceChanged != NULL) { // service_event_pt event = (service_event_pt) malloc(sizeof(*event)); // event->type = REGISTERED; // event->reference = (*registration)->reference; registry->serviceChanged(registry->framework, OSGI_FRAMEWORK_SERVICE_EVENT_REGISTERED, *registration, NULL); // free(event); // event = NULL; } return CELIX_SUCCESS; }
celix_status_t importRegistration_getService(import_registration_pt import, bundle_pt bundle, service_registration_pt registration, void **out) { celix_status_t status = CELIX_SUCCESS; /* module_pt module = NULL; char *name = NULL; bundle_getCurrentModule(bundle, &module); module_getSymbolicName(module, &name); printf("getting service for bundle '%s'\n", name); */ pthread_mutex_lock(&import->proxiesMutex); struct service_proxy *proxy = hashMap_get(import->proxies, bundle); if (proxy == NULL) { status = importRegistration_createProxy(import, bundle, &proxy); if (status == CELIX_SUCCESS) { hashMap_put(import->proxies, bundle, proxy); } } if (status == CELIX_SUCCESS) { proxy->count += 1; *out = proxy->service; } pthread_mutex_unlock(&import->proxiesMutex); return status; }
celix_status_t managedServiceTracker_trackManagedService(managed_service_tracker_pt tracker, char *pid, service_reference_pt reference, managed_service_service_pt service) { managedServiceTracker_lockManagedServicesReferences(tracker); if (hashMap_containsKey(tracker->managedServicesReferences, pid)) { printf("[ WARNING ]: Tracker - Track ( Service{PID=%s} already registered ) ", pid); managedServiceTracker_unlockManagedServicesReferences(tracker); return CELIX_ILLEGAL_ARGUMENT; } hashMap_put(tracker->managedServicesReferences, pid, reference); hashMap_put(tracker->managedServices, pid, service); managedServiceTracker_unlockManagedServicesReferences(tracker); return CELIX_SUCCESS; }
void symTab_enter(JSymTab* tab, const char* name, JValue* value) { JValue* old; char* key = strPool_save(tab->pool, name, -1); old = (JValue*)hashMap_put(tab->map, key, value); if (old) { } }
celix_status_t serviceRegistry_unregisterService(service_registry_pt registry, bundle_pt bundle, service_registration_pt registration) { // array_list_t clients; unsigned int i; array_list_pt regs; array_list_pt references = NULL; celixThreadMutex_lock(®istry->mutex); serviceRegistry_removeHook(registry, registration); regs = (array_list_pt) hashMap_get(registry->serviceRegistrations, bundle); if (regs != NULL) { arrayList_removeElement(regs, registration); hashMap_put(registry->serviceRegistrations, bundle, regs); } celixThreadMutex_unlock(®istry->mutex); if (registry->serviceChanged != NULL) { registry->serviceChanged(registry->framework, OSGI_FRAMEWORK_SERVICE_EVENT_UNREGISTERING, registration, NULL); } celixThreadMutex_lock(®istry->mutex); // unget service serviceRegistration_getServiceReferences(registration, &references); for (i = 0; i < arrayList_size(references); i++) { service_reference_pt reference = (service_reference_pt) arrayList_get(references, i); array_list_pt clients = NULL; unsigned int j; clients = serviceRegistry_getUsingBundles(registry, reference); for (j = 0; (clients != NULL) && (j < arrayList_size(clients)); j++) { bundle_pt client = (bundle_pt) arrayList_get(clients, j); bool ungetResult = true; while (ungetResult) { serviceRegistry_ungetService(registry, client, reference, &ungetResult); } } arrayList_destroy(clients); serviceReference_invalidate(reference); } arrayList_destroy(references); //TODO not needed, the registration is destroyed, any reference to the registration is invalid and will result in a segfault serviceRegistration_invalidate(registration); // serviceRegistration_destroy(registration); celixThreadMutex_unlock(®istry->mutex); return CELIX_SUCCESS; }
celix_status_t wiringTopologyManager_wiringEndpointListenerAdded(void* handle, service_reference_pt reference, void* service) { celix_status_t status = CELIX_SUCCESS; wiring_topology_manager_pt manager = handle; char *scope = NULL; char* wtm = NULL; serviceReference_getProperty(reference, (char *) INAETICS_WIRING_ENDPOINT_LISTENER_SCOPE, &scope); serviceReference_getProperty(reference, "WTM", &wtm); if (wtm != NULL && strcmp(wtm, "true") == 0) { printf("WTM: Ignoring own ENDPOINT_LISTENER\n"); } else { status = celixThreadMutex_lock(&manager->listenerListLock); if (status == CELIX_SUCCESS) { hashMap_put(manager->listenerList, reference, NULL); celixThreadMutex_unlock(&manager->listenerListLock); } filter_pt filter = filter_create(scope); status = celixThreadMutex_lock(&manager->exportedWiringEndpointsLock); if (status == CELIX_SUCCESS) { hash_map_iterator_pt propIter = hashMapIterator_create(manager->exportedWiringEndpoints); while (hashMapIterator_hasNext(propIter)) { hash_map_pt wiringAdminList = hashMapIterator_nextValue(propIter); hash_map_iterator_pt waIter = hashMapIterator_create(wiringAdminList); while (hashMapIterator_hasNext(waIter)) { wiring_endpoint_description_pt wEndpoint = hashMapIterator_nextValue(waIter); bool matchResult = false; filter_match(filter, wEndpoint->properties, &matchResult); if (matchResult) { wiring_endpoint_listener_pt listener = (wiring_endpoint_listener_pt) service; status = listener->wiringEndpointAdded(listener->handle, wEndpoint, scope); } } hashMapIterator_destroy(waIter); } hashMapIterator_destroy(propIter); celixThreadMutex_unlock(&manager->exportedWiringEndpointsLock); } filter_destroy(filter); } return status; }
celix_status_t wiringAdmin_exportWiringEndpoint(wiring_admin_pt admin, wiring_endpoint_description_pt* wEndpointDescription) { celix_status_t status = CELIX_SUCCESS; celixThreadMutex_lock(&admin->exportedWiringEndpointLock); if (hashMap_size(admin->wiringReceiveTracker) == 0) { status = wiringAdmin_startWebserver(admin->context, &admin); } if (status == CELIX_SUCCESS) { char* fwuuid = NULL; status = bundleContext_getProperty(admin->context, OSGI_FRAMEWORK_FRAMEWORK_UUID, &fwuuid); if (status == CELIX_SUCCESS) { char* wireId = NULL; properties_pt props = properties_create(); printf("%s: HTTP Wiring Endpoint running at %s\n", TAG, admin->url); status = wiringEndpointDescription_create(NULL, props, wEndpointDescription); properties_set(props, WIRING_ADMIN_PROPERTIES_CONFIG_KEY, WIRING_ADMIN_PROPERTIES_CONFIG_VALUE); properties_set(props, WIRING_ENDPOINT_DESCRIPTION_HTTP_URL_KEY, admin->url); properties_set(props, (char*) OSGI_RSA_ENDPOINT_FRAMEWORK_UUID, fwuuid); wireId = properties_get(props, WIRING_ENDPOINT_DESCRIPTION_WIRE_ID_KEY); printf("%s: wiringEndpointDescription_create w/ wireId %s started\n", TAG, wireId); if (status == CELIX_SUCCESS) { service_tracker_pt tracker = NULL; status = wiringAdmin_createWiringReceiveTracker(admin, &tracker, wireId); if (status == CELIX_SUCCESS) { status = serviceTracker_open(tracker); if (status == CELIX_SUCCESS) { hashMap_put(admin->wiringReceiveTracker, *wEndpointDescription, tracker); printf("%s: WiringReceiveTracker w/ wireId %s started\n", TAG, wireId); } else { serviceTracker_destroy(tracker); } } } } } else { printf("%s: Cannot export Wiring Endpoint\n", TAG); } celixThreadMutex_unlock(&admin->exportedWiringEndpointLock); return status; }
static celix_status_t pubsubAdmin_addSubscriptionToPendingList(pubsub_admin_pt admin,pubsub_endpoint_pt subEP){ celix_status_t status = CELIX_SUCCESS; char* scope_topic = createScopeTopicKey(subEP->scope, subEP->topic); array_list_pt pendingListPerTopic = hashMap_get(admin->pendingSubscriptions,scope_topic); if(pendingListPerTopic==NULL){ arrayList_create(&pendingListPerTopic); hashMap_put(admin->pendingSubscriptions,strdup(scope_topic),pendingListPerTopic); } arrayList_add(pendingListPerTopic,subEP); free(scope_topic); return status; }
void test_hashMap_getEntry(void) { char * key = "key"; char * value = "value"; char * key2 = "key2"; char * value2 = "value2"; char * neKey = "notExisting"; char * key3 = NULL; char * value3 = "value3"; hash_map_entry_pt entry; hashMap_clear(map, false, false); // Add one entry hashMap_put(map, key, value); // Add second entry hashMap_put(map, key2, value2); entry = hashMap_getEntry(map, key); CU_ASSERT_STRING_EQUAL(entry->key, key); CU_ASSERT_STRING_EQUAL(entry->value, value); entry = hashMap_getEntry(map, key2); CU_ASSERT_STRING_EQUAL(entry->key, key2); CU_ASSERT_STRING_EQUAL(entry->value, value2); entry = hashMap_getEntry(map, neKey); CU_ASSERT_EQUAL(entry, NULL); entry = hashMap_getEntry(map, NULL); CU_ASSERT_EQUAL(entry, NULL); // Add third entry with NULL key hashMap_put(map, key3, value3); entry = hashMap_getEntry(map, key3); CU_ASSERT_EQUAL(entry->key, key3); CU_ASSERT_STRING_EQUAL(entry->value, value3); }
celix_status_t shell_addCommand(shell_pt shell_ptr, service_reference_pt reference_ptr) { celix_status_t status = CELIX_SUCCESS; command_service_pt command_ptr = NULL; char *name_str = NULL; if (!shell_ptr && !reference_ptr) { status = CELIX_ILLEGAL_ARGUMENT; } if (status == CELIX_SUCCESS) { status = bundleContext_getService(shell_ptr->bundle_context_ptr, reference_ptr, (void **) &command_ptr); if (!command_ptr) { status = CELIX_BUNDLE_EXCEPTION; } } if (status == CELIX_SUCCESS) { status = serviceReference_getProperty(reference_ptr, "command.name", &name_str); if (!name_str) { logHelper_log(shell_ptr->logHelper, OSGI_LOGSERVICE_ERROR, "Command service must contain a 'command.name' property!"); status = CELIX_BUNDLE_EXCEPTION; } } if (status == CELIX_SUCCESS) { hashMap_put(shell_ptr->command_name_map_ptr, name_str, command_ptr); hashMap_put(shell_ptr->command_reference_map_ptr, reference_ptr, command_ptr); } if (status != CELIX_SUCCESS) { shell_removeCommand(shell_ptr, reference_ptr); char err[32]; celix_strerror(status, err, 32); logHelper_log(shell_ptr->logHelper, OSGI_LOGSERVICE_ERROR, "Could not add command, got error %s\n", err); } return status; }
static celix_status_t etcdWatcher_addEntry(etcd_watcher_pt watcher, char* key, char* value) { celix_status_t status = CELIX_BUNDLE_EXCEPTION; endpoint_discovery_poller_pt poller = watcher->discovery->poller; if (!hashMap_containsKey(watcher->entries, key)) { status = endpointDiscoveryPoller_addDiscoveryEndpoint(poller, value); if (status == CELIX_SUCCESS) { hashMap_put(watcher->entries, strdup(key), strdup(value)); } } return status; }
void test_hashMapValues_toArray(void) { char * key = "key"; char * value = "value"; char * key2 = "key2"; char * value2 = "value2"; char **array; unsigned int size; hash_map_values_pt values; hashMap_clear(map, false, false); // Add one entry hashMap_put(map, key, value); // Add second entry hashMap_put(map, key2, value2); values = hashMapValues_create(map); hashMapValues_toArray(values, (void*)&array, &size); CU_ASSERT_EQUAL(size, 2); CU_ASSERT_TRUE(hashMapValues_contains(values, array[0])); CU_ASSERT_TRUE(hashMapValues_contains(values, array[1])); }
celix_status_t deploymentPackage_create(apr_pool_t *pool, bundle_context_pt context, manifest_pt manifest, deployment_package_pt *package) { celix_status_t status = CELIX_SUCCESS; *package = apr_palloc(pool, sizeof(**package)); if (!package) { status = CELIX_ENOMEM; } else { (*package)->pool = pool; (*package)->context = context; (*package)->manifest = manifest; (*package)->bundleInfos = NULL; (*package)->resourceInfos = NULL; (*package)->nameToBundleInfo = hashMap_create(utils_stringHash, NULL, utils_stringEquals, NULL); (*package)->pathToEntry = hashMap_create(utils_stringHash, NULL, utils_stringEquals, NULL); status = arrayList_create(&(*package)->bundleInfos); if (status == CELIX_SUCCESS) { status = arrayList_create(&(*package)->resourceInfos); if (status == CELIX_SUCCESS) { status = deploymentPackage_processEntries(*package); if (status == CELIX_SUCCESS) { int i; for (i = 0; i < arrayList_size((*package)->bundleInfos); i++) { bundle_info_pt info = arrayList_get((*package)->bundleInfos, i); hashMap_put((*package)->nameToBundleInfo, info->symbolicName, info); } for (i = 0; i < arrayList_size((*package)->resourceInfos); i++) { resource_info_pt info = arrayList_get((*package)->resourceInfos, i); hashMap_put((*package)->pathToEntry, info->path, info); } } } } } return status; }
static celix_status_t serviceRegistry_addUsageCount(service_registry_pt registry, bundle_pt bundle, service_reference_pt reference, usage_count_pt *usageCount) { array_list_pt usages = hashMap_get(registry->inUseMap, bundle); usage_count_pt usage = malloc(sizeof(*usage)); usage->reference = reference; usage->count = 0; usage->service = NULL; if (usages == NULL) { arrayList_create(&usages); } arrayList_add(usages, usage); hashMap_put(registry->inUseMap, bundle, usages); *usageCount = usage; return CELIX_SUCCESS; }
static void connectTopicPubSubToSerializer(pubsub_admin_pt admin,pubsub_serializer_service_t *serializer,void *topicPubSub,bool isPublication){ celixThreadMutex_lock(&admin->usedSerializersLock); hash_map_pt map = isPublication?admin->topicPublicationsPerSerializer:admin->topicSubscriptionsPerSerializer; array_list_pt list = (array_list_pt)hashMap_get(map,serializer); if(list==NULL){ arrayList_create(&list); hashMap_put(map,serializer,list); } arrayList_add(list,topicPubSub); celixThreadMutex_unlock(&admin->usedSerializersLock); }
void test_hashMap_removeMapping(void) { char * key = "key"; char * value = "value"; char * key2 = NULL; char * value2 = "value2"; hash_map_entry_pt entry1; hash_map_entry_pt entry2; hash_map_entry_pt removed; hashMap_clear(map, false, false); // Add one entry hashMap_put(map, key, value); // Add second entry with null key hashMap_put(map, key2, value2); entry1 = hashMap_getEntry(map, key); entry2 = hashMap_getEntry(map, key2); CU_ASSERT_PTR_NOT_NULL_FATAL(entry1); CU_ASSERT_PTR_NOT_NULL_FATAL(entry2); removed = hashMap_removeMapping(map, entry1); CU_ASSERT_PTR_EQUAL(entry1, removed); CU_ASSERT_EQUAL(map->size, 1); removed = hashMap_removeMapping(map, entry2); CU_ASSERT_PTR_EQUAL(entry2, removed); CU_ASSERT_EQUAL(map->size, 0); // Remove unexisting entry for empty map hashMap_removeMapping(map, NULL); CU_ASSERT_EQUAL(map->size, 0); CU_ASSERT_TRUE(hashMap_isEmpty(map)); }
void test_hashMap_get(void) { char * key = "key"; char * value = "value"; char * key2 = "key2"; char * value2 = "value2"; char * neKey = "notExisting"; char * key3 = NULL; char * value3 = "value3"; char * get; hashMap_clear(map, false, false); // Add one entry hashMap_put(map, key, value); // Add second entry hashMap_put(map, key2, value2); get = hashMap_get(map, key); CU_ASSERT_STRING_EQUAL(get, value); get = hashMap_get(map, key2); CU_ASSERT_STRING_EQUAL(get, value2); get = hashMap_get(map, neKey); CU_ASSERT_EQUAL(get, NULL); get = hashMap_get(map, NULL); CU_ASSERT_EQUAL(get, NULL); // Add third entry with NULL key hashMap_put(map, key3, value3); get = hashMap_get(map, NULL); CU_ASSERT_STRING_EQUAL(get, value3); }
static celix_status_t remoteProxyFactory_registerProxyService(remote_proxy_factory_pt remote_proxy_factory_ptr, endpoint_description_pt endpointDescription, remote_service_admin_pt rsa, sendToHandle sendToCallback) { celix_status_t status = CELIX_SUCCESS; proxy_instance_pt proxy_instance_ptr = NULL; if (!remote_proxy_factory_ptr || !remote_proxy_factory_ptr->create_proxy_service_ptr) { status = CELIX_ILLEGAL_ARGUMENT; } if (status == CELIX_SUCCESS) { proxy_instance_ptr = calloc(1, sizeof(*proxy_instance_ptr)); if (!proxy_instance_ptr) { status = CELIX_ENOMEM; } } if (status == CELIX_SUCCESS) { proxy_instance_ptr->properties = properties_create(); if (!proxy_instance_ptr->properties) { status = CELIX_BUNDLE_EXCEPTION; } } if (status == CELIX_SUCCESS) { status = remote_proxy_factory_ptr->create_proxy_service_ptr(remote_proxy_factory_ptr->handle, endpointDescription, rsa, sendToCallback, proxy_instance_ptr->properties, &proxy_instance_ptr->service); } if (status == CELIX_SUCCESS) { properties_set(proxy_instance_ptr->properties, "proxy.interface", remote_proxy_factory_ptr->service); hash_map_iterator_pt iter = hashMapIterator_create(endpointDescription->properties); while (hashMapIterator_hasNext(iter)) { hash_map_entry_pt entry = hashMapIterator_nextEntry(iter); char *key = hashMapEntry_getKey(entry); char *value = hashMapEntry_getValue(entry); properties_set(proxy_instance_ptr->properties, key, value); } } if (status == CELIX_SUCCESS) { status = bundleContext_registerService(remote_proxy_factory_ptr->context_ptr, remote_proxy_factory_ptr->service, proxy_instance_ptr->service, proxy_instance_ptr->properties, &proxy_instance_ptr->registration_ptr); } if (status == CELIX_SUCCESS) { hashMap_put(remote_proxy_factory_ptr->proxy_instances, endpointDescription, proxy_instance_ptr); } return status; }