Changeset cb4a66d2 in mainline

Timestamp:

2012-08-01T23:43:10Z (12 years ago)

Author:

Sean Bartell <wingedtachikoma@…>

Branches:

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

Children:

b8d45e9e

Parents:

47a728e1

Message:

Bithenge: add transform_prefix_apply

• makes struct nodes more efficient in some cases.
• will make certain future transforms easier to implement.

Location:

uspace/app/bithenge

Files:

• transform.c (modified) (5 diffs)
• transform.h (modified) (4 diffs)

uspace/app/bithenge/transform.c

@@ -54 +54 @@
 {
         assert(ops);
-        assert(ops->apply);
+        assert(ops->apply || ops->prefix_apply);
         assert(ops->destroy);
         self->ops = ops;
@@ -65 +65 @@
 {
         assert(false);
+}
+
+/** Apply a transform. Takes ownership of nothing.
+ * @memberof bithenge_transform_t
+ * @param self The transform.
+ * @param scope The scope.
+ * @param in The input tree.
+ * @param[out] out Where the output tree will be stored.
+ * @return EOK on success or an error code from errno.h. */
+int bithenge_transform_apply(bithenge_transform_t *self,
+    bithenge_scope_t *scope, bithenge_node_t *in, bithenge_node_t **out)
+{
+        assert(self);
+        assert(self->ops);
+        if (self->ops->apply)
+                return self->ops->apply(self, scope, in, out);
+
+        if (bithenge_node_type(in) != BITHENGE_NODE_BLOB)
+                return EINVAL;
+        aoff64_t self_size, whole_size;
+        int rc = bithenge_transform_prefix_apply(self, scope,
+            bithenge_node_as_blob(in), out, &self_size);
+        if (rc != EOK)
+                return rc;
+        rc = bithenge_blob_size(bithenge_node_as_blob(in), &whole_size);
+        if (rc == EOK && whole_size != self_size)
+                rc = EINVAL;
+        if (rc != EOK) {
+                bithenge_node_dec_ref(*out);
+                return rc;
+        }
+        return EOK;
+}
+
+/** Find the length of the prefix of a blob this transform can use as input. In
+ * other words, figure out how many bytes this transform will use up.  This
+ * method is optional and can return an error, but it must succeed for struct
+ * subtransforms. Takes ownership of nothing.
+ * @memberof bithenge_transform_t
+ * @param self The transform.
+ * @param scope The scope.
+ * @param blob The blob.
+ * @param[out] out Where the prefix length will be stored.
+ * @return EOK on success, ENOTSUP if not supported, or another error code from
+ * errno.h. */
+int bithenge_transform_prefix_length(bithenge_transform_t *self,
+    bithenge_scope_t *scope, bithenge_blob_t *blob, aoff64_t *out)
+{
+        assert(self);
+        assert(self->ops);
+        if (self->ops->prefix_length)
+                return self->ops->prefix_length(self, scope, blob, out);
+        if (!self->ops->prefix_apply)
+                return ENOTSUP;
+
+        bithenge_node_t *node;
+        int rc = bithenge_transform_prefix_apply(self, scope, blob, &node,
+            out);
+        if (rc != EOK)
+                return rc;
+        bithenge_node_dec_ref(node);
+        return EOK;
+}
+
+/** Apply this transform to a prefix of a blob. In other words, feed as much of
+ * the blob into this transform as possible. Takes ownership of nothing.
+ * @memberof bithenge_transform_t
+ * @param self The transform.
+ * @param scope The scope.
+ * @param blob The blob.
+ * @param[out] out_node Holds the result of applying this transform to the
+ * prefix.
+ * @param[out] out_size Holds the size of the prefix.
+ * @return EOK on success, ENOTSUP if not supported, or another error code from
+ * errno.h. */
+int bithenge_transform_prefix_apply(bithenge_transform_t *self,
+    bithenge_scope_t *scope, bithenge_blob_t *blob, bithenge_node_t **out_node,
+    aoff64_t *out_size)
+{
+        assert(self);
+        assert(self->ops);
+        if (self->ops->prefix_apply)
+                return self->ops->prefix_apply(self, scope, blob, out_node,
+                    out_size);
+        if (!self->ops->prefix_length)
+                return ENOTSUP;
+
+        int rc = bithenge_transform_prefix_length(self, scope, blob, out_size);
+        if (rc != EOK)
+                return rc;
+        bithenge_node_t *prefix_blob;
+        bithenge_blob_inc_ref(blob);
+        rc = bithenge_new_subblob(&prefix_blob, blob, 0, *out_size);
+        if (rc != EOK)
+                return rc;
+        rc = bithenge_transform_apply(self, scope, prefix_blob, out_node);
+        bithenge_node_dec_ref(prefix_blob);
+        return rc;
 }
 
@@ -471 +569 @@
     size_t index)
 {
-        aoff64_t start_pos, end_pos;
+        aoff64_t start_pos;
         int rc = struct_node_field_offset(self, &start_pos, index);
         if (rc != EOK)
                 return rc;
-        rc = struct_node_field_offset(self, &end_pos, index + 1);
-        if (rc != EOK)
-                return rc;
-
-        bithenge_node_t *blob_node;
-        bithenge_blob_inc_ref(self->blob);
-        rc = bithenge_new_subblob(&blob_node, self->blob, start_pos,
-            end_pos - start_pos);
-        if (rc != EOK)
-                return rc;
-
-        rc = bithenge_transform_apply(
-            self->transform->subtransforms[index].transform, &self->scope,
-            blob_node, out);
-        bithenge_node_dec_ref(blob_node);
-        if (rc != EOK)
-                return rc;
+
+        if (index == self->num_ends) {
+                /* We can apply the subtransform and cache its prefix length at
+                 * the same time. */
+                bithenge_node_t *blob_node;
+                bithenge_blob_inc_ref(self->blob);
+                rc = bithenge_new_offset_blob(&blob_node, self->blob,
+                    start_pos);
+                if (rc != EOK)
+                        return rc;
+
+                aoff64_t size;
+                rc = bithenge_transform_prefix_apply(
+                    self->transform->subtransforms[index].transform,
+                    &self->scope, bithenge_node_as_blob(blob_node), out,
+                    &size);
+                bithenge_node_dec_ref(blob_node);
+                if (rc != EOK)
+                        return rc;
+
+                self->ends[self->num_ends++] = start_pos + size;
+        } else {
+                aoff64_t end_pos;
+                int rc = struct_node_field_offset(self, &end_pos, index + 1);
+                if (rc != EOK)
+                        return rc;
+
+                bithenge_node_t *blob_node;
+                bithenge_blob_inc_ref(self->blob);
+                rc = bithenge_new_subblob(&blob_node, self->blob, start_pos,
+                    end_pos - start_pos);
+                if (rc != EOK)
+                        return rc;
+
+                rc = bithenge_transform_apply(
+                    self->transform->subtransforms[index].transform,
+                    &self->scope, blob_node, out);
+                bithenge_node_dec_ref(blob_node);
+                if (rc != EOK)
+                        return rc;
+        }
 
         return EOK;
@@ -692 +814 @@
 }
 
+static int struct_transform_prefix_apply(bithenge_transform_t *base,
+    bithenge_scope_t *scope, bithenge_blob_t *blob, bithenge_node_t **out_node,
+    aoff64_t *out_size)
+{
+        struct_transform_t *self = transform_as_struct(base);
+        int rc = struct_transform_make_node(self, out_node, scope, blob,
+            true);
+        if (rc != EOK)
+                return rc;
+
+        rc = struct_node_field_offset(node_as_struct(*out_node), out_size,
+            self->num_subtransforms);
+        if (rc != EOK) {
+                bithenge_node_dec_ref(*out_node);
+                return rc;
+        }
+
+        return EOK;
+}
+
 static void free_subtransforms(bithenge_named_transform_t *subtransforms)
 {
@@ -711 +853 @@
         .apply = struct_transform_apply,
         .prefix_length = struct_transform_prefix_length,
+        .prefix_apply = struct_transform_prefix_apply,
         .destroy = struct_transform_destroy,
 };

uspace/app/bithenge/transform.h

@@ -57 +57 @@
 } bithenge_scope_t;
 
-/** Operations that may be provided by a transform. */
+/** Operations that may be provided by a transform. All transforms must provide
+ * apply and/or prefix_apply. To be used in struct transforms and repeat
+ * transforms, transforms must provide prefix_length and/or prefix_apply. */
 typedef struct bithenge_transform_ops {
         /** @copydoc bithenge_transform_t::bithenge_transform_apply */
@@ -65 +67 @@
         int (*prefix_length)(bithenge_transform_t *self,
             bithenge_scope_t *scope, bithenge_blob_t *blob, aoff64_t *out);
+        /** @copydoc bithenge_transform_t::bithenge_transform_prefix_apply */
+        int (*prefix_apply)(bithenge_transform_t *self,
+            bithenge_scope_t *scope, bithenge_blob_t *blob,
+            bithenge_node_t **out_node, aoff64_t *out_size);
         /** Destroy the transform.
          * @param self The transform. */
@@ -191 +197 @@
         assert(self);
         return self->num_params;
-}
-
-/** Apply a transform. Takes ownership of nothing.
- * @memberof bithenge_transform_t
- * @param self The transform.
- * @param scope The scope.
- * @param in The input tree.
- * @param[out] out Where the output tree will be stored.
- * @return EOK on success or an error code from errno.h. */
-static inline int bithenge_transform_apply(bithenge_transform_t *self,
-    bithenge_scope_t *scope, bithenge_node_t *in, bithenge_node_t **out)
-{
-        assert(self);
-        assert(self->ops);
-        return self->ops->apply(self, scope, in, out);
-}
-
-/** Find the length of the prefix of a blob this transform can use as input. In
- * other words, figure out how many bytes this transform will use up.  This
- * method is optional and can return an error, but it must succeed for struct
- * subtransforms. Takes ownership of nothing.
- * @memberof bithenge_transform_t
- * @param self The transform.
- * @param scope The scope.
- * @param blob The blob.
- * @param[out] out Where the prefix length will be stored.
- * @return EOK on success, ENOTSUP if not supported, or another error code from
- * errno.h. */
-static inline int bithenge_transform_prefix_length(bithenge_transform_t *self,
-    bithenge_scope_t *scope, bithenge_blob_t *blob, aoff64_t *out)
-{
-        assert(self);
-        assert(self->ops);
-        if (!self->ops->prefix_length)
-                return ENOTSUP;
-        return self->ops->prefix_length(self, scope, blob, out);
 }
 
@@ -269 +239 @@
 int bithenge_init_transform(bithenge_transform_t *,
     const bithenge_transform_ops_t *, int);
+int bithenge_transform_apply(bithenge_transform_t *, bithenge_scope_t *,
+    bithenge_node_t *, bithenge_node_t **);
+int bithenge_transform_prefix_length(bithenge_transform_t *,
+    bithenge_scope_t *, bithenge_blob_t *, aoff64_t *);
+int bithenge_transform_prefix_apply(bithenge_transform_t *, bithenge_scope_t *,
+    bithenge_blob_t *, bithenge_node_t **, aoff64_t *);
 int bithenge_new_param_transform(bithenge_transform_t **,
     bithenge_transform_t *, int);