appwrite-cli 0.14.0

package/ldid/libplist/src/bytearray.c

@@ -0,0 +1,61 @@
+/*
+ * bytearray.c
+ * simple byte array implementation
+ *
+ * Copyright (c) 2011 Nikias Bassen, All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include <string.h>
+#include "bytearray.h"
+
+#define PAGE_SIZE 4096
+
+bytearray_t *byte_array_new(size_t initial)
+{
+	bytearray_t *a = (bytearray_t*)malloc(sizeof(bytearray_t));
+	a->capacity = (initial > PAGE_SIZE) ? (initial+(PAGE_SIZE-1)) & (~(PAGE_SIZE-1)) : PAGE_SIZE;
+	a->data = malloc(a->capacity);
+	a->len = 0;
+	return a;
+}
+
+void byte_array_free(bytearray_t *ba)
+{
+	if (!ba) return;
+	if (ba->data) {
+		free(ba->data);
+	}
+	free(ba);
+}
+
+void byte_array_grow(bytearray_t *ba, size_t amount)
+{
+	size_t increase = (amount > PAGE_SIZE) ? (amount+(PAGE_SIZE-1)) & (~(PAGE_SIZE-1)) : PAGE_SIZE;
+	ba->data = realloc(ba->data, ba->capacity + increase);
+	ba->capacity += increase;
+}
+
+void byte_array_append(bytearray_t *ba, void *buf, size_t len)
+{
+	if (!ba || !ba->data || (len <= 0)) return;
+	size_t remaining = ba->capacity-ba->len;
+	if (len > remaining) {
+		size_t needed = len - remaining;
+		byte_array_grow(ba, needed);
+	}
+	memcpy(((char*)ba->data) + ba->len, buf, len);
+	ba->len += len;
+}

package/ldid/libplist/src/bytearray.h

@@ -0,0 +1,36 @@
+/*
+ * bytearray.h
+ * header file for simple byte array implementation
+ *
+ * Copyright (c) 2011 Nikias Bassen, All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef BYTEARRAY_H
+#define BYTEARRAY_H
+#include <stdlib.h>
+
+typedef struct bytearray_t {
+	void *data;
+	size_t len;
+	size_t capacity;
+} bytearray_t;
+
+bytearray_t *byte_array_new(size_t initial);
+void byte_array_free(bytearray_t *ba);
+void byte_array_grow(bytearray_t *ba, size_t amount);
+void byte_array_append(bytearray_t *ba, void *buf, size_t len);
+
+#endif

package/ldid/libplist/src/hashtable.c

@@ -0,0 +1,140 @@
+/*
+ * hashtable.c
+ * really simple hash table implementation
+ *
+ * Copyright (c) 2011-2016 Nikias Bassen, All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include "hashtable.h"
+
+hashtable_t* hash_table_new(hash_func_t hash_func, compare_func_t compare_func, free_func_t free_func)
+{
+	hashtable_t* ht = (hashtable_t*)malloc(sizeof(hashtable_t));
+	int i;
+	for (i = 0; i < 4096; i++) {
+		ht->entries[i] = NULL;
+	}
+	ht->count = 0;
+	ht->hash_func = hash_func;
+	ht->compare_func = compare_func;
+	ht->free_func = free_func;
+	return ht;
+}
+
+void hash_table_destroy(hashtable_t *ht)
+{
+	if (!ht) return;
+
+	int i = 0;
+	for (i = 0; i < 4096; i++) {
+		if (ht->entries[i]) {
+			hashentry_t* e = ht->entries[i];
+			while (e) {
+				if (ht->free_func) {
+					ht->free_func(e->value);
+				}
+				hashentry_t* old = e;
+				e = e->next;
+				free(old);
+			}
+		}
+	}
+	free(ht);
+}
+
+void hash_table_insert(hashtable_t* ht, void *key, void *value)
+{
+	if (!ht || !key) return;
+
+	unsigned int hash = ht->hash_func(key);
+
+	int idx0 = hash & 0xFFF;
+
+	// get the idx0 list
+	hashentry_t* e = ht->entries[idx0];
+	while (e) {
+		if (ht->compare_func(e->key, key)) {
+			// element already present. replace value.
+			e->value = value;
+			return;
+		}
+		e = e->next;
+	}
+
+	// if we get here, the element is not yet in the list.
+
+	// make a new entry.
+	hashentry_t* entry = (hashentry_t*)malloc(sizeof(hashentry_t));
+	entry->key = key;
+	entry->value = value;
+	if (!ht->entries[idx0]) {
+		// first entry
+		entry->next = NULL;
+	} else {
+		// add to list
+		entry->next = ht->entries[idx0];
+	}
+	ht->entries[idx0] = entry;
+	ht->count++;
+}
+
+void* hash_table_lookup(hashtable_t* ht, void *key)
+{
+	if (!ht || !key) return NULL;
+	unsigned int hash = ht->hash_func(key);
+
+	int idx0 = hash & 0xFFF;
+
+	hashentry_t* e = ht->entries[idx0];
+	while (e) {
+		if (ht->compare_func(e->key, key)) {
+			return e->value;
+		}
+		e = e->next;
+	}
+	return NULL;
+}
+
+void hash_table_remove(hashtable_t* ht, void *key)
+{
+	if (!ht || !key) return;
+
+	unsigned int hash = ht->hash_func(key);
+
+	int idx0 = hash & 0xFFF;
+
+	// get the idx0 list
+	hashentry_t* e = ht->entries[idx0];
+	hashentry_t* last = e;
+	while (e) {
+		if (ht->compare_func(e->key, key)) {
+			// found element, remove it from the list
+			hashentry_t* old = e;
+			if (e == ht->entries[idx0]) {
+				ht->entries[idx0] = e->next;
+			} else {
+				last->next = e->next;
+			}
+			if (ht->free_func) {
+				ht->free_func(old->value);
+			}
+			free(old);
+			return;
+		}
+		last = e;
+		e = e->next;
+	}
+}

package/ldid/libplist/src/hashtable.h

@@ -0,0 +1,50 @@
+/*
+ * hashtable.h
+ * header file for really simple hash table implementation
+ *
+ * Copyright (c) 2011-2016 Nikias Bassen, All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef HASHTABLE_H
+#define HASHTABLE_H
+#include <stdlib.h>
+
+typedef struct hashentry_t {
+	void *key;
+	void *value;
+	void *next;
+} hashentry_t;
+
+typedef unsigned int(*hash_func_t)(const void* key);
+typedef int (*compare_func_t)(const void *a, const void *b);
+typedef void (*free_func_t)(void *ptr);
+
+typedef struct hashtable_t {
+	hashentry_t *entries[4096];
+	size_t count;
+	hash_func_t hash_func;
+	compare_func_t compare_func;
+	free_func_t free_func;
+} hashtable_t;
+
+hashtable_t* hash_table_new(hash_func_t hash_func, compare_func_t compare_func, free_func_t free_func);
+void hash_table_destroy(hashtable_t *ht);
+
+void hash_table_insert(hashtable_t* ht, void *key, void *value);
+void* hash_table_lookup(hashtable_t* ht, void *key);
+void hash_table_remove(hashtable_t* ht, void *key);
+
+#endif