btr: Introduce btr_next_buffer_omit().

[paraslash.git] / buffer_tree.c

diff --git a/buffer_tree.c b/buffer_tree.c
index 88fb8362bb0c9233d9a5916519b4acf47f4a63ed..cb9d514f1aa5adfc501d5eee89150b7aa31821bc 100644 (file)
--- a/buffer_tree.c
+++ b/buffer_tree.c
@@ -563,40 +563,95 @@ static size_t btr_get_buffer_by_reference(struct btr_buffer_reference *br, char
 }
 
 /**
- * Obtain the next buffer of the input queue of a buffer tree node.
+ * Obtain the next buffer of the input queue, omitting data.
  *
  * \param btrn The node whose input queue is to be queried.
+ * \param omit Number of bytes to be omitted.
  * \param bufp Result pointer.
  *
- * \return The number of bytes that can be read from buf. Zero if the input
- * buffer queue is empty. In this case the value of \a bufp is undefined.
+ * If a buffer tree node needs more input data but can not consume the data it
+ * already has (because it might be needed again later) this function can be
+ * used instead of btr_next_buffer() to get a reference to the buffer obtained
+ * by skipping the given number of bytes. Skipped input bytes are not consumed.
+ *
+ * With a zero \a omit argument, this function is equivalent to \ref
+ * btr_next_buffer().
+ *
+ * \return Number of bytes in \a bufp. If there are less than or equal to \a
+ * omit many bytes available in the input queue of the buffer tree node pointed
+ * to by \a btrn, the function returns zero and the value of \a bufp is
+ * undefined.
  */
-size_t btr_next_buffer(struct btr_node *btrn, char **bufp)
+size_t btr_next_buffer_omit(struct btr_node *btrn, size_t omit, char **bufp)
 {
        struct btr_buffer_reference *br;
+       size_t wrap_count, sz, rv = 0;
        char *buf, *result = NULL;
-       size_t sz, rv = 0;
 
-       FOR_EACH_BUFFER_REF(br, btrn) {
+       br = get_first_input_br(btrn);
+       if (!br)
+               return 0;
+       wrap_count = br->wrap_count;
+       if (wrap_count > 0) { /* we have a wrap buffer */
                sz = btr_get_buffer_by_reference(br, &buf);
-               if (!result) {
-                       result = buf;
-                       rv = sz;
-                       if (!br->btrb->pool)
-                               break;
-                       continue;
+               if (sz > omit) { /* and it's big enough */
+                       result = buf + omit;
+                       rv = sz - omit;
+                       /*
+                        * Wrap buffers are allocated by malloc(), so the next
+                        * buffer ref will not align nicely, so we return the
+                        * tail of the wrap buffer.
+                        */
+                       goto out;
                }
-               if (!br->btrb->pool)
-                       break;
-               if (result + rv != buf)
-                       break;
-               rv += sz;
+               /*
+                * The next wrap_count bytes exist twice, in the wrap buffer
+                * and as a buffer reference in the buffer tree pool.
+                */
+               omit += wrap_count;
+       }
+       /*
+        * For buffer tree pools, the buffers in the list align, i.e. the next
+        * buffer in the list starts directly at the end of its predecessor. In
+        * this case we merge adjacent buffers and return one larger buffer
+        * instead.
+        */
+       FOR_EACH_BUFFER_REF(br, btrn) {
+               sz = btr_get_buffer_by_reference(br, &buf);
+               if (result) {
+                       if (result + rv != buf)
+                               goto out;
+                       rv += sz;
+               } else if (sz > omit) {
+                       result = buf + omit;
+                       rv = sz - omit;
+               } else
+                       omit -= sz;
        }
+       if (!result)
+               return 0;
+out:
        if (bufp)
                *bufp = result;
        return rv;
 }
 
+/**
+ * Obtain the next buffer of the input queue of a buffer tree node.
+ *
+ * \param btrn The node whose input queue is to be queried.
+ * \param bufp Result pointer.
+ *
+ * \return The number of bytes that can be read from buf.
+ *
+ * The call of this function is is equivalent to calling \ref
+ * btr_next_buffer_omit() with an \a omit value of zero.
+ */
+size_t btr_next_buffer(struct btr_node *btrn, char **bufp)
+{
+       return btr_next_buffer_omit(btrn, 0, bufp);
+}
+
 /**
  * Deallocate the given number of bytes from the input queue.
  *