libcouchbase 0.0.1

data/ext/libcouchbase/src/simplestring.h

@@ -0,0 +1,228 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2013 Couchbase, Inc.
+ *
+ *   Licensed 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.
+ */
+
+#ifndef LCB_STRING_H
+#define LCB_STRING_H
+
+#include <libcouchbase/couchbase.h>
+#include <stdarg.h>
+
+#include "config.h"
+#include "assert.h"
+#include "ringbuffer.h"
+
+/**
+ * Simple string type.
+ *
+ * This structure is designed mainly for ease of use when dealing with actual
+ * "string" data - i.e. data which must be null-terminated and contiguous.
+ *
+ * This won't replace the ringbuffer structure as this string's removal and
+ * copying operations are comparatively expensive.
+ *
+ * Note that all API functions which update the position of the buffer ALSO
+ * add a trailing NUL byte at the end.
+ */
+typedef struct lcb_string_st {
+    /** Buffer that's allocated */
+    char *base;
+
+    /** Number of bytes allocated */
+    lcb_size_t nalloc;
+
+    /** Number of bytes used */
+    lcb_size_t nused;
+#ifdef __cplusplus
+    typedef char *iterator;
+    typedef const char *const_iterator;
+
+    iterator begin() { return base; };
+    iterator end() { return base + nused; }
+    const_iterator begin() const { return base; }
+    const_iterator end() const { return base + nused; }
+    size_t size() const { return nused; }
+    size_t capacity() const { return nalloc; }
+    const char *c_str() const { return base; }
+
+    inline void insert(iterator p, const char *first, const char *last);
+#endif
+} lcb_string;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int lcb_string_init(lcb_string *str);
+
+/**
+ * Free any storage associated with the string. The string's state will be
+ * empty as if string_init() had just been called.
+ */
+void lcb_string_release(lcb_string *str);
+
+/**
+ * Clear the contents of the string, but don't free the underlying buffer
+ */
+void lcb_string_clear(lcb_string *str);
+
+
+/**
+ * Indicate that bytes have been added to the string. This is used in conjunction
+ * with reserve(). As such, the number of bytes added should not exceed the
+ * number of bytes passed to reserver.
+ *
+ * @param str the string
+ * @param nbytes the number of bytes added
+ */
+void lcb_string_added(lcb_string *str, lcb_size_t nbytes);
+
+/**
+ * Reserve an amount of free bytes within the string. When this is done,
+ * up to @c size bytes may be added to the string starting at @c base+str->nbytes
+ */
+int lcb_string_reserve(lcb_string *str, lcb_size_t size);
+
+
+/**
+ * Adds data to the string.
+ * @param str the string to append to
+ * @param data the data to copy
+ * @param size the size of data to copy
+ */
+int lcb_string_append(lcb_string *str, const void *data, lcb_size_t size);
+
+/**
+ * Adds a C-style string
+ * @param str the target lcb_string
+ * @param zstr a NUL-terminated string to add
+ */
+int lcb_string_appendz(lcb_string *str, const char *zstr);
+
+
+/**
+ * Appends a list of pointer-length pairs. Useful if you need to concatenate
+ * many small buffers
+ * @param str The string to append to. This should be followed by a list of
+ * `pointer, size` arguments (where `size` is `size_t`). If the length is
+ * `-1` then `strlen(pointer)` will be called to determine the length.
+ *
+ * A terminal `NULL` should be placed at the end of the argument list
+ *
+ * @return 0 if appended, nonzero on memory error
+ */
+int lcb_string_appendv(lcb_string *str, ...);
+
+/**
+ * Adds a string from a ringbuffer structure. This copies the contents
+ * of the ringbuffer into a string.
+ * @param str the target string
+ * @param rb the source ringbuffer
+ * @param rbadvance whether to advance the ringbuffer's read head
+ */
+int lcb_string_rbappend(lcb_string *str, ringbuffer_t *rb, int rbadvance);
+
+/**
+ * Removes bytes from the end of the string. The resultant string will be
+ * NUL-terminated
+ * @param str the string to operate on
+ * @param to_remove the number of bytes to trim from the end
+ */
+void lcb_string_erase_end(lcb_string *str, lcb_size_t to_remove);
+
+
+/**
+ * Removes bytes from the beginning of the string. The resultant string will
+ * be NUL-terminated.
+ * @param str the string to operate on
+ * @param to_remove the number of bytes to remove from the beginning of
+ * the string.
+ */
+void lcb_string_erase_beginning(lcb_string *str, lcb_size_t to_remove);
+
+/**
+ * Transfers ownership of the underlying buffer contained within the structure
+ * 'to' to the structure 'from', as such, 'from' becomes a newly initialized
+ * empty string structure and 'to' contains the existing buffer.
+ *
+ * @param from the string which contains the existing buffer
+ * @param to a new string structure which contains no buffer. It will receive
+ * from's buffer
+ */
+void lcb_string_transfer(lcb_string *from, lcb_string *to);
+
+/**
+ * Inserts a string at a given position
+ * @param str the string object
+ * @param at position at which to insert
+ * @param src the string to insert
+ * @param len length of string to insert
+ */
+int lcb_string_insert(lcb_string *str, size_t at, const char *src, size_t len);
+
+#define lcb_string_tail(str) ((str)->base + (str)->nused)
+
+#ifdef __cplusplus
+}
+
+#include <stdexcept>
+#include <new>
+void
+lcb_string_st::insert(iterator p, const char *first, const char *last) {
+    size_t at = p - base;
+    size_t n = last - first;
+    if (lcb_string_insert(this, at, first, n) != 0) {
+        throw std::bad_alloc();
+    }
+}
+
+namespace lcb {
+class AutoString : public lcb_string_st {
+public:
+    AutoString() {
+        lcb_string_init(this);
+    }
+    ~AutoString() {
+        lcb_string_release(this);
+    }
+
+    char *take(size_t& len, size_t& cap) {
+        char *ret = base;
+        len = nused;
+        cap = nalloc;
+
+        base = NULL;
+        nalloc = 0;
+        nused = 0;
+        return ret;
+    }
+    char *take(size_t& len) {
+        size_t dummy;
+        return take(len, dummy);
+    }
+    char *take() {
+        size_t dummy;
+        return take(dummy, dummy);
+    }
+
+private:
+    AutoString(lcb_string_st&);
+    AutoString(const lcb_string_st&);
+};
+}
+
+#endif /** __cplusplus */
+#endif /* LCB_STRING_H */

data/ext/libcouchbase/src/sllist-inl.h

@@ -0,0 +1,197 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2014 Couchbase, Inc.
+ *
+ *   Licensed 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.
+ */
+
+#include "sllist.h"
+#include <stdlib.h>
+#include <assert.h>
+#include <stdio.h>
+#ifndef INLINE
+#ifdef _MSC_VER
+#define INLINE __inline
+#elif __GNUC__
+#define INLINE __inline__
+#else
+#define INLINE inline
+#endif /* MSC_VER */
+#endif /* !INLINE */
+
+
+static INLINE int
+sllist_contains(sllist_root *list, sllist_node *item)
+{
+    sllist_node *ll;
+    SLLIST_FOREACH(list, ll) {
+        if (item == ll) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+static INLINE unsigned
+sllist_get_size(sllist_root *list)
+{
+    unsigned ret = 0;
+    sllist_node *ll;
+    SLLIST_FOREACH(list, ll) {
+        ret++;
+    }
+    return ret;
+}
+
+/* #define SLLIST_DEBUG */
+
+#ifdef SLLIST_DEBUG
+#define slist_sanity_insert(l, n) assert(!slist_contains(l, n))
+#else
+#define slist_sanity_insert(l, n)
+#endif
+
+static INLINE void
+slist_iter_init_at(sllist_node *node, sllist_iterator *iter)
+{
+    iter->cur = node->next;
+    iter->prev = node;
+    iter->removed = 0;
+
+    if (iter->cur) {
+        iter->next = iter->cur->next;
+    } else {
+        iter->next = NULL;
+    }
+}
+
+static INLINE void
+slist_iter_init(sllist_root *list, sllist_iterator *iter)
+{
+    slist_iter_init_at(&list->first_prev, iter);
+}
+
+static INLINE void
+slist_iter_incr(sllist_root *list, sllist_iterator *iter)
+{
+    if (!iter->removed) {
+        iter->prev = iter->prev->next;
+    } else {
+        iter->removed = 0;
+    }
+
+    if ((iter->cur = iter->next)) {
+        iter->next = iter->cur->next;
+    } else {
+        iter->next = NULL;
+    }
+
+    assert(iter->cur != iter->prev);
+
+    (void)list;
+}
+
+static INLINE void
+sllist_iter_remove(sllist_root *list, sllist_iterator *iter)
+{
+    iter->prev->next = iter->next;
+
+    /** GCC strict aliasing. Yay. */
+    if (iter->prev->next == NULL && iter->prev == &list->first_prev) {
+        list->last = NULL;
+    } else if (iter->cur == list->last && iter->next == NULL) {
+        /* removing the last item */
+        list->last = iter->prev;
+    }
+    iter->removed = 1;
+}
+
+static INLINE void
+sllist_remove_head(sllist_root *list)
+{
+    if (!SLLIST_FIRST(list)) {
+        return;
+    }
+
+    SLLIST_FIRST(list) = SLLIST_FIRST(list)->next;
+
+    if (!SLLIST_FIRST(list)) {
+        list->last = NULL;
+    }
+}
+
+static INLINE void
+sllist_remove(sllist_root *list, sllist_node *item)
+{
+    sllist_iterator iter;
+    SLLIST_ITERFOR(list, &iter) {
+        if (iter.cur == item) {
+            sllist_iter_remove(list, &iter);
+            return;
+        }
+    }
+    fprintf(stderr, "SLLIST: Requested to remove item %p which is not in %p\n", (void*)list, (void*)item);
+    assert(0);
+}
+
+static INLINE void
+sllist_append(sllist_root *list, sllist_node *item)
+{
+    if (SLLIST_IS_EMPTY(list)) {
+        SLLIST_FIRST(list) = list->last = item;
+        item->next = NULL;
+    } else {
+        slist_sanity_insert(list, item);
+        list->last->next = item;
+        list->last = item;
+    }
+    item->next = NULL;
+}
+
+static INLINE void
+sllist_prepend(sllist_root *list, sllist_node *item)
+{
+    if (SLLIST_IS_EMPTY(list)) {
+        SLLIST_FIRST(list) = list->last = item;
+    } else {
+        slist_sanity_insert(list, item);
+        item->next = SLLIST_FIRST(list);
+        SLLIST_FIRST(list) = item;
+    }
+}
+
+static void
+sllist_insert(sllist_root *list, sllist_node *prev, sllist_node *item)
+{
+    item->next = prev->next;
+    prev->next = item;
+    if (item->next == NULL) {
+        list->last = item;
+    }
+}
+
+static INLINE void
+sllist_insert_sorted(sllist_root *list, sllist_node *item,
+                     int (*compar)(sllist_node*, sllist_node*))
+{
+    sllist_iterator iter;
+    SLLIST_ITERFOR(list, &iter) {
+        int rv = compar(item, iter.cur);
+        /** if the item we have is before the current, prepend it here */
+        if (rv <= 0) {
+            sllist_insert(list, iter.prev, item);
+            return;
+        }
+    }
+    sllist_append(list, item);
+}

data/ext/libcouchbase/src/sllist.h

@@ -0,0 +1,76 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2014 Couchbase, Inc.
+ *
+ *   Licensed 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.
+ */
+
+#ifndef LCB_SLIST_H
+#define LCB_SLIST_H
+
+struct slist_node_st;
+typedef struct slist_node_st {
+    struct slist_node_st *next;
+} sllist_node;
+
+typedef struct {
+    sllist_node first_prev;
+    sllist_node *last;
+} sllist_root;
+
+/**
+ * Indicates whether the list is empty or not
+ */
+#define SLLIST_FIRST(list) (list)->first_prev.next
+#define SLLIST_LAST(list) (list)->last
+
+#define SLLIST_IS_EMPTY(list) (SLLIST_LAST(list) == NULL)
+#define SLLIST_IS_ONE(list) (SLLIST_FIRST(list) && SLLIST_FIRST(list) == SLLIST_LAST(list))
+
+/**
+ * Iterator for list. This can be used as the 'for' statement; as such this
+ * macro should look like such:
+ *
+ *  slist_node *ii;
+ *  SLIST_FOREACH(list, ii) {
+ *      my_item *item = LCB_LIST_ITEM(my_item, ii, slnode);
+ *  }
+ *
+ *  @param list the list to iterate
+ *  @param pos a local variable to use as the iterator
+ */
+#define SLLIST_FOREACH(list, pos) \
+    for (pos = SLLIST_FIRST(list); pos; pos = pos->next)
+
+
+typedef struct sllist_iterator_st {
+    sllist_node *cur;
+    sllist_node *prev;
+    sllist_node *next;
+    int removed;
+} sllist_iterator;
+
+#define sllist_iter_end(list, iter) ((iter)->cur == NULL)
+
+#define SLLIST_ITEM(ptr, type, member) \
+        ((type *) (void *) ((char *)(ptr) - offsetof(type, member)))
+
+#define SLLIST_ITERFOR(list, iter) \
+    for (slist_iter_init(list, iter); \
+            !sllist_iter_end(list, iter); \
+            slist_iter_incr(list, iter))
+
+#define SLLIST_ITERBASIC(list, elem) \
+        for (elem = SLLIST_FIRST(list); elem; elem = elem->next)
+
+#endif