Changeset 5e718d9 in mainline for uspace/lib/bithenge/tree.c

Timestamp:

2012-08-21T10:04:16Z (12 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

67edca6

Parents:

0da6c04 (diff), 6a97f2e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge with upstream (lp:~wtachi/helenos/bithenge)

File:

• uspace/lib/bithenge/tree.c (moved) (moved from uspace/app/bithenge/tree.c ) (7 diffs)

uspace/lib/bithenge/tree.c

@@ -76 +76 @@
         if (!node)
                 return;
+        assert (node->refs > 0);
         if (--node->refs == 0)
                 node_destroy(node);
@@ -89 +90 @@
 {
         get_for_each_data_t *data = (get_for_each_data_t *)raw_data;
-        bool equal = bithenge_node_equal(key, data->key);
+        bool equal;
+        int rc = bithenge_node_equal(&equal, key, data->key);
         bithenge_node_dec_ref(key);
+        if (rc != EOK)
+                return rc;
         if (equal) {
                 *data->out = value;
@@ -101 +105 @@
 /** Get a child of a node. Takes ownership of the key. If the node does not
  * provide this function, for_each will be used as an alternative, which may be
- * very slow.
- * @memberof bithenge_node_t
- * @param self The internal node to find a child of.
+ * very slow. Also works for blob nodes to find the byte value at a given
+ * index.
+ * @memberof bithenge_node_t
+ * @param self The internal/blob node to find a child of.
  * @param key The key to search for.
  * @param[out] out Holds the found node.
@@ -111 +116 @@
     bithenge_node_t **out)
 {
+        if (self->type == BITHENGE_NODE_BLOB) {
+                if (bithenge_node_type(key) != BITHENGE_NODE_INTEGER) {
+                        bithenge_node_dec_ref(key);
+                        return ENOENT;
+                }
+                bithenge_int_t offset = bithenge_integer_node_value(key);
+                bithenge_node_dec_ref(key);
+                uint8_t byte;
+                aoff64_t size = 1;
+                int rc = bithenge_blob_read(bithenge_node_as_blob(self),
+                    offset, (char *)&byte, &size);
+                if (rc != EOK)
+                        return rc;
+                if (size != 1)
+                        return ENOENT;
+
+                return bithenge_new_integer_node(out, byte);
+        }
+
         assert(self->type == BITHENGE_NODE_INTERNAL);
         if (self->internal_ops->get)
@@ -174 +198 @@
 int bithenge_new_empty_internal_node(bithenge_node_t **out)
 {
+        if (bithenge_should_fail())
+                return ENOMEM;
         bithenge_node_inc_ref(&empty_internal_node);
         *out = &empty_internal_node;
@@ -277 +303 @@
 {
         assert(out);
+        if (bithenge_should_fail())
+                return ENOMEM;
         *out = value ? &true_node : &false_node;
         (*out)->refs++;
@@ -327 +355 @@
  * internal nodes. Takes ownership of nothing.
  * @memberof bithenge_node_t
+ * @param[out] out Holds whether the nodes are equal.
  * @param a, b Nodes to compare.
- * @return Whether the nodes are equal. If an error occurs, returns false.
- * @todo Add support for internal nodes.
- */
-bool bithenge_node_equal(bithenge_node_t *a, bithenge_node_t *b)
-{
-        if (a->type != b->type)
-                return false;
+ * @return EOK on success or an error code from errno.h.
+ * @todo Add support for internal nodes. */
+int bithenge_node_equal(bool *out, bithenge_node_t *a, bithenge_node_t *b)
+{
+        if (a->type != b->type) {
+                *out = false;
+                return EOK;
+        }
         switch (a->type) {
         case BITHENGE_NODE_INTERNAL:
-                return false;
+                *out = false;
+                return EOK;
         case BITHENGE_NODE_BOOLEAN:
-                return a->boolean_value == b->boolean_value;
+                *out = a->boolean_value == b->boolean_value;
+                return EOK;
         case BITHENGE_NODE_INTEGER:
-                return a->integer_value == b->integer_value;
+                *out = a->integer_value == b->integer_value;
+                return EOK;
         case BITHENGE_NODE_STRING:
-                return !str_cmp(a->string_value.ptr, b->string_value.ptr);
+                *out = !str_cmp(a->string_value.ptr, b->string_value.ptr);
+                return EOK;
         case BITHENGE_NODE_BLOB:
-                return bithenge_blob_equal(bithenge_node_as_blob(a),
+                return bithenge_blob_equal(out, bithenge_node_as_blob(a),
                     bithenge_node_as_blob(b));
         }
-        return false;
+        return EINVAL;
 }