Changeset f2da0bb in mainline for uspace/app/bithenge/tree.c

Timestamp:

2012-06-24T19:24:35Z (12 years ago)

Author:

Sean Bartell <wingedtachikoma@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

04a7435f

Parents:

0d1a8fd

Message:

Bithenge: use reference counting for nodes

File:

• uspace/app/bithenge/tree.c (modified) (11 diffs)

uspace/app/bithenge/tree.c

@@ -48 +48 @@
 }
 
-/** Destroy a node.
- * @memberof bithenge_node_t
- * @param node The node to destroy.
- * @return EOK on success or an error code from errno.h. */
-int bithenge_node_destroy(bithenge_node_t *node)
+static int node_destroy(bithenge_node_t *node)
 {
         switch (bithenge_node_type(node)) {
@@ -72 +68 @@
 }
 
+/** Decrement a node's reference count and free it if appropriate.
+ * @memberof bithenge_node_t
+ * @param node The node to dereference, or NULL.
+ * @return EOK on success or an error code from errno.h. */
+int bithenge_node_dec_ref(bithenge_node_t *node)
+{
+        if (!node)
+                return EOK;
+        if (--node->refs == 0)
+                return node_destroy(node);
+        return EOK;
+}
+
 typedef struct
 {
@@ -83 +92 @@
 {
         return (simple_internal_node_t *)node;
+}
+
+static bithenge_node_t *simple_as_node(simple_internal_node_t *node)
+{
+        return &node->base;
 }
 
@@ -102 +116 @@
         int rc;
         simple_internal_node_t *node = node_as_simple(base);
-        for (bithenge_int_t i = 0; i < node->len; i++) {
-                rc = bithenge_node_destroy(node->nodes[2*i+0]);
-                if (rc != EOK)
-                        return rc;
-                rc = bithenge_node_destroy(node->nodes[2*i+1]);
+        for (bithenge_int_t i = 0; i < 2 * node->len; i++) {
+                rc = bithenge_node_dec_ref(node->nodes[i]);
                 if (rc != EOK)
                         return rc;
@@ -121 +132 @@
 };
 
-static bithenge_node_t *simple_internal_as_node(simple_internal_node_t *node)
-{
-        return &node->base;
-}
-
-/** Create an internal node from a set of keys and values. The node must be
- * freed with @a bithenge_node_t::bithenge_node_destroy after it is used, which
- * will also destroy all the key and value nodes.
+/** Create an internal node from a set of keys and values. This function takes
+ * ownership of a reference to the key and value nodes, and optionally the
+ * array @a nodes.
  * @memberof bithenge_node_t
  * @param[out] out Stores the created internal node.
@@ -135 +141 @@
  * @param len The number of key-value pairs in the node array.
  * @param needs_free If true, when the internal node is destroyed it will free
- * the nodes array as well as destroying each node inside it.
+ * the nodes array rather than just dereferencing each node inside it.
  * @return EOK on success or an error code from errno.h. */
 int bithenge_new_simple_internal_node(bithenge_node_t **out,
@@ -142 +148 @@
         assert(out);
         simple_internal_node_t *node = malloc(sizeof(*node));
-        if (!node)
+        if (!node) {
+                for (bithenge_int_t i = 0; i < 2 * len; i++)
+                        bithenge_node_dec_ref(nodes[i]);
+                if (needs_free)
+                        free(nodes);
                 return ENOMEM;
+        }
         node->base.type = BITHENGE_NODE_INTERNAL;
+        node->base.refs = 1;
         node->base.internal_ops = &simple_internal_node_ops;
         node->nodes = nodes;
         node->len = len;
         node->needs_free = needs_free;
-        *out = simple_internal_as_node(node);
-        return EOK;
-}
-
-static bithenge_node_t false_node = { BITHENGE_NODE_BOOLEAN, .boolean_value = false };
-static bithenge_node_t true_node = { BITHENGE_NODE_BOOLEAN, .boolean_value = true };
-
-/** Create a boolean node. The node must be freed with @a
- * bithenge_node_t::bithenge_node_destroy after it is used.
+        *out = simple_as_node(node);
+        return EOK;
+}
+
+static bithenge_node_t false_node = { BITHENGE_NODE_BOOLEAN, 1, .boolean_value = false };
+static bithenge_node_t true_node = { BITHENGE_NODE_BOOLEAN, 1, .boolean_value = true };
+
+/** Create a boolean node.
  * @memberof bithenge_node_t
  * @param[out] out Stores the created boolean node.
@@ -166 +177 @@
         assert(out);
         *out = value ? &true_node : &false_node;
-        return EOK;
-}
-
-/** Create an integer node. The node must be freed with @a
- * bithenge_node_t::bithenge_node_destroy after it is used.
+        (*out)->refs++;
+        return EOK;
+}
+
+/** Create an integer node.
  * @memberof bithenge_node_t
  * @param[out] out Stores the created integer node.
@@ -182 +193 @@
                 return ENOMEM;
         node->type = BITHENGE_NODE_INTEGER;
+        node->refs = 1;
         node->integer_value = value;
         *out = node;
@@ -187 +199 @@
 }
 
-/** Create a string node. The node must be freed with @a
- * bithenge_node_t::bithenge_node_destroy after it is used.
+/** Create a string node.
  * @memberof bithenge_node_t
  * @param[out] out Stores the created string node.
@@ -202 +213 @@
                 return ENOMEM;
         node->type = BITHENGE_NODE_STRING;
+        node->refs = 1;
         node->string_value.ptr = value;
         node->string_value.needs_free = needs_free;