You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@celix.apache.org by pn...@apache.org on 2017/11/20 20:33:00 UTC
[03/46] celix git commit: CELIX-417: Initial refactoring for CMake
usage
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/utils/private/src/hash_map.c
----------------------------------------------------------------------
diff --git a/utils/private/src/hash_map.c b/utils/private/src/hash_map.c
deleted file mode 100644
index bc514a7..0000000
--- a/utils/private/src/hash_map.c
+++ /dev/null
@@ -1,607 +0,0 @@
-/**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements. See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership. The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- *specific language governing permissions and limitations
- *under the License.
- */
-/*
- * hash_map.c
- *
- * \date Jul 21, 2010
- * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- * \copyright Apache License, Version 2.0
- */
-#include "celixbool.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-#include <stdint.h>
-#include <string.h>
-
-#include "hash_map.h"
-#include "hash_map_private.h"
-
-static unsigned int DEFAULT_INITIAL_CAPACITY = 16;
-static float DEFAULT_LOAD_FACTOR = 0.75f;
-static unsigned int MAXIMUM_CAPACITY = 1 << 30;
-
-unsigned int hashMap_hashCode(const void * toHash) {
- intptr_t address = (intptr_t) toHash;
- return address;
-}
-
-int hashMap_equals(const void * toCompare, const void * compare) {
- return toCompare == compare;
-}
-
-int hashMap_entryEquals(hash_map_pt map, hash_map_entry_pt entry, hash_map_entry_pt compare) {
- if (entry->key == compare->key || map->equalsKey(entry->key, compare->key)) {
- if (entry->value == compare->value || map->equalsValue(entry->value, compare->value)) {
- return true;
- }
- }
- return false;
-}
-
-static unsigned int hashMap_hash(unsigned int h) {
- h += ~(h << 9);
- h ^= ((h >> 14) | (h << 18)); /* >>> */
- h += (h << 4);
- h ^= ((h >> 10) | (h << 22)); /* >>> */
- return h;
-}
-
-static unsigned int hashMap_indexFor(unsigned int h, unsigned int length) {
- return h & (length - 1);
-}
-
-hash_map_pt hashMap_create(unsigned int (*keyHash)(const void *), unsigned int (*valueHash)(const void *),
- int (*keyEquals)(const void *, const void *), int (*valueEquals)(const void *, const void *)) {
- hash_map_pt map = (hash_map_pt) malloc(sizeof(*map));
- map->treshold = (unsigned int) (DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
- map->table = (hash_map_entry_pt *) calloc(DEFAULT_INITIAL_CAPACITY, sizeof(hash_map_entry_pt));
- map->size = 0;
- map->modificationCount = 0;
- map->tablelength = DEFAULT_INITIAL_CAPACITY;
- map->hashKey = hashMap_hashCode;
- map->hashValue = hashMap_hashCode;
- map->equalsKey = hashMap_equals;
- map->equalsValue = hashMap_equals;
-
- if (keyHash != NULL) {
- map->hashKey = keyHash;
- }
- if (valueHash != NULL) {
- map->hashValue = valueHash;
- }
- if (keyEquals != NULL) {
- map->equalsKey = keyEquals;
- }
- if (valueEquals != NULL) {
- map->equalsValue = valueEquals;
- }
-
- return map;
-}
-
-void hashMap_destroy(hash_map_pt map, bool freeKeys, bool freeValues) {
- hashMap_clear(map, freeKeys, freeValues);
- free(map->table);
- free(map);
-}
-
-int hashMap_size(hash_map_pt map) {
- return map->size;
-}
-
-bool hashMap_isEmpty(hash_map_pt map) {
- return hashMap_size(map) == 0;
-}
-
-void * hashMap_get(hash_map_pt map, const void* key) {
- unsigned int hash;
- if (key == NULL) {
- hash_map_entry_pt entry;
- for (entry = map->table[0]; entry != NULL; entry = entry->next) {
- if (entry->key == NULL) {
- return entry->value;
- }
- }
- return NULL;
- }
-
- hash = hashMap_hash(map->hashKey(key));
- hash_map_entry_pt entry = NULL;
- for (entry = map->table[hashMap_indexFor(hash, map->tablelength)]; entry != NULL; entry = entry->next) {
- if (entry->hash == hash && (entry->key == key || map->equalsKey(key, entry->key))) {
- return entry->value;
- }
- }
- return NULL;
-}
-
-bool hashMap_containsKey(hash_map_pt map, const void* key) {
- return hashMap_getEntry(map, key) != NULL;
-}
-
-hash_map_entry_pt hashMap_getEntry(hash_map_pt map, const void* key) {
- unsigned int hash = (key == NULL) ? 0 : hashMap_hash(map->hashKey(key));
- hash_map_entry_pt entry;
- int index = hashMap_indexFor(hash, map->tablelength);
- for (entry = map->table[index]; entry != NULL; entry = entry->next) {
- if (entry->hash == hash && (entry->key == key || map->equalsKey(key, entry->key))) {
- return entry;
- }
- }
- return NULL;
-}
-
-void * hashMap_put(hash_map_pt map, void * key, void * value) {
- unsigned int hash;
- int i;
- if (key == NULL) {
- hash_map_entry_pt entry;
- for (entry = map->table[0]; entry != NULL; entry = entry->next) {
- if (entry->key == NULL) {
- void * oldValue = entry->value;
- entry->value = value;
- return oldValue;
- }
- }
- map->modificationCount++;
- hashMap_addEntry(map, 0, NULL, value, 0);
- return NULL;
- }
- hash = hashMap_hash(map->hashKey(key));
- i = hashMap_indexFor(hash, map->tablelength);
-
- hash_map_entry_pt entry;
- for (entry = map->table[i]; entry != NULL; entry = entry->next) {
- if (entry->hash == hash && (entry->key == key || map->equalsKey(key, entry->key))) {
- void * oldValue = entry->value;
- entry->value = value;
- return oldValue;
- }
- }
- map->modificationCount++;
- hashMap_addEntry(map, hash, key, value, i);
- return NULL;
-}
-
-void hashMap_resize(hash_map_pt map, int newCapacity) {
- hash_map_entry_pt * newTable;
- unsigned int j;
- if (map->tablelength == MAXIMUM_CAPACITY) {
- return;
- }
-
- newTable = (hash_map_entry_pt *) calloc(newCapacity, sizeof(hash_map_entry_pt));
-
- for (j = 0; j < map->tablelength; j++) {
- hash_map_entry_pt entry = map->table[j];
- if (entry != NULL) {
- map->table[j] = NULL;
- do {
- hash_map_entry_pt next = entry->next;
- int i = hashMap_indexFor(entry->hash, newCapacity);
- entry->next = newTable[i];
- newTable[i] = entry;
- entry = next;
- } while (entry != NULL);
- }
- }
- free(map->table);
- map->table = newTable;
- map->tablelength = newCapacity;
- map->treshold = (unsigned int) ceil(newCapacity * DEFAULT_LOAD_FACTOR);
-}
-
-void * hashMap_remove(hash_map_pt map, const void* key) {
- hash_map_entry_pt entry = hashMap_removeEntryForKey(map, key);
- void * value = (entry == NULL ? NULL : entry->value);
- if (entry != NULL) {
- entry->key = NULL;
- entry->value = NULL;
- free(entry);
- }
- return value;
-}
-
-hash_map_entry_pt hashMap_removeEntryForKey(hash_map_pt map, const void* key) {
- unsigned int hash = (key == NULL) ? 0 : hashMap_hash(map->hashKey(key));
- int i = hashMap_indexFor(hash, map->tablelength);
- hash_map_entry_pt prev = map->table[i];
- hash_map_entry_pt entry = prev;
-
- while (entry != NULL) {
- hash_map_entry_pt next = entry->next;
- if (entry->hash == hash && (entry->key == key || (key != NULL && map->equalsKey(key, entry->key)))) {
- map->modificationCount++;
- map->size--;
- if (prev == entry) {
- map->table[i] = next;
- } else {
- prev->next = next;
- }
- return entry;
- }
- prev = entry;
- entry = next;
- }
-
- return entry;
-}
-
-hash_map_entry_pt hashMap_removeMapping(hash_map_pt map, hash_map_entry_pt entry) {
- unsigned int hash;
- hash_map_entry_pt prev;
- hash_map_entry_pt e;
- int i;
- if (entry == NULL) {
- return NULL;
- }
- hash = (entry->key == NULL) ? 0 : hashMap_hash(map->hashKey(entry->key));
- i = hashMap_indexFor(hash, map->tablelength);
- prev = map->table[i];
- e = prev;
-
- while (e != NULL) {
- hash_map_entry_pt next = e->next;
- if (e->hash == hash && hashMap_entryEquals(map, e, entry)) {
- map->modificationCount++;
- map->size--;
- if (prev == e) {
- map->table[i] = next;
- } else {
- prev->next = next;
- }
- return e;
- }
- prev = e;
- e = next;
- }
-
- return e;
-}
-
-void hashMap_clear(hash_map_pt map, bool freeKey, bool freeValue) {
- unsigned int i;
- hash_map_entry_pt * table;
- map->modificationCount++;
- table = map->table;
-
- for (i = 0; i < map->tablelength; i++) {
- hash_map_entry_pt entry = table[i];
- while (entry != NULL) {
- hash_map_entry_pt f = entry;
- entry = entry->next;
- if (freeKey && f->key != NULL)
- free(f->key);
- if (freeValue && f->value != NULL)
- free(f->value);
- free(f);
- }
- table[i] = NULL;
- }
- map->size = 0;
-}
-
-bool hashMap_containsValue(hash_map_pt map, const void* value) {
- unsigned int i;
- if (value == NULL) {
- for (i = 0; i < map->tablelength; i++) {
- hash_map_entry_pt entry;
- for (entry = map->table[i]; entry != NULL; entry = entry->next) {
- if (entry->value == NULL) {
- return true;
- }
- }
- }
- return false;
- }
- for (i = 0; i < map->tablelength; i++) {
- hash_map_entry_pt entry;
- for (entry = map->table[i]; entry != NULL; entry = entry->next) {
- if (entry->value == value || map->equalsValue(entry->value, value)) {
- return true;
- }
- }
- }
- return false;
-}
-
-void hashMap_addEntry(hash_map_pt map, int hash, void* key, void* value, int bucketIndex) {
- hash_map_entry_pt entry = map->table[bucketIndex];
- hash_map_entry_pt new = (hash_map_entry_pt) malloc(sizeof(*new));
- new->hash = hash;
- new->key = key;
- new->value = value;
- new->next = entry;
- map->table[bucketIndex] = new;
- if (map->size++ >= map->treshold) {
- hashMap_resize(map, 2 * map->tablelength);
- }
-}
-
-hash_map_iterator_pt hashMapIterator_alloc(void) {
- return calloc(1, sizeof(hash_map_iterator_t));
-}
-
-void hashMapIterator_dealloc(hash_map_iterator_pt iterator) {
- free(iterator);
-}
-
-hash_map_iterator_pt hashMapIterator_create(hash_map_pt map) {
- hash_map_iterator_pt iterator = hashMapIterator_alloc();
- hashMapIterator_init(map, iterator);
- return iterator;
-}
-
-UTILS_EXPORT hash_map_iterator_t hashMapIterator_construct(hash_map_pt map) {
- hash_map_iterator_t iter;
- memset(&iter, 0, sizeof(iter));
- hashMapIterator_init(map, &iter);
- return iter;
-}
-
-void hashMapIterator_init(hash_map_pt map, hash_map_iterator_pt iterator) {
- iterator->map = map;
- iterator->expectedModCount = map->modificationCount;
- iterator->index = 0;
- iterator->next = NULL;
- iterator->current = NULL;
- if (map->size > 0) {
- while (iterator->index < map->tablelength && (iterator->next = map->table[iterator->index++]) == NULL) {
- }
- }
-}
-
-void hashMapIterator_deinit(hash_map_iterator_pt iterator) {
- iterator->current = NULL;
- iterator->expectedModCount = 0;
- iterator->index = 0;
- iterator->map = NULL;
- iterator->next = NULL;
-}
-
-void hashMapIterator_destroy(hash_map_iterator_pt iterator) {
- hashMapIterator_deinit(iterator);
- hashMapIterator_dealloc(iterator);
-}
-
-bool hashMapIterator_hasNext(hash_map_iterator_pt iterator) {
- return iterator->next != NULL;
-}
-
-void hashMapIterator_remove(hash_map_iterator_pt iterator) {
- void * key;
- hash_map_entry_pt entry;
- if (iterator->current == NULL) {
- return;
- }
- if (iterator->expectedModCount != iterator->map->modificationCount) {
- return;
- }
- key = iterator->current->key;
- iterator->current = NULL;
- entry = hashMap_removeEntryForKey(iterator->map, key);
- free(entry);
- iterator->expectedModCount = iterator->map->modificationCount;
-}
-
-void * hashMapIterator_nextValue(hash_map_iterator_pt iterator) {
- hash_map_entry_pt entry;
- if (iterator->expectedModCount != iterator->map->modificationCount) {
- return NULL;
- }
- entry = iterator->next;
- if (entry == NULL) {
- return NULL;
- }
- if ((iterator->next = entry->next) == NULL) {
- while (iterator->index < iterator->map->tablelength && (iterator->next = iterator->map->table[iterator->index++]) == NULL) {
- }
- }
- iterator->current = entry;
- return entry->value;
-}
-
-void * hashMapIterator_nextKey(hash_map_iterator_pt iterator) {
- hash_map_entry_pt entry;
- if (iterator->expectedModCount != iterator->map->modificationCount) {
- return NULL;
- }
- entry = iterator->next;
- if (entry == NULL) {
- return NULL;
- }
- if ((iterator->next = entry->next) == NULL) {
- while (iterator->index < iterator->map->tablelength && (iterator->next = iterator->map->table[iterator->index++]) == NULL) {
- }
- }
- iterator->current = entry;
- return entry->key;
-}
-
-hash_map_entry_pt hashMapIterator_nextEntry(hash_map_iterator_pt iterator) {
- hash_map_entry_pt entry;
- if (iterator->expectedModCount != iterator->map->modificationCount) {
- return NULL;
- }
- entry = iterator->next;
- if (entry == NULL) {
- return NULL;
- }
- if ((iterator->next = entry->next) == NULL) {
- while (iterator->index < iterator->map->tablelength && (iterator->next = iterator->map->table[iterator->index++]) == NULL) {
- }
- }
- iterator->current = entry;
- return entry;
-}
-
-hash_map_key_set_pt hashMapKeySet_create(hash_map_pt map) {
- hash_map_key_set_pt keySet = (hash_map_key_set_pt) malloc(sizeof(*keySet));
- keySet->map = map;
-
- return keySet;
-}
-
-void hashMapKeySet_destroy(hash_map_key_set_pt keySet){
- keySet->map = NULL;
- free(keySet);
-}
-
-int hashMapKeySet_size(hash_map_key_set_pt keySet) {
- return keySet->map->size;
-}
-
-bool hashMapKeySet_contains(hash_map_key_set_pt keySet, const void* key) {
- return hashMap_containsKey(keySet->map, key);
-}
-
-bool hashMapKeySet_remove(hash_map_key_set_pt keySet, const void* key) {
- hash_map_entry_pt entry = hashMap_removeEntryForKey(keySet->map, key);
- bool removed = entry != NULL;
- free(entry);
- return removed;
-}
-
-void hashMapKeySet_clear(hash_map_key_set_pt keySet) {
- hashMap_clear(keySet->map, false, false);
-}
-
-bool hashMapKeySet_isEmpty(hash_map_key_set_pt keySet) {
- return hashMapKeySet_size(keySet) == 0;
-}
-
-hash_map_values_pt hashMapValues_create(hash_map_pt map) {
- hash_map_values_pt values = (hash_map_values_pt) malloc(sizeof(*values));
- values->map = map;
-
- return values;
-}
-
-void hashMapValues_destroy(hash_map_values_pt values) {
- values->map = NULL;
- free(values);
-}
-
-hash_map_iterator_pt hashMapValues_iterator(hash_map_values_pt values) {
- return hashMapIterator_create(values->map);
-}
-
-int hashMapValues_size(hash_map_values_pt values) {
- return values->map->size;
-}
-
-bool hashMapValues_contains(hash_map_values_pt values, const void* value) {
- return hashMap_containsValue(values->map, value);
-}
-
-void hashMapValues_toArray(hash_map_values_pt values, void* *array[], unsigned int *size) {
- hash_map_iterator_pt it;
- int i = 0;
- int vsize = hashMapValues_size(values);
- *size = vsize;
- *array = malloc(vsize * sizeof(**array));
- it = hashMapValues_iterator(values);
- while(hashMapIterator_hasNext(it) && i<vsize){
- (*array)[i++] = hashMapIterator_nextValue(it);
- }
- hashMapIterator_destroy(it);
-}
-
-bool hashMapValues_remove(hash_map_values_pt values, const void* value) {
- hash_map_iterator_pt iterator = hashMapValues_iterator(values);
- if (value == NULL) {
- while (hashMapIterator_hasNext(iterator)) {
- if (hashMapIterator_nextValue(iterator) == NULL) {
- hashMapIterator_remove(iterator);
- hashMapIterator_destroy(iterator);
- return true;
- }
- }
- } else {
- while (hashMapIterator_hasNext(iterator)) {
- if (values->map->equalsValue(value, hashMapIterator_nextValue(iterator))) {
- hashMapIterator_remove(iterator);
- hashMapIterator_destroy(iterator);
- return true;
- }
- }
- }
- hashMapIterator_destroy(iterator);
- return false;
-}
-
-void hashMapValues_clear(hash_map_values_pt values) {
- hashMap_clear(values->map, false, false);
-}
-
-bool hashMapValues_isEmpty(hash_map_values_pt values) {
- return hashMapValues_size(values) == 0;
-}
-
-hash_map_entry_set_pt hashMapEntrySet_create(hash_map_pt map) {
- hash_map_entry_set_pt entrySet = (hash_map_entry_set_pt) malloc(sizeof(*entrySet));
- entrySet->map = map;
-
- return entrySet;
-}
-
-void hashMapEntrySet_destroy(hash_map_entry_set_pt entrySet){
- entrySet->map = NULL;
- free(entrySet);
-}
-
-int hashMapEntrySet_size(hash_map_entry_set_pt entrySet) {
- return entrySet->map->size;
-}
-
-bool hashMapEntrySet_contains(hash_map_entry_set_pt entrySet, hash_map_entry_pt entry) {
- return hashMap_containsValue(entrySet->map, entry);
-}
-
-bool hashMapEntrySet_remove(hash_map_entry_set_pt entrySet, hash_map_entry_pt entry) {
- hash_map_entry_pt temp = hashMap_removeMapping(entrySet->map, entry);
- if (temp != NULL) {
- free(temp);
- return true;
- } else {
- return false;
- }
-}
-
-void hashMapEntrySet_clear(hash_map_entry_set_pt entrySet) {
- hashMap_clear(entrySet->map, false, false);
-}
-
-bool hashMapEntrySet_isEmpty(hash_map_entry_set_pt entrySet) {
- return hashMapEntrySet_size(entrySet) == 0;
-}
-
-void * hashMapEntry_getKey(hash_map_entry_pt entry) {
- return entry->key;
-}
-
-void * hashMapEntry_getValue(hash_map_entry_pt entry) {
- return entry->value;
-}
-
-
-
-
-
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/utils/private/src/linked_list.c
----------------------------------------------------------------------
diff --git a/utils/private/src/linked_list.c b/utils/private/src/linked_list.c
deleted file mode 100644
index 235c3e7..0000000
--- a/utils/private/src/linked_list.c
+++ /dev/null
@@ -1,268 +0,0 @@
-/**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements. See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership. The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- *specific language governing permissions and limitations
- *under the License.
- */
-/*
- * linked_list.c
- *
- * \date Jul 16, 2010
- * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- * \copyright Apache License, Version 2.0
- */
-#include "celixbool.h"
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "linked_list.h"
-#include "linked_list_private.h"
-
-celix_status_t linkedList_create(linked_list_pt *list) {
- linked_list_pt linked_list = malloc(sizeof(*linked_list));
- if (linked_list) {
- linked_list->header = (linked_list_entry_pt) malloc(sizeof(*(linked_list->header)));
- if (linked_list->header) {
- linked_list->header->element = NULL;
- linked_list->header->next = linked_list->header;
- linked_list->header->previous = linked_list->header;
- linked_list->size = 0;
- linked_list->modificationCount = 0;
-
- *list = linked_list;
-
- return CELIX_SUCCESS;
- }
- }
-
- return CELIX_ENOMEM;
-}
-
-UTILS_EXPORT celix_status_t linkedList_destroy(linked_list_pt list) {
- celix_status_t status = CELIX_SUCCESS;
-
- linked_list_entry_pt current = NULL;
- linked_list_entry_pt next = NULL;
-
- current = list->header->next;
-
- while (current != list->header) {
- next = current->next;
- free(current);
- current = next;
- }
-
- free(list->header);
- free(list);
-
- return status;
-}
-
-celix_status_t linkedList_clone(linked_list_pt list, linked_list_pt *clone) {
- celix_status_t status;
-
- status = linkedList_create(clone);
- if (status == CELIX_SUCCESS) {
- struct linked_list_entry *e;
- for (e = list->header->next; e != list->header; e = e->next) {
- linkedList_addElement(*clone, e->element);
- }
- }
-
- return status;
-}
-
-void * linkedList_getFirst(linked_list_pt list) {
- if (list->size == 0) {
- return NULL;
- }
- return list->header->next->element;
-}
-
-void * linkedList_getLast(linked_list_pt list) {
- if (list->size == 0) {
- return NULL;
- }
- return list->header->previous->element;
-}
-
-void * linkedList_removeFirst(linked_list_pt list) {
- return linkedList_removeEntry(list, list->header->next);
-}
-
-void * linkedList_removeLast(linked_list_pt list) {
- return linkedList_removeEntry(list, list->header->previous);
-}
-
-void linkedList_addFirst(linked_list_pt list, void * element) {
- linkedList_addBefore(list, element, list->header->next);
-}
-
-void linkedList_addLast(linked_list_pt list, void * element) {
- linkedList_addBefore(list, element, list->header);
-}
-
-bool linkedList_contains(linked_list_pt list, void * element) {
- return linkedList_indexOf(list, element) != -1;
-}
-
-int linkedList_size(linked_list_pt list) {
- return list->size;
-}
-
-bool linkedList_isEmpty(linked_list_pt list) {
- return linkedList_size(list) == 0;
-}
-
-bool linkedList_addElement(linked_list_pt list, void * element) {
- linkedList_addBefore(list, element, list->header);
- return true;
-}
-
-bool linkedList_removeElement(linked_list_pt list, void * element) {
- if (element == NULL) {
- linked_list_entry_pt entry;
- for (entry = list->header->next; entry != list->header; entry = entry->next) {
- if (entry->element == NULL) {
- linkedList_removeEntry(list, entry);
- return true;
- }
- }
- } else {
- linked_list_entry_pt entry;
- for (entry = list->header->next; entry != list->header; entry = entry->next) {
- if (element == entry->element) {
- linkedList_removeEntry(list, entry);
- return true;
- }
- }
- }
- return false;
-}
-
-void linkedList_clear(linked_list_pt list) {
- linked_list_entry_pt entry = list->header->next;
- while (entry != list->header) {
- linked_list_entry_pt next = entry->next;
- entry->next = entry->previous = NULL;
- // free(entry->element);
- entry->element = NULL;
- free(entry);
- entry = next;
- }
- list->header->next = list->header->previous = list->header;
- list->size = 0;
- list->modificationCount++;
-}
-
-void * linkedList_get(linked_list_pt list, int index) {
- return linkedList_entry(list, index)->element;
-}
-void * linkedList_set(linked_list_pt list, int index, void * element) {
- linked_list_entry_pt entry = linkedList_entry(list, index);
- void * old = entry->element;
- entry->element = element;
- return old;
-}
-
-void linkedList_addIndex(linked_list_pt list, int index, void * element) {
- linkedList_addBefore(list, element, (index == list->size ? list->header : linkedList_entry(list, index)));
-}
-
-void * linkedList_removeIndex(linked_list_pt list, int index) {
- return linkedList_removeEntry(list, linkedList_entry(list, index));
-}
-
-linked_list_entry_pt linkedList_entry(linked_list_pt list, int index) {
- linked_list_entry_pt entry;
- int i;
- if (index < 0 || index >= list->size) {
- return NULL;
- }
-
- entry = list->header;
- if (index < (list->size >> 1)) {
- for (i = 0; i <= index; i++) {
- entry = entry->next;
- }
- } else {
- for (i = list->size; i > index; i--) {
- entry = entry->previous;
- }
- }
- return entry;
-}
-
-int linkedList_indexOf(linked_list_pt list, void * element) {
- int index = 0;
- if (element == NULL) {
- linked_list_entry_pt entry;
- for (entry = list->header->next; entry != list->header; entry = entry->next) {
- if (entry->element == NULL) {
- return index;
- }
- index++;
- }
- } else {
- linked_list_entry_pt entry;
- for (entry = list->header->next; entry != list->header; entry = entry->next) {
- if (element == entry->element) {
- return index;
- }
- index++;
- }
- }
- return -1;
-}
-
-linked_list_entry_pt linkedList_addBefore(linked_list_pt list, void * element, linked_list_entry_pt entry) {
- linked_list_entry_pt new = NULL;
-
- new = malloc(sizeof(*new));
- if (new != NULL) {
-
- new->element = element;
- new->next = entry;
- new->previous = entry->previous;
-
- new->previous->next = new;
- new->next->previous = new;
-
- list->size++;
- list->modificationCount++;
- }
-
- return new;
-}
-
-void * linkedList_removeEntry(linked_list_pt list, linked_list_entry_pt entry) {
- void * result;
- if (entry == list->header) {
- return NULL;
- }
-
- result = entry->element;
-
- entry->previous->next = entry->next;
- entry->next->previous = entry->previous;
-
- entry->next = entry->previous = NULL;
- free(entry);
-
- list->size--;
- list->modificationCount++;
-
- return result;
-}
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/utils/private/src/linked_list_iterator.c
----------------------------------------------------------------------
diff --git a/utils/private/src/linked_list_iterator.c b/utils/private/src/linked_list_iterator.c
deleted file mode 100644
index dc0e5c4..0000000
--- a/utils/private/src/linked_list_iterator.c
+++ /dev/null
@@ -1,153 +0,0 @@
-/**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements. See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership. The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- *specific language governing permissions and limitations
- *under the License.
- */
-/*
- * linked_list_iterator.c
- *
- * \date Jul 16, 2010
- * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- * \copyright Apache License, Version 2.0
- */
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "linked_list_iterator.h"
-#include "linked_list_private.h"
-
-struct linkedListIterator {
- linked_list_entry_pt lastReturned;
- linked_list_entry_pt next;
- int nextIndex;
- linked_list_pt list;
- int expectedModificationCount;
-};
-
-linked_list_iterator_pt linkedListIterator_create(linked_list_pt list, unsigned int index) {
- linked_list_iterator_pt iterator;
- if (index > list->size) {
- return NULL;
- }
- iterator = (linked_list_iterator_pt) malloc(sizeof(*iterator));
- iterator->lastReturned = list->header;
- iterator->list = list;
- iterator->expectedModificationCount = list->modificationCount;
- if (index < (list->size >> 1)) {
- iterator->next = iterator->list->header->next;
- for (iterator->nextIndex = 0; iterator->nextIndex < index; iterator->nextIndex++) {
- iterator->next = iterator->next->next;
- }
- } else {
- iterator->next = list->header;
- for (iterator->nextIndex = list->size; iterator->nextIndex > index; iterator->nextIndex--) {
- iterator->next = iterator->next->previous;
- }
- }
- return iterator;
-}
-
-void linkedListIterator_destroy(linked_list_iterator_pt iterator) {
- iterator->expectedModificationCount = 0;
- iterator->lastReturned = NULL;
- iterator->list = NULL;
- iterator->next = NULL;
- iterator->nextIndex = 0;
- free(iterator);
-}
-
-bool linkedListIterator_hasNext(linked_list_iterator_pt iterator) {
- return iterator->nextIndex != iterator->list->size;
-}
-
-void * linkedListIterator_next(linked_list_iterator_pt iterator) {
- if (iterator->list->modificationCount != iterator->expectedModificationCount) {
- return NULL;
- }
- if (iterator->nextIndex == iterator->list->size) {
- return NULL;
- }
- iterator->lastReturned = iterator->next;
- iterator->next = iterator->next->next;
- iterator->nextIndex++;
- return iterator->lastReturned->element;
-}
-
-bool linkedListIterator_hasPrevious(linked_list_iterator_pt iterator) {
- return iterator->nextIndex != 0;
-}
-
-void * linkedListIterator_previous(linked_list_iterator_pt iterator) {
- if (iterator->nextIndex == 0) {
- return NULL;
- }
-
- iterator->lastReturned = iterator->next = iterator->next->previous;
- iterator->nextIndex--;
-
- if (iterator->list->modificationCount != iterator->expectedModificationCount) {
- return NULL;
- }
-
- return iterator->lastReturned->element;
-}
-
-int linkedListIterator_nextIndex(linked_list_iterator_pt iterator) {
- return iterator->nextIndex;
-}
-
-int linkedListIterator_previousIndex(linked_list_iterator_pt iterator) {
- return iterator->nextIndex-1;
-}
-
-void linkedListIterator_remove(linked_list_iterator_pt iterator) {
- linked_list_entry_pt lastNext;
- if (iterator->list->modificationCount != iterator->expectedModificationCount) {
- return;
- }
- lastNext = iterator->lastReturned->next;
- if (linkedList_removeEntry(iterator->list, iterator->lastReturned) == NULL) {
- return;
- }
- if (iterator->next == iterator->lastReturned) {
- iterator->next = lastNext;
- } else {
- iterator->nextIndex--;
- }
- iterator->lastReturned = iterator->list->header;
- iterator->expectedModificationCount++;
-}
-
-void linkedListIterator_set(linked_list_iterator_pt iterator, void * element) {
- if (iterator->lastReturned == iterator->list->header) {
- return;
- }
- if (iterator->list->modificationCount != iterator->expectedModificationCount) {
- return;
- }
- iterator->lastReturned->element = element;
-}
-
-void linkedListIterator_add(linked_list_iterator_pt iterator, void * element) {
- if (iterator->list->modificationCount != iterator->expectedModificationCount) {
- return;
- }
- iterator->lastReturned = iterator->list->header;
- linkedList_addBefore(iterator->list, element, iterator->next);
- iterator->nextIndex++;
- iterator->expectedModificationCount++;
-}
-
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/utils/private/src/memstream/fmemopen.c
----------------------------------------------------------------------
diff --git a/utils/private/src/memstream/fmemopen.c b/utils/private/src/memstream/fmemopen.c
deleted file mode 100644
index cb1b0c0..0000000
--- a/utils/private/src/memstream/fmemopen.c
+++ /dev/null
@@ -1,76 +0,0 @@
-
-/*
- * fmem.c : fmemopen() on top of BSD's funopen()
- * 20081017 AF
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-struct fmem {
- size_t pos;
- size_t size;
- char *buffer;
-};
-typedef struct fmem fmem_t;
-
-static int readfn(void *handler, char *buf, int size)
-{
- int count = 0;
- fmem_t *mem = handler;
- size_t available = mem->size - mem->pos;
-
- if(size > available) size = available;
- for(count=0; count < size; mem->pos++, count++)
- buf[count] = mem->buffer[mem->pos];
-
- return count;
-}
-
-static int writefn(void *handler, const char *buf, int size)
-{
- int count = 0;
- fmem_t *mem = handler;
- size_t available = mem->size - mem->pos;
-
- if(size > available) size = available;
- for(count=0; count < size; mem->pos++, count++)
- mem->buffer[mem->pos] = buf[count];
-
- return count; // ? count : size;
-}
-
-static fpos_t seekfn(void *handler, fpos_t offset, int whence)
-{
- size_t pos;
- fmem_t *mem = handler;
-
- switch(whence) {
- case SEEK_SET: pos = offset; break;
- case SEEK_CUR: pos = mem->pos + offset; break;
- case SEEK_END: pos = mem->size + offset; break;
- default: return -1;
- }
-
- if(pos > mem->size) return -1;
-
- mem->pos = pos;
- return (fpos_t) pos;
-}
-
-static int closefn(void *handler)
-{
- free(handler);
- return 0;
-}
-
-/* simple, but portable version of fmemopen for OS X / BSD */
-FILE *fmemopen(void *buf, size_t size, const char *mode)
-{
- fmem_t *mem = (fmem_t *) malloc(sizeof(fmem_t));
-
- memset(mem, 0, sizeof(fmem_t));
- mem->size = size, mem->buffer = buf;
- return funopen(mem, readfn, writefn, seekfn, closefn);
-}
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/utils/private/src/memstream/open_memstream.c
----------------------------------------------------------------------
diff --git a/utils/private/src/memstream/open_memstream.c b/utils/private/src/memstream/open_memstream.c
deleted file mode 100644
index 6bc4f01..0000000
--- a/utils/private/src/memstream/open_memstream.c
+++ /dev/null
@@ -1,130 +0,0 @@
-/* Use funopen(3) to provide open_memstream(3) like functionality. */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <errno.h>
-
-struct memstream {
- char **cp;
- size_t *lenp;
- size_t offset;
-};
-
-static void
-memstream_grow(struct memstream *ms, size_t newsize)
-{
- char *buf;
-
- if (newsize > *ms->lenp) {
- buf = realloc(*ms->cp, newsize + 1);
- if (buf != NULL) {
-#ifdef DEBUG
- fprintf(stderr, "MS: %p growing from %zd to %zd\n",
- ms, *ms->lenp, newsize);
-#endif
- memset(buf + *ms->lenp + 1, 0, newsize - *ms->lenp);
- *ms->cp = buf;
- *ms->lenp = newsize;
- }
- }
-}
-
-static int
-memstream_read(void *cookie, char *buf, int len)
-{
- struct memstream *ms;
- int tocopy;
-
- ms = cookie;
- memstream_grow(ms, ms->offset + len);
- tocopy = *ms->lenp - ms->offset;
- if (len < tocopy)
- tocopy = len;
- memcpy(buf, *ms->cp + ms->offset, tocopy);
- ms->offset += tocopy;
-#ifdef DEBUG
- fprintf(stderr, "MS: read(%p, %d) = %d\n", ms, len, tocopy);
-#endif
- return (tocopy);
-}
-
-static int
-memstream_write(void *cookie, const char *buf, int len)
-{
- struct memstream *ms;
- int tocopy;
-
- ms = cookie;
- memstream_grow(ms, ms->offset + len);
- tocopy = *ms->lenp - ms->offset;
- if (len < tocopy)
- tocopy = len;
- memcpy(*ms->cp + ms->offset, buf, tocopy);
- ms->offset += tocopy;
-#ifdef DEBUG
- fprintf(stderr, "MS: write(%p, %d) = %d\n", ms, len, tocopy);
-#endif
- return (tocopy);
-}
-
-static fpos_t
-memstream_seek(void *cookie, fpos_t pos, int whence)
-{
- struct memstream *ms;
-#ifdef DEBUG
- size_t old;
-#endif
-
- ms = cookie;
-#ifdef DEBUG
- old = ms->offset;
-#endif
- switch (whence) {
- case SEEK_SET:
- ms->offset = pos;
- break;
- case SEEK_CUR:
- ms->offset += pos;
- break;
- case SEEK_END:
- ms->offset = *ms->lenp + pos;
- break;
- }
-#ifdef DEBUG
- fprintf(stderr, "MS: seek(%p, %zd, %d) %zd -> %zd\n", ms, pos, whence,
- old, ms->offset);
-#endif
- return (ms->offset);
-}
-
-static int
-memstream_close(void *cookie)
-{
-
- free(cookie);
- return (0);
-}
-
-FILE *
-open_memstream(char **cp, size_t *lenp)
-{
- struct memstream *ms;
- int save_errno;
- FILE *fp;
-
- *cp = NULL;
- *lenp = 0;
- ms = malloc(sizeof(*ms));
- ms->cp = cp;
- ms->lenp = lenp;
- ms->offset = 0;
- fp = funopen(ms, memstream_read, memstream_write, memstream_seek,
- memstream_close);
- if (fp == NULL) {
- save_errno = errno;
- free(ms);
- errno = save_errno;
- }
- return (fp);
-}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/utils/private/src/properties.c
----------------------------------------------------------------------
diff --git a/utils/private/src/properties.c b/utils/private/src/properties.c
deleted file mode 100644
index 0bd6dc3..0000000
--- a/utils/private/src/properties.c
+++ /dev/null
@@ -1,302 +0,0 @@
-/**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements. See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership. The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- *specific language governing permissions and limitations
- *under the License.
- */
-/*
- * properties.c
- *
- * \date Apr 27, 2010
- * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- * \copyright Apache License, Version 2.0
- */
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <ctype.h>
-#include "celixbool.h"
-#include "properties.h"
-#include "utils.h"
-
-#define MALLOC_BLOCK_SIZE 5
-
-static void parseLine(const char* line, properties_pt props);
-
-properties_pt properties_create(void) {
- return hashMap_create(utils_stringHash, utils_stringHash, utils_stringEquals, utils_stringEquals);
-}
-
-void properties_destroy(properties_pt properties) {
- hash_map_iterator_pt iter = hashMapIterator_create(properties);
- while (hashMapIterator_hasNext(iter)) {
- hash_map_entry_pt entry = hashMapIterator_nextEntry(iter);
- free(hashMapEntry_getKey(entry));
- free(hashMapEntry_getValue(entry));
- }
- hashMapIterator_destroy(iter);
- hashMap_destroy(properties, false, false);
-}
-
-properties_pt properties_load(const char* filename) {
- FILE *file = fopen(filename, "r");
- if(file==NULL){
- return NULL;
- }
- properties_pt props = properties_loadWithStream(file);
- fclose(file);
- return props;
-}
-
-properties_pt properties_loadWithStream(FILE *file) {
- properties_pt props = NULL;
-
-
- if (file != NULL ) {
- char *saveptr;
- char *filebuffer = NULL;
- char *line = NULL;
- size_t file_size = 0;
-
- props = properties_create();
- fseek(file, 0, SEEK_END);
- file_size = ftell(file);
- fseek(file, 0, SEEK_SET);
-
- if(file_size > 0){
- filebuffer = calloc(file_size + 1, sizeof(char));
- if(filebuffer) {
- size_t rs = fread(filebuffer, sizeof(char), file_size, file);
- if(rs != file_size){
- fprintf(stderr,"fread read only %lu bytes out of %lu\n",rs,file_size);
- }
- filebuffer[file_size]='\0';
- line = strtok_r(filebuffer, "\n", &saveptr);
- while ( line != NULL ) {
- parseLine(line, props);
- line = strtok_r(NULL, "\n", &saveptr);
- }
- free(filebuffer);
- }
- }
- }
-
- return props;
-}
-
-
-/**
- * Header is ignored for now, cannot handle comments yet
- */
-void properties_store(properties_pt properties, const char* filename, const char* header) {
- FILE *file = fopen ( filename, "w+" );
- char *str;
-
- if (file != NULL) {
- if (hashMap_size(properties) > 0) {
- hash_map_iterator_pt iterator = hashMapIterator_create(properties);
- while (hashMapIterator_hasNext(iterator)) {
- hash_map_entry_pt entry = hashMapIterator_nextEntry(iterator);
- str = hashMapEntry_getKey(entry);
- for (int i = 0; i < strlen(str); i += 1) {
- if (str[i] == '#' || str[i] == '!' || str[i] == '=' || str[i] == ':') {
- fputc('\\', file);
- }
- fputc(str[i], file);
- }
-
- fputc('=', file);
-
- str = hashMapEntry_getValue(entry);
- for (int i = 0; i < strlen(str); i += 1) {
- if (str[i] == '#' || str[i] == '!' || str[i] == '=' || str[i] == ':') {
- fputc('\\', file);
- }
- fputc(str[i], file);
- }
-
- fputc('\n', file);
-
- }
- hashMapIterator_destroy(iterator);
- }
- fclose(file);
- } else {
- perror("File is null");
- }
-}
-
-celix_status_t properties_copy(properties_pt properties, properties_pt *out) {
- celix_status_t status = CELIX_SUCCESS;
- properties_pt copy = properties_create();
-
- if (copy != NULL) {
- hash_map_iterator_pt iter = hashMapIterator_create(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(copy, key, value);
- }
- hashMapIterator_destroy(iter);
- } else {
- status = CELIX_ENOMEM;
- }
-
- if (status == CELIX_SUCCESS) {
- *out = copy;
- }
-
- return status;
-}
-
-const char* properties_get(properties_pt properties, const char* key) {
- return hashMap_get(properties, (void*)key);
-}
-
-const char* properties_getWithDefault(properties_pt properties, const char* key, const char* defaultValue) {
- const char* value = properties_get(properties, key);
- return value == NULL ? defaultValue : value;
-}
-
-void properties_set(properties_pt properties, const char* key, const char* value) {
- hash_map_entry_pt entry = hashMap_getEntry(properties, key);
- char* oldValue = NULL;
- if (entry != NULL) {
- char* oldKey = hashMapEntry_getKey(entry);
- oldValue = hashMapEntry_getValue(entry);
- hashMap_put(properties, oldKey, strndup(value, 1024*10));
- } else {
- hashMap_put(properties, strndup(key, 1024*10), strndup(value, 1024*10));
- }
- free(oldValue);
-}
-
-static void updateBuffers(char **key, char ** value, char **output, int outputPos, int *key_len, int *value_len) {
- if (*output == *key) {
- if (outputPos == (*key_len) - 1) {
- (*key_len) += MALLOC_BLOCK_SIZE;
- *key = realloc(*key, *key_len);
- *output = *key;
- }
- }
- else {
- if (outputPos == (*value_len) - 1) {
- (*value_len) += MALLOC_BLOCK_SIZE;
- *value = realloc(*value, *value_len);
- *output = *value;
- }
- }
-}
-
-static void parseLine(const char* line, properties_pt props) {
- int linePos = 0;
- bool precedingCharIsBackslash = false;
- bool isComment = false;
- int outputPos = 0;
- char *output = NULL;
- int key_len = MALLOC_BLOCK_SIZE;
- int value_len = MALLOC_BLOCK_SIZE;
- linePos = 0;
- precedingCharIsBackslash = false;
- isComment = false;
- output = NULL;
- outputPos = 0;
-
- //Ignore empty lines
- if (line[0] == '\n' && line[1] == '\0') {
- return;
- }
-
- char *key = calloc(1, key_len);
- char *value = calloc(1, value_len);
- key[0] = '\0';
- value[0] = '\0';
-
- while (line[linePos] != '\0') {
- if (line[linePos] == ' ' || line[linePos] == '\t') {
- if (output == NULL) {
- //ignore
- linePos += 1;
- continue;
- }
- }
- else {
- if (output == NULL) {
- output = key;
- }
- }
- if (line[linePos] == '=' || line[linePos] == ':' || line[linePos] == '#' || line[linePos] == '!') {
- if (precedingCharIsBackslash) {
- //escaped special character
- output[outputPos++] = line[linePos];
- updateBuffers(&key, &value, &output, outputPos, &key_len, &value_len);
- precedingCharIsBackslash = false;
- }
- else {
- if (line[linePos] == '#' || line[linePos] == '!') {
- if (outputPos == 0) {
- isComment = true;
- break;
- }
- else {
- output[outputPos++] = line[linePos];
- updateBuffers(&key, &value, &output, outputPos, &key_len, &value_len);
- }
- }
- else { // = or :
- if (output == value) { //already have a seperator
- output[outputPos++] = line[linePos];
- updateBuffers(&key, &value, &output, outputPos, &key_len, &value_len);
- }
- else {
- output[outputPos++] = '\0';
- updateBuffers(&key, &value, &output, outputPos, &key_len, &value_len);
- output = value;
- outputPos = 0;
- }
- }
- }
- }
- else if (line[linePos] == '\\') {
- if (precedingCharIsBackslash) { //double backslash -> backslash
- output[outputPos++] = '\\';
- updateBuffers(&key, &value, &output, outputPos, &key_len, &value_len);
- }
- precedingCharIsBackslash = true;
- }
- else { //normal character
- precedingCharIsBackslash = false;
- output[outputPos++] = line[linePos];
- updateBuffers(&key, &value, &output, outputPos, &key_len, &value_len);
- }
- linePos += 1;
- }
- if (output != NULL) {
- output[outputPos] = '\0';
- }
-
- if (!isComment) {
- //printf("putting 'key'/'value' '%s'/'%s' in properties\n", utils_stringTrim(key), utils_stringTrim(value));
- properties_set(props, utils_stringTrim(key), utils_stringTrim(value));
- }
- if(key) {
- free(key);
- }
- if(value) {
- free(value);
- }
-
-}
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/utils/private/src/thpool.c
----------------------------------------------------------------------
diff --git a/utils/private/src/thpool.c b/utils/private/src/thpool.c
deleted file mode 100644
index 5121fca..0000000
--- a/utils/private/src/thpool.c
+++ /dev/null
@@ -1,535 +0,0 @@
-/* ********************************
- * Author: Johan Hanssen Seferidis
- * License: MIT
- * Description: Library providing a threading pool where you can add
- * work. For usage, check the thpool.h file or README.md
- *
- *//** @file thpool.h *//*
- *
- ********************************/
-
-
-#include <unistd.h>
-#include <signal.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <pthread.h>
-#include <errno.h>
-#include <time.h>
-#include "thpool.h"
-
-#ifdef THPOOL_DEBUG
-#define THPOOL_DEBUG 1
-#else
-#define THPOOL_DEBUG 0
-#endif
-
-static volatile int threads_keepalive;
-static volatile int threads_on_hold;
-
-
-
-/* ========================== STRUCTURES ============================ */
-
-
-/* Binary semaphore */
-typedef struct bsem {
- pthread_mutex_t mutex;
- pthread_cond_t cond;
- int v;
-} bsem;
-
-
-/* Job */
-typedef struct job{
- struct job* prev; /* pointer to previous job */
- void* (*function)(void* arg); /* function pointer */
- void* arg; /* function's argument */
-} job;
-
-
-/* Job queue */
-typedef struct jobqueue{
- pthread_mutex_t rwmutex; /* used for queue r/w access */
- job *front; /* pointer to front of queue */
- job *rear; /* pointer to rear of queue */
- bsem *has_jobs; /* flag as binary semaphore */
- int len; /* number of jobs in queue */
-} jobqueue;
-
-
-/* Thread */
-typedef struct thread{
- int id; /* friendly id */
- pthread_t pthread; /* pointer to actual thread */
- struct thpool_* thpool_p; /* access to thpool */
-} thread;
-
-
-/* Threadpool */
-typedef struct thpool_{
- thread** threads; /* pointer to threads */
- volatile int num_threads_alive; /* threads currently alive */
- volatile int num_threads_working; /* threads currently working */
- pthread_mutex_t thcount_lock; /* used for thread count etc */
- pthread_cond_t threads_all_idle; /* signal to thpool_wait */
- jobqueue* jobqueue_p; /* pointer to the job queue */
-} thpool_;
-
-
-
-
-
-/* ========================== PROTOTYPES ============================ */
-
-
-static void thread_init(thpool_* thpool_p, struct thread** thread_p, int id);
-static void* thread_do(struct thread* thread_p);
-static void thread_hold();
-static void thread_destroy(struct thread* thread_p);
-
-static int jobqueue_init(thpool_* thpool_p);
-static void jobqueue_clear(thpool_* thpool_p);
-static void jobqueue_push(thpool_* thpool_p, struct job* newjob_p);
-static struct job* jobqueue_pull(thpool_* thpool_p);
-static void jobqueue_destroy(thpool_* thpool_p);
-
-static void bsem_init(struct bsem *bsem_p, int value);
-static void bsem_reset(struct bsem *bsem_p);
-static void bsem_post(struct bsem *bsem_p);
-static void bsem_post_all(struct bsem *bsem_p);
-static void bsem_wait(struct bsem *bsem_p);
-
-
-
-
-
-/* ========================== THREADPOOL ============================ */
-
-
-/* Initialise thread pool */
-struct thpool_* thpool_init(int num_threads){
-
- threads_on_hold = 0;
- threads_keepalive = 1;
-
- if ( num_threads < 0){
- num_threads = 0;
- }
-
- /* Make new thread pool */
- thpool_* thpool_p;
- thpool_p = (struct thpool_*)malloc(sizeof(struct thpool_));
- if (thpool_p == NULL){
- fprintf(stderr, "thpool_init(): Could not allocate memory for thread pool\n");
- return NULL;
- }
- thpool_p->num_threads_alive = 0;
- thpool_p->num_threads_working = 0;
-
- /* Initialise the job queue */
- if (jobqueue_init(thpool_p) == -1){
- fprintf(stderr, "thpool_init(): Could not allocate memory for job queue\n");
- free(thpool_p);
- return NULL;
- }
-
- /* Make threads in pool */
- thpool_p->threads = (struct thread**)malloc(num_threads * sizeof(struct thread*));
- if (thpool_p->threads == NULL){
- fprintf(stderr, "thpool_init(): Could not allocate memory for threads\n");
- jobqueue_destroy(thpool_p);
- free(thpool_p->jobqueue_p);
- free(thpool_p);
- return NULL;
- }
-
- pthread_mutex_init(&(thpool_p->thcount_lock), NULL);
- pthread_cond_init(&thpool_p->threads_all_idle, NULL);
-
- /* Thread init */
- int n;
- for (n=0; n<num_threads; n++){
- thread_init(thpool_p, &thpool_p->threads[n], n);
- if (THPOOL_DEBUG)
- printf("THPOOL_DEBUG: Created thread %d in pool \n", n);
- }
-
- /* Wait for threads to initialize */
- while (thpool_p->num_threads_alive != num_threads) {}
-
- return thpool_p;
-}
-
-
-/* Add work to the thread pool */
-int thpool_add_work(thpool_* thpool_p, void *(*function_p)(void*), void* arg_p){
- job* newjob;
-
- newjob=(struct job*)malloc(sizeof(struct job));
- if (newjob==NULL){
- fprintf(stderr, "thpool_add_work(): Could not allocate memory for new job\n");
- return -1;
- }
-
- /* add function and argument */
- newjob->function=function_p;
- newjob->arg=arg_p;
-
- /* add job to queue */
- pthread_mutex_lock(&thpool_p->jobqueue_p->rwmutex);
- jobqueue_push(thpool_p, newjob);
- pthread_mutex_unlock(&thpool_p->jobqueue_p->rwmutex);
-
- return 0;
-}
-
-
-/* Wait until all jobs have finished */
-void thpool_wait(thpool_* thpool_p){
- pthread_mutex_lock(&thpool_p->thcount_lock);
- while (thpool_p->jobqueue_p->len || thpool_p->num_threads_working) {
- pthread_cond_wait(&thpool_p->threads_all_idle, &thpool_p->thcount_lock);
- }
- pthread_mutex_unlock(&thpool_p->thcount_lock);
-}
-
-
-/* Destroy the threadpool */
-void thpool_destroy(thpool_* thpool_p){
-
- volatile int threads_total = thpool_p->num_threads_alive;
-
- /* End each thread 's infinite loop */
- threads_keepalive = 0;
-
- /* Give one second to kill idle threads */
- double TIMEOUT = 1.0;
- time_t start, end;
- double tpassed = 0.0;
- time (&start);
- while (tpassed < TIMEOUT && thpool_p->num_threads_alive){
- bsem_post_all(thpool_p->jobqueue_p->has_jobs);
- time (&end);
- tpassed = difftime(end,start);
- }
-
- /* Poll remaining threads */
- while (thpool_p->num_threads_alive){
- bsem_post_all(thpool_p->jobqueue_p->has_jobs);
- sleep(1);
- }
-
- /* Job queue cleanup */
- jobqueue_destroy(thpool_p);
- free(thpool_p->jobqueue_p);
-
- /* Deallocs */
- int n;
- for (n=0; n < threads_total; n++){
- thread_destroy(thpool_p->threads[n]);
- }
- free(thpool_p->threads);
- free(thpool_p);
-}
-
-
-/* Pause all threads in threadpool */
-void thpool_pause(thpool_* thpool_p) {
- int n;
- for (n=0; n < thpool_p->num_threads_alive; n++){
- pthread_kill(thpool_p->threads[n]->pthread, SIGUSR1);
- }
-}
-
-
-/* Resume all threads in threadpool */
-void thpool_resume(thpool_* thpool_p) {
- threads_on_hold = 0;
-}
-
-
-
-
-
-/* ============================ THREAD ============================== */
-
-
-/* Initialize a thread in the thread pool
- *
- * @param thread address to the pointer of the thread to be created
- * @param id id to be given to the thread
- *
- */
-static void thread_init (thpool_* thpool_p, struct thread** thread_p, int id){
-
- *thread_p = (struct thread*)malloc(sizeof(struct thread));
- if (*thread_p == NULL){
- fprintf(stderr, "thpool_init(): Could not allocate memory for thread\n");
- exit(1);
- }
-
- (*thread_p)->thpool_p = thpool_p;
- (*thread_p)->id = id;
-
- pthread_create(&(*thread_p)->pthread, NULL, (void *)thread_do, (*thread_p));
- pthread_detach((*thread_p)->pthread);
-
-}
-
-
-/* Sets the calling thread on hold */
-static void thread_hold () {
- threads_on_hold = 1;
- while (threads_on_hold){
- sleep(1);
- }
-}
-
-
-/* What each thread is doing
-*
-* In principle this is an endless loop. The only time this loop gets interuppted is once
-* thpool_destroy() is invoked or the program exits.
-*
-* @param thread thread that will run this function
-* @return nothing
-*/
-static void* thread_do(struct thread* thread_p){
-
- /* Set thread name for profiling and debuging */
- char thread_name[128] = {0};
- sprintf(thread_name, "thread-pool-%d", thread_p->id);
-
-#if defined(__linux__)
- pthread_setname_np(thread_p->pthread, thread_name);
-#elif defined(__APPLE__) && defined(__MACH__)
- pthread_setname_np(thread_name);
-#else
- fprintf(stderr, "thread_do(): pthread_setname_np is not supported on this system");
-#endif
-
- /* Assure all threads have been created before starting serving */
- thpool_* thpool_p = thread_p->thpool_p;
-
- /* Register signal handler */
- struct sigaction act;
- sigemptyset(&act.sa_mask);
- act.sa_flags = 0;
- act.sa_handler = thread_hold;
- if (sigaction(SIGUSR1, &act, NULL) == -1) {
- fprintf(stderr, "thread_do(): cannot handle SIGUSR1");
- }
-
- /* Mark thread as alive (initialized) */
- pthread_mutex_lock(&thpool_p->thcount_lock);
- thpool_p->num_threads_alive += 1;
- pthread_mutex_unlock(&thpool_p->thcount_lock);
-
- while(threads_keepalive){
-
- bsem_wait(thpool_p->jobqueue_p->has_jobs);
-
- if (threads_keepalive){
-
- pthread_mutex_lock(&thpool_p->thcount_lock);
- thpool_p->num_threads_working++;
- pthread_mutex_unlock(&thpool_p->thcount_lock);
-
- /* Read job from queue and execute it */
- void*(*func_buff)(void* arg);
- void* arg_buff;
- job* job_p;
- pthread_mutex_lock(&thpool_p->jobqueue_p->rwmutex);
- job_p = jobqueue_pull(thpool_p);
- pthread_mutex_unlock(&thpool_p->jobqueue_p->rwmutex);
- if (job_p) {
- func_buff = job_p->function;
- arg_buff = job_p->arg;
- func_buff(arg_buff);
- free(job_p);
- }
-
- pthread_mutex_lock(&thpool_p->thcount_lock);
- thpool_p->num_threads_working--;
- if (!thpool_p->num_threads_working) {
- pthread_cond_signal(&thpool_p->threads_all_idle);
- }
- pthread_mutex_unlock(&thpool_p->thcount_lock);
-
- }
- }
- pthread_mutex_lock(&thpool_p->thcount_lock);
- thpool_p->num_threads_alive --;
- pthread_mutex_unlock(&thpool_p->thcount_lock);
-
- return NULL;
-}
-
-
-/* Frees a thread */
-static void thread_destroy (thread* thread_p){
- free(thread_p);
-}
-
-
-
-
-
-/* ============================ JOB QUEUE =========================== */
-
-
-/* Initialize queue */
-static int jobqueue_init(thpool_* thpool_p){
-
- thpool_p->jobqueue_p = (struct jobqueue*)malloc(sizeof(struct jobqueue));
- if (thpool_p->jobqueue_p == NULL){
- return -1;
- }
- thpool_p->jobqueue_p->len = 0;
- thpool_p->jobqueue_p->front = NULL;
- thpool_p->jobqueue_p->rear = NULL;
-
- thpool_p->jobqueue_p->has_jobs = (struct bsem*)malloc(sizeof(struct bsem));
- if (thpool_p->jobqueue_p->has_jobs == NULL){
- return -1;
- }
-
- pthread_mutex_init(&(thpool_p->jobqueue_p->rwmutex), NULL);
- bsem_init(thpool_p->jobqueue_p->has_jobs, 0);
-
- return 0;
-}
-
-
-/* Clear the queue */
-static void jobqueue_clear(thpool_* thpool_p){
-
- while(thpool_p->jobqueue_p->len){
- free(jobqueue_pull(thpool_p));
- }
-
- thpool_p->jobqueue_p->front = NULL;
- thpool_p->jobqueue_p->rear = NULL;
- bsem_reset(thpool_p->jobqueue_p->has_jobs);
- thpool_p->jobqueue_p->len = 0;
-
-}
-
-
-/* Add (allocated) job to queue
- *
- * Notice: Caller MUST hold a mutex
- */
-static void jobqueue_push(thpool_* thpool_p, struct job* newjob){
-
- newjob->prev = NULL;
-
- switch(thpool_p->jobqueue_p->len){
-
- case 0: /* if no jobs in queue */
- thpool_p->jobqueue_p->front = newjob;
- thpool_p->jobqueue_p->rear = newjob;
- break;
-
- default: /* if jobs in queue */
- thpool_p->jobqueue_p->rear->prev = newjob;
- thpool_p->jobqueue_p->rear = newjob;
-
- }
- thpool_p->jobqueue_p->len++;
-
- bsem_post(thpool_p->jobqueue_p->has_jobs);
-}
-
-
-/* Get first job from queue(removes it from queue)
- *
- * Notice: Caller MUST hold a mutex
- */
-static struct job* jobqueue_pull(thpool_* thpool_p){
-
- job* job_p;
- job_p = thpool_p->jobqueue_p->front;
-
- switch(thpool_p->jobqueue_p->len){
-
- case 0: /* if no jobs in queue */
- break;
-
- case 1: /* if one job in queue */
- thpool_p->jobqueue_p->front = NULL;
- thpool_p->jobqueue_p->rear = NULL;
- thpool_p->jobqueue_p->len = 0;
- break;
-
- default: /* if >1 jobs in queue */
- thpool_p->jobqueue_p->front = job_p->prev;
- thpool_p->jobqueue_p->len--;
- /* more than one job in queue -> post it */
- bsem_post(thpool_p->jobqueue_p->has_jobs);
-
- }
-
- return job_p;
-}
-
-
-/* Free all queue resources back to the system */
-static void jobqueue_destroy(thpool_* thpool_p){
- jobqueue_clear(thpool_p);
- free(thpool_p->jobqueue_p->has_jobs);
-}
-
-
-
-
-
-/* ======================== SYNCHRONISATION ========================= */
-
-
-/* Init semaphore to 1 or 0 */
-static void bsem_init(bsem *bsem_p, int value) {
- if (value < 0 || value > 1) {
- fprintf(stderr, "bsem_init(): Binary semaphore can take only values 1 or 0");
- exit(1);
- }
- pthread_mutex_init(&(bsem_p->mutex), NULL);
- pthread_cond_init(&(bsem_p->cond), NULL);
- bsem_p->v = value;
-}
-
-
-/* Reset semaphore to 0 */
-static void bsem_reset(bsem *bsem_p) {
- bsem_init(bsem_p, 0);
-}
-
-
-/* Post to at least one thread */
-static void bsem_post(bsem *bsem_p) {
- pthread_mutex_lock(&bsem_p->mutex);
- bsem_p->v = 1;
- pthread_cond_signal(&bsem_p->cond);
- pthread_mutex_unlock(&bsem_p->mutex);
-}
-
-
-/* Post to all threads */
-static void bsem_post_all(bsem *bsem_p) {
- pthread_mutex_lock(&bsem_p->mutex);
- bsem_p->v = 1;
- pthread_cond_broadcast(&bsem_p->cond);
- pthread_mutex_unlock(&bsem_p->mutex);
-}
-
-
-/* Wait on semaphore until semaphore has value 0 */
-static void bsem_wait(bsem* bsem_p) {
- pthread_mutex_lock(&bsem_p->mutex);
- while (bsem_p->v != 1) {
- pthread_cond_wait(&bsem_p->cond, &bsem_p->mutex);
- }
- bsem_p->v = 0;
- pthread_mutex_unlock(&bsem_p->mutex);
-}
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/utils/private/src/utils.c
----------------------------------------------------------------------
diff --git a/utils/private/src/utils.c b/utils/private/src/utils.c
deleted file mode 100644
index fc4d538..0000000
--- a/utils/private/src/utils.c
+++ /dev/null
@@ -1,141 +0,0 @@
-/**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements. See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership. The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- *specific language governing permissions and limitations
- *under the License.
- */
-/*
- * utils.c
- *
- * \date Jul 27, 2010
- * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- * \copyright Apache License, Version 2.0
- */
-#include <stdlib.h>
-#include <string.h>
-
-#include "utils.h"
-
-unsigned int utils_stringHash(const void* strPtr) {
- const char* string = strPtr;
- unsigned int hc = 5381;
- char ch;
- while((ch = *string++) != '\0'){
- hc = (hc << 5) + hc + ch;
- }
-
- return hc;
-}
-
-int utils_stringEquals(const void* string, const void* toCompare) {
- return strcmp((const char*)string, (const char*)toCompare) == 0;
-}
-
-char * string_ndup(const char *s, size_t n) {
- size_t len = strlen(s);
- char *ret;
-
- if (len <= n) {
- return strdup(s);
- }
-
- ret = malloc(n + 1);
- strncpy(ret, s, n);
- ret[n] = '\0';
- return ret;
-}
-
-char * utils_stringTrim(char * string) {
- char* copy = string;
-
- char *end;
- // Trim leading space
- while (isspace(*copy)) {
- copy++;
- }
-
- // Trim trailing space
- end = copy + strlen(copy) - 1;
- while(end > copy && isspace(*end)) {
- *(end) = '\0';
- end--;
- }
-
- if (copy != string) {
- //beginning whitespaces -> move char in copy to to begin string
- //This to ensure free still works on the same pointer.
- char* nstring = string;
- while(*copy != '\0') {
- *(nstring++) = *(copy++);
- }
- (*nstring) = '\0';
- }
-
- return string;
-}
-
-bool utils_isStringEmptyOrNull(const char * const str) {
- bool empty = true;
- if (str != NULL) {
- int i;
- for (i = 0; i < strnlen(str, 1024 * 1024); i += 1) {
- if (!isspace(str[i])) {
- empty = false;
- break;
- }
- }
- }
-
- return empty;
-}
-
-celix_status_t thread_equalsSelf(celix_thread_t thread, bool *equals) {
- celix_status_t status = CELIX_SUCCESS;
-
- celix_thread_t self = celixThread_self();
- if (status == CELIX_SUCCESS) {
- *equals = celixThread_equals(self, thread);
- }
-
- return status;
-}
-
-celix_status_t utils_isNumeric(const char *number, bool *ret) {
- celix_status_t status = CELIX_SUCCESS;
- *ret = true;
- while(*number) {
- if(!isdigit(*number) && *number != '.') {
- *ret = false;
- break;
- }
- number++;
- }
- return status;
-}
-
-
-int utils_compareServiceIdsAndRanking(unsigned long servId, long servRank, unsigned long otherServId, long otherServRank) {
- int result;
-
- if (servId == otherServId) {
- result = 0;
- } else if (servRank != otherServRank) {
- result = servRank < otherServRank ? -1 : 1;
- } else { //equal service rank, compare service ids
- result = servId < otherServId ? 1 : -1;
- }
-
- return result;
-}
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/utils/private/src/version.c
----------------------------------------------------------------------
diff --git a/utils/private/src/version.c b/utils/private/src/version.c
deleted file mode 100644
index cb2703d..0000000
--- a/utils/private/src/version.c
+++ /dev/null
@@ -1,264 +0,0 @@
-/**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements. See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership. The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- *specific language governing permissions and limitations
- *under the License.
- */
-/*
- * version.c
- *
- * \date Jul 12, 2010
- * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- * \copyright Apache License, Version 2.0
- */
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-#include "celix_errno.h"
-#include "version_private.h"
-
-celix_status_t version_createVersion(int major, int minor, int micro, char * qualifier, version_pt *version) {
- celix_status_t status = CELIX_SUCCESS;
-
- if (*version != NULL) {
- status = CELIX_ILLEGAL_ARGUMENT;
- } else {
- *version = (version_pt) malloc(sizeof(**version));
- if (!*version) {
- status = CELIX_ENOMEM;
- } else {
- unsigned int i;
-
- (*version)->major = major;
- (*version)->minor = minor;
- (*version)->micro = micro;
- if (qualifier == NULL) {
- qualifier = "";
- }
- (*version)->qualifier = strdup(qualifier);
-
- if (major < 0) {
- status = CELIX_ILLEGAL_ARGUMENT;
- }
- if (minor < 0) {
- status = CELIX_ILLEGAL_ARGUMENT;
- }
- if (micro < 0) {
- status = CELIX_ILLEGAL_ARGUMENT;
- }
-
- for (i = 0; i < strlen(qualifier); i++) {
- char ch = qualifier[i];
- if (('A' <= ch) && (ch <= 'Z')) {
- continue;
- }
- if (('a' <= ch) && (ch <= 'z')) {
- continue;
- }
- if (('0' <= ch) && (ch <= '9')) {
- continue;
- }
- if ((ch == '_') || (ch == '-')) {
- continue;
- }
- status = CELIX_ILLEGAL_ARGUMENT;
- break;
- }
- }
- }
-
- return status;
-}
-
-celix_status_t version_clone(version_pt version, version_pt *clone) {
- return version_createVersion(version->major, version->minor, version->micro, version->qualifier, clone);
-}
-
-celix_status_t version_destroy(version_pt version) {
- version->major = 0;
- version->minor = 0;
- version->micro = 0;
- free(version->qualifier);
- version->qualifier = NULL;
- free(version);
- return CELIX_SUCCESS;
-}
-
-celix_status_t version_createVersionFromString(const char * versionStr, version_pt *version) {
- celix_status_t status = CELIX_SUCCESS;
-
- int major = 0;
- int minor = 0;
- int micro = 0;
- char * qualifier = NULL;
-
- char delims[] = ".";
- char *token = NULL;
- char *last = NULL;
-
- int i = 0;
-
- char* versionWrkStr = strdup(versionStr);
-
- token = strtok_r(versionWrkStr, delims, &last);
- if (token != NULL) {
- for (i = 0; i < strlen(token); i++) {
- char ch = token[i];
- if (('0' <= ch) && (ch <= '9')) {
- continue;
- }
- status = CELIX_ILLEGAL_ARGUMENT;
- break;
- }
- major = atoi(token);
- token = strtok_r(NULL, delims, &last);
- if (token != NULL) {
- for (i = 0; i < strlen(token); i++) {
- char ch = token[i];
- if (('0' <= ch) && (ch <= '9')) {
- continue;
- }
- status = CELIX_ILLEGAL_ARGUMENT;
- break;
- }
- minor = atoi(token);
- token = strtok_r(NULL, delims, &last);
- if (token != NULL) {
- for (i = 0; i < strlen(token); i++) {
- char ch = token[i];
- if (('0' <= ch) && (ch <= '9')) {
- continue;
- }
- status = CELIX_ILLEGAL_ARGUMENT;
- break;
- }
- micro = atoi(token);
- token = strtok_r(NULL, delims, &last);
- if (token != NULL) {
- qualifier = strdup(token);
- token = strtok_r(NULL, delims, &last);
- if (token != NULL) {
- *version = NULL;
- status = CELIX_ILLEGAL_ARGUMENT;
- }
- }
- }
- }
- }
-
- free(versionWrkStr);
-
- if (status == CELIX_SUCCESS) {
- status = version_createVersion(major, minor, micro, qualifier, version);
- }
-
- if (qualifier != NULL) {
- free(qualifier);
- }
-
- return status;
-}
-
-celix_status_t version_createEmptyVersion(version_pt *version) {
- return version_createVersion(0, 0, 0, "", version);
-}
-
-celix_status_t version_getMajor(version_pt version, int *major) {
- celix_status_t status = CELIX_SUCCESS;
- *major = version->major;
- return status;
-}
-
-celix_status_t version_getMinor(version_pt version, int *minor) {
- celix_status_t status = CELIX_SUCCESS;
- *minor = version->minor;
- return status;
-}
-
-celix_status_t version_getMicro(version_pt version, int *micro) {
- celix_status_t status = CELIX_SUCCESS;
- *micro = version->micro;
- return status;
-}
-
-celix_status_t version_getQualifier(version_pt version, const char **qualifier) {
- celix_status_t status = CELIX_SUCCESS;
- *qualifier = version->qualifier;
- return status;
-}
-
-celix_status_t version_compareTo(version_pt version, version_pt compare, int *result) {
- celix_status_t status = CELIX_SUCCESS;
- if (compare == version) {
- *result = 0;
- } else {
- int res = version->major - compare->major;
- if (res != 0) {
- *result = res;
- } else {
- res = version->minor - compare->minor;
- if (res != 0) {
- *result = res;
- } else {
- res = version->micro - compare->micro;
- if (res != 0) {
- *result = res;
- } else {
- *result = strcmp(version->qualifier, compare->qualifier);
- }
- }
- }
- }
-
- return status;
-}
-
-celix_status_t version_toString(version_pt version, char **string) {
- celix_status_t status = CELIX_SUCCESS;
- if (strlen(version->qualifier) > 0) {
- char str[512];
- int written = snprintf(str, 512, "%d.%d.%d.%s", version->major, version->minor, version->micro, version->qualifier);
- if (written >= 512 || written < 0) {
- status = CELIX_BUNDLE_EXCEPTION;
- }
- *string = strdup(str);
- } else {
- char str[512];
- int written = snprintf(str, 512, "%d.%d.%d", version->major, version->minor, version->micro);
- if (written >= 512 || written < 0) {
- status = CELIX_BUNDLE_EXCEPTION;
- }
- *string = strdup(str);
- }
- return status;
-}
-
-celix_status_t version_isCompatible(version_pt user, version_pt provider, bool* isCompatible) {
- celix_status_t status = CELIX_SUCCESS;
- bool result = false;
-
- if (user == NULL || provider == NULL) {
- return CELIX_ILLEGAL_ARGUMENT;
- }
-
- if (user->major == provider->major) {
- result = (provider->minor >= user->minor);
- }
-
- *isCompatible = result;
-
- return status;
-}
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/utils/private/src/version_range.c
----------------------------------------------------------------------
diff --git a/utils/private/src/version_range.c b/utils/private/src/version_range.c
deleted file mode 100644
index ed681fd..0000000
--- a/utils/private/src/version_range.c
+++ /dev/null
@@ -1,233 +0,0 @@
-/**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements. See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership. The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- *specific language governing permissions and limitations
- *under the License.
- */
-/*
- * version_range.c
- *
- * \date Jul 12, 2010
- * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- * \copyright Apache License, Version 2.0
- */
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "version_range_private.h"
-
-celix_status_t versionRange_createVersionRange(version_pt low, bool isLowInclusive,
- version_pt high, bool isHighInclusive, version_range_pt *range) {
- celix_status_t status = CELIX_SUCCESS;
- *range = (version_range_pt) malloc(sizeof(**range));
- if (!*range) {
- status = CELIX_ENOMEM;
- } else {
- (*range)->low = low;
- (*range)->isLowInclusive = isLowInclusive;
- (*range)->high = high;
- (*range)->isHighInclusive = isHighInclusive;
- }
-
- return status;
-}
-
-celix_status_t versionRange_destroy(version_range_pt range) {
- if (range->high != NULL) {
- version_destroy(range->high);
- }
- if (range->low != NULL) {
- version_destroy(range->low);
- }
-
- range->high = NULL;
- range->isHighInclusive = false;
- range->low = NULL;
- range->isLowInclusive = false;
-
- free(range);
-
- return CELIX_SUCCESS;
-}
-
-celix_status_t versionRange_createInfiniteVersionRange(version_range_pt *range) {
- celix_status_t status;
-
- version_pt version = NULL;
- status = version_createEmptyVersion(&version);
- if (status == CELIX_SUCCESS) {
- status = versionRange_createVersionRange(version, true, NULL, true, range);
- }
-
- return status;
-}
-
-celix_status_t versionRange_isInRange(version_range_pt versionRange, version_pt version, bool *inRange) {
- celix_status_t status;
- if (versionRange->high == NULL) {
- int cmp;
- status = version_compareTo(version, versionRange->low, &cmp);
- if (status == CELIX_SUCCESS) {
- *inRange = (cmp >= 0);
- }
- } else if (versionRange->isLowInclusive && versionRange->isHighInclusive) {
- int low, high;
- status = version_compareTo(version, versionRange->low, &low);
- if (status == CELIX_SUCCESS) {
- status = version_compareTo(version, versionRange->high, &high);
- if (status == CELIX_SUCCESS) {
- *inRange = (low >= 0) && (high <= 0);
- }
- }
- } else if (versionRange->isHighInclusive) {
- int low, high;
- status = version_compareTo(version, versionRange->low, &low);
- if (status == CELIX_SUCCESS) {
- status = version_compareTo(version, versionRange->high, &high);
- if (status == CELIX_SUCCESS) {
- *inRange = (low > 0) && (high <= 0);
- }
- }
- } else if (versionRange->isLowInclusive) {
- int low, high;
- status = version_compareTo(version, versionRange->low, &low);
- if (status == CELIX_SUCCESS) {
- status = version_compareTo(version, versionRange->high, &high);
- if (status == CELIX_SUCCESS) {
- *inRange = (low >= 0) && (high < 0);
- }
- }
- } else {
- int low, high;
- status = version_compareTo(version, versionRange->low, &low);
- if (status == CELIX_SUCCESS) {
- status = version_compareTo(version, versionRange->high, &high);
- if (status == CELIX_SUCCESS) {
- *inRange = (low > 0) && (high < 0);
- }
- }
- }
-
- return status;
-}
-
-celix_status_t versionRange_getLowVersion(version_range_pt versionRange, version_pt *lowVersion) {
- celix_status_t status = CELIX_SUCCESS;
-
- if (versionRange == NULL) {
- status = CELIX_ILLEGAL_ARGUMENT;
- }
- else {
- *lowVersion = versionRange->low;
- }
-
- return status;
-}
-
-celix_status_t versionRange_isLowInclusive(version_range_pt versionRange, bool *isLowInclusive) {
- celix_status_t status = CELIX_SUCCESS;
-
- if (versionRange == NULL) {
- status = CELIX_ILLEGAL_ARGUMENT;
- }
- else {
- *isLowInclusive = versionRange->isLowInclusive;
- }
-
- return status;
-}
-
-celix_status_t versionRange_getHighVersion(version_range_pt versionRange, version_pt *highVersion) {
- celix_status_t status = CELIX_SUCCESS;
-
- if (versionRange == NULL) {
- status = CELIX_ILLEGAL_ARGUMENT;
- }
- else {
- *highVersion = versionRange->high;
- }
-
- return status;
-}
-
-celix_status_t versionRange_isHighInclusive(version_range_pt versionRange, bool *isHighInclusive) {
- celix_status_t status = CELIX_SUCCESS;
-
- if (versionRange == NULL) {
- status = CELIX_ILLEGAL_ARGUMENT;
- }
- else {
- *isHighInclusive = versionRange->isHighInclusive;
- }
-
- return status;
-}
-
-
-celix_status_t versionRange_parse(const char * rangeStr, version_range_pt *range) {
- celix_status_t status;
- if (strchr(rangeStr, ',') != NULL) {
- int vlowL = strcspn(rangeStr+1, ",");
- char * vlow = (char *) malloc(sizeof(char) * (vlowL + 1));
- if (!vlow) {
- status = CELIX_ENOMEM;
- } else {
- int vhighL;
- char * vhigh;
- vlow = strncpy(vlow, rangeStr+1, vlowL);
- vlow[vlowL] = '\0';
- vhighL = strlen(rangeStr+1) - vlowL - 2;
- vhigh = (char *) malloc(sizeof(char) * (vhighL+1));
- if (!vhigh) {
- status = CELIX_ENOMEM;
- } else {
- version_pt versionLow = NULL;
- int rangeL = strlen(rangeStr);
- char start = rangeStr[0];
- char end = rangeStr[rangeL-1];
-
- vhigh = strncpy(vhigh, rangeStr+vlowL+2, vhighL);
- vhigh[vhighL] = '\0';
- status = version_createVersionFromString(vlow, &versionLow);
- if (status == CELIX_SUCCESS) {
- version_pt versionHigh = NULL;
- status = version_createVersionFromString(vhigh, &versionHigh);
- if (status == CELIX_SUCCESS) {
- status = versionRange_createVersionRange(
- versionLow,
- start == '[',
- versionHigh,
- end ==']',
- range
- );
- }
- }
- free(vhigh);
- }
- free(vlow);
-
- }
- } else {
- version_pt version = NULL;
- status = version_createVersionFromString(rangeStr, &version);
- if (status == CELIX_SUCCESS) {
- status = versionRange_createVersionRange(version, true, NULL, false, range);
- }
- }
-
- return status;
-}
-
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/utils/public/include/array_list.h
----------------------------------------------------------------------
diff --git a/utils/public/include/array_list.h b/utils/public/include/array_list.h
deleted file mode 100644
index 4f83a45..0000000
--- a/utils/public/include/array_list.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements. See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership. The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- *specific language governing permissions and limitations
- *under the License.
- */
-/*
- * array_list.h
- *
- * \date Aug 4, 2010
- * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- * \copyright Apache License, Version 2.0
- */
-
-#ifndef ARRAY_LIST_H_
-#define ARRAY_LIST_H_
-
-#include "celixbool.h"
-#include "exports.h"
-#include "celix_errno.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct arrayList *array_list_pt;
-
-typedef struct arrayListIterator *array_list_iterator_pt;
-
-typedef celix_status_t (*array_list_element_equals_pt)(const void *, const void *, bool *equals);
-
-UTILS_EXPORT celix_status_t arrayList_create(array_list_pt *list);
-
-UTILS_EXPORT celix_status_t arrayList_createWithEquals(array_list_element_equals_pt equals, array_list_pt *list);
-
-UTILS_EXPORT void arrayList_destroy(array_list_pt list);
-
-UTILS_EXPORT void arrayList_trimToSize(array_list_pt list);
-
-UTILS_EXPORT void arrayList_ensureCapacity(array_list_pt list, int capacity);
-
-UTILS_EXPORT unsigned int arrayList_size(array_list_pt list);
-
-UTILS_EXPORT bool arrayList_isEmpty(array_list_pt list);
-
-UTILS_EXPORT bool arrayList_contains(array_list_pt list, void *element);
-
-UTILS_EXPORT int arrayList_indexOf(array_list_pt list, void *element);
-
-UTILS_EXPORT int arrayList_lastIndexOf(array_list_pt list, void *element);
-
-UTILS_EXPORT void *arrayList_get(array_list_pt list, unsigned int index);
-
-UTILS_EXPORT void *arrayList_set(array_list_pt list, unsigned int index, void *element);
-
-UTILS_EXPORT bool arrayList_add(array_list_pt list, void *element);
-
-UTILS_EXPORT int arrayList_addIndex(array_list_pt list, unsigned int index, void *element);
-
-UTILS_EXPORT bool arrayList_addAll(array_list_pt list, array_list_pt toAdd);
-
-UTILS_EXPORT void *arrayList_remove(array_list_pt list, unsigned int index);
-
-UTILS_EXPORT bool arrayList_removeElement(array_list_pt list, void *element);
-
-UTILS_EXPORT void arrayList_clear(array_list_pt list);
-
-UTILS_EXPORT array_list_pt arrayList_clone(array_list_pt list);
-
-UTILS_EXPORT array_list_iterator_pt arrayListIterator_create(array_list_pt list);
-
-UTILS_EXPORT void arrayListIterator_destroy(array_list_iterator_pt iterator);
-
-UTILS_EXPORT bool arrayListIterator_hasNext(array_list_iterator_pt iterator);
-
-UTILS_EXPORT void *arrayListIterator_next(array_list_iterator_pt iterator);
-
-UTILS_EXPORT bool arrayListIterator_hasPrevious(array_list_iterator_pt iterator);
-
-UTILS_EXPORT void *arrayListIterator_previous(array_list_iterator_pt iterator);
-
-UTILS_EXPORT void arrayListIterator_remove(array_list_iterator_pt iterator);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* ARRAY_LIST_H_ */
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/utils/public/include/celix_errno.h
----------------------------------------------------------------------
diff --git a/utils/public/include/celix_errno.h b/utils/public/include/celix_errno.h
deleted file mode 100644
index b51540b..0000000
--- a/utils/public/include/celix_errno.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements. See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership. The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- *specific language governing permissions and limitations
- *under the License.
- */
-/*
- * celix_errno.h
- *
- * \date Feb 15, 2011
- * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- * \copyright Apache License, Version 2.0
- */
-/*!
- \file
- \brief Error codes
- \defgroup framework Celix Framework
- */
-#ifndef CELIX_ERRNO_H_
-#define CELIX_ERRNO_H_
-
-#include <stddef.h>
-#include <errno.h>
-
-#include "exports.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*!
- * Helper macro which check the current status and executes the provided expression if the
- * status is still CELIX_SUCCESS (0)
- */
-#define CELIX_DO_IF(status, expr) ((status) == CELIX_SUCCESS) ? (expr) : (status)
-
-/*!
- * \defgroup celix_errno Error Codes
- * \ingroup framework
- * \{
- */
-
-struct celix_status {
- int code;
- char *error;
-};
-
-/*!
- * Status type returned by all functions in Celix
- */
-typedef int celix_status_t;
-
-/*!
- * Return a readable string for the given error code.
- *
- */
-UTILS_EXPORT char *celix_strerror(celix_status_t errorcode, char *buffer, size_t bufferSize);
-
-/*!
- * Error code indicating successful execution of the function.
- */
-#define CELIX_SUCCESS 0
-
-/*!
- * Starting point for Celix errors.
- */
-#define CELIX_START_ERROR 70000
-
-/*!
- * The range for Celix errors.
- */
-#define CELIX_ERRSPACE_SIZE 1000
-
-/*!
- * The start error number user application can use.
- */
-#define CELIX_START_USERERR (CELIX_START_ERROR + CELIX_ERRSPACE_SIZE)
-
-/*!
- * Exception indicating a problem with a bundle
- */
-#define CELIX_BUNDLE_EXCEPTION (CELIX_START_ERROR + 1)
-/*!
- * Invalid bundle context is used
- */
-#define CELIX_INVALID_BUNDLE_CONTEXT (CELIX_START_ERROR + 2)
-/*!
- * Argument is not correct
- */
-#define CELIX_ILLEGAL_ARGUMENT (CELIX_START_ERROR + 3)
-#define CELIX_INVALID_SYNTAX (CELIX_START_ERROR + 4)
-#define CELIX_FRAMEWORK_SHUTDOWN (CELIX_START_ERROR + 5)
-#define CELIX_ILLEGAL_STATE (CELIX_START_ERROR + 6)
-#define CELIX_FRAMEWORK_EXCEPTION (CELIX_START_ERROR + 7)
-#define CELIX_FILE_IO_EXCEPTION (CELIX_START_ERROR + 8)
-#define CELIX_SERVICE_EXCEPTION (CELIX_START_ERROR + 9)
-
-#define CELIX_ENOMEM ENOMEM
-
-/**
- * \}
- */
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* CELIX_ERRNO_H_ */
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/utils/public/include/celix_threads.h
----------------------------------------------------------------------
diff --git a/utils/public/include/celix_threads.h b/utils/public/include/celix_threads.h
deleted file mode 100644
index 6af57bb..0000000
--- a/utils/public/include/celix_threads.h
+++ /dev/null
@@ -1,135 +0,0 @@
-/**
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements. See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership. The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- *specific language governing permissions and limitations
- *under the License.
- */
-/*
- * celix_threads.h
- *
- * \date 4 Jun 2014
- * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- * \copyright Apache License, Version 2.0
- */
-
-#ifndef CELIX_THREADS_H_
-#define CELIX_THREADS_H_
-
-#include <pthread.h>
-#include <stdbool.h>
-
-#include "celix_errno.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct celix_thread {
- bool threadInitialized;
- pthread_t thread;
-};
-
-typedef pthread_once_t celix_thread_once_t;
-#define CELIX_THREAD_ONCE_INIT PTHREAD_ONCE_INIT
-
-typedef struct celix_thread celix_thread_t;
-typedef pthread_attr_t celix_thread_attr_t;
-
-typedef void *(*celix_thread_start_t)(void *);
-
-static const celix_thread_t celix_thread_default = {0, 0};
-
-celix_status_t
-celixThread_create(celix_thread_t *new_thread, celix_thread_attr_t *attr, celix_thread_start_t func, void *data);
-
-void celixThread_exit(void *exitStatus);
-
-celix_status_t celixThread_detach(celix_thread_t thread);
-
-celix_status_t celixThread_join(celix_thread_t thread, void **status);
-
-celix_status_t celixThread_kill(celix_thread_t thread, int sig);
-
-celix_thread_t celixThread_self(void);
-
-int celixThread_equals(celix_thread_t thread1, celix_thread_t thread2);
-
-bool celixThread_initalized(celix_thread_t thread);
-
-
-typedef pthread_mutex_t celix_thread_mutex_t;
-typedef pthread_mutexattr_t celix_thread_mutexattr_t;
-
-//MUTEX TYPES
-enum {
- CELIX_THREAD_MUTEX_NORMAL,
- CELIX_THREAD_MUTEX_RECURSIVE,
- CELIX_THREAD_MUTEX_ERRORCHECK,
- CELIX_THREAD_MUTEX_DEFAULT
-};
-
-
-celix_status_t celixThreadMutex_create(celix_thread_mutex_t *mutex, celix_thread_mutexattr_t *attr);
-
-celix_status_t celixThreadMutex_destroy(celix_thread_mutex_t *mutex);
-
-celix_status_t celixThreadMutex_lock(celix_thread_mutex_t *mutex);
-
-celix_status_t celixThreadMutex_unlock(celix_thread_mutex_t *mutex);
-
-celix_status_t celixThreadMutexAttr_create(celix_thread_mutexattr_t *attr);
-
-celix_status_t celixThreadMutexAttr_destroy(celix_thread_mutexattr_t *attr);
-
-celix_status_t celixThreadMutexAttr_settype(celix_thread_mutexattr_t *attr, int type);
-
-typedef pthread_rwlock_t celix_thread_rwlock_t;
-typedef pthread_rwlockattr_t celix_thread_rwlockattr_t;
-
-celix_status_t celixThreadRwlock_create(celix_thread_rwlock_t *lock, celix_thread_rwlockattr_t *attr);
-
-celix_status_t celixThreadRwlock_destroy(celix_thread_rwlock_t *lock);
-
-celix_status_t celixThreadRwlock_readLock(celix_thread_rwlock_t *lock);
-
-celix_status_t celixThreadRwlock_writeLock(celix_thread_rwlock_t *lock);
-
-celix_status_t celixThreadRwlock_unlock(celix_thread_rwlock_t *lock);
-
-celix_status_t celixThreadRwlockAttr_create(celix_thread_rwlockattr_t *attr);
-
-celix_status_t celixThreadRwlockAttr_destroy(celix_thread_rwlockattr_t *attr);
-//NOTE: No support yet for setting specific rw lock attributes
-
-
-typedef pthread_cond_t celix_thread_cond_t;
-typedef pthread_condattr_t celix_thread_condattr_t;
-
-celix_status_t celixThreadCondition_init(celix_thread_cond_t *condition, celix_thread_condattr_t *attr);
-
-celix_status_t celixThreadCondition_destroy(celix_thread_cond_t *condition);
-
-celix_status_t celixThreadCondition_wait(celix_thread_cond_t *cond, celix_thread_mutex_t *mutex);
-
-celix_status_t celixThreadCondition_broadcast(celix_thread_cond_t *cond);
-
-celix_status_t celixThreadCondition_signal(celix_thread_cond_t *cond);
-
-celix_status_t celixThread_once(celix_thread_once_t *once_control, void (*init_routine)(void));
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* CELIX_THREADS_H_ */
http://git-wip-us.apache.org/repos/asf/celix/blob/a1c30887/utils/public/include/celixbool.h
----------------------------------------------------------------------
diff --git a/utils/public/include/celixbool.h b/utils/public/include/celixbool.h
deleted file mode 100644
index 526392b..0000000
--- a/utils/public/include/celixbool.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- *Licensed to the Apache Software Foundation (ASF) under one
- *or more contributor license agreements. See the NOTICE file
- *distributed with this work for additional information
- *regarding copyright ownership. The ASF licenses this file
- *to you under the Apache License, Version 2.0 (the
- *"License"); you may not use this file except in compliance
- *with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- *Unless required by applicable law or agreed to in writing,
- *software distributed under the License is distributed on an
- *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- *specific language governing permissions and limitations
- *under the License.
- */
-/*
- * celixbool.h
- *
- * \date Jun 16, 2011
- * \author <a href="mailto:dev@celix.apache.org">Apache Celix Project Team</a>
- * \copyright Apache License, Version 2.0
- */
-
-#ifndef CELIXBOOL_H_
-#define CELIXBOOL_H_
-
-
-#if defined(__STDC__)
-# define C89
-# if defined(__STDC_VERSION__)
-# define C90
-# if (__STDC_VERSION__ >= 199409L)
-# define C94
-# endif
-# if (__STDC_VERSION__ >= 199901L)
-# define C99
-# endif
-# endif
-#endif
-
-
-#if __STDC_VERSION__ < 199901L && __GNUC__ < 3
-// #ifndef C99
-
-typedef int _Bool;
-
-#define bool _Bool
-#define false 0
-#define true 1
-
-
-#else
-
-#include <stdbool.h>
-
-#endif
-
-#endif /* CELIXBOOL_H_ */