Changeset c2d50c8 in mainline

Timestamp:

2019-08-06T18:29:48Z (5 years ago)

Author:

Matthieu Riolo <matthieu.riolo@…>

Children:

72c8f77

Parents:

73f7c4e

git-author:

Michal Koutný <xm.koutny+hos@…> (2015-05-26 16:12:03)

git-committer:

Matthieu Riolo <matthieu.riolo@…> (2019-08-06 18:29:48)

Message:

dyn_array: Add concat and clear_range operations

Location:

uspace/lib/c

Files:

• generic/adt/dyn_array.c (modified) (2 diffs)
• include/adt/dyn_array.h (modified) (1 diff)
• test/dyn_array.c (modified) (1 diff)

uspace/lib/c/generic/adt/dyn_array.c

@@ -68 +68 @@
 }
 
-/** Remove item at give position, shift rest of array */
+/** Remove item at given position, shift rest of array */
 void dyn_array_remove(dyn_array_t *da, size_t index)
 {
@@ -81 +81 @@
 {
         da->size = 0;
+}
+
+/** Clear subsequence of array
+ *
+ * @param[in/out]  da
+ * @param[in]      begin  index of first item to remove
+ * @param[in]      end    index behind last item to remove
+ */
+void dyn_array_clear_range(dyn_array_t *da, size_t begin, size_t end)
+{
+        assert(begin < da->size);
+        assert(end <= da->size);
+
+        _dyn_array_unshift(da, begin, end - begin);
+        int rc = dyn_array_reserve(da, da->size);
+        assert(rc == EOK);
+}
+
+/** Concatenate two arrays
+ *
+ * @param[in/out]  da1  first array and concatenated output
+ * @param[in]      da2  second array, it is untouched
+ *
+ * @return EOK on success
+ * @return ENOMEM when allocation fails
+ */
+int dyn_array_concat(dyn_array_t *da1, dyn_array_t *da2)
+{
+        assert(da1->_item_size == da2->_item_size);
+
+        int rc = dyn_array_reserve(da1, da1->size + da2->size);
+        if (rc != EOK) {
+                return rc;
+        }
+        void *dst = da1->_data + da1->size * da1->_item_size;
+        void *src = da2->_data;
+        size_t size = da1->_item_size * da2->size;
+        memcpy(dst, src, size);
+        da1->size += da2->size;
+
+        return EOK;
 }
 

uspace/lib/c/include/adt/dyn_array.h

@@ -128 +128 @@
 extern void dyn_array_remove(dyn_array_t *, size_t);
 void dyn_array_clear(dyn_array_t *);
-extern int  dyn_array_reserve(dyn_array_t *, size_t);
+void dyn_array_clear_range(dyn_array_t *, size_t, size_t);
+extern int dyn_array_concat(dyn_array_t *, dyn_array_t *);
+extern int dyn_array_reserve(dyn_array_t *, size_t);
 
 extern void _dyn_array_initialize(dyn_array_t *, size_t);

uspace/lib/c/test/dyn_array.c

@@ -136 +136 @@
 }
 
+PCUT_TEST(clear_range_middle) {
+        dyn_array_append(&da, data_t, 10);
+        dyn_array_append(&da, data_t, 11);
+        dyn_array_append(&da, data_t, 12);
+        dyn_array_append(&da, data_t, 99);
+
+        dyn_array_clear_range(&da, 1, 3);
+        PCUT_ASSERT_INT_EQUALS(2, da.size);
+        PCUT_ASSERT_INT_EQUALS(10, dyn_array_at(&da, data_t, 0));
+        PCUT_ASSERT_INT_EQUALS(99, dyn_array_at(&da, data_t, 1));
+}
+
+PCUT_TEST(clear_range_begin) {
+        dyn_array_append(&da, data_t, 10);
+        dyn_array_append(&da, data_t, 11);
+        dyn_array_append(&da, data_t, 12);
+        dyn_array_append(&da, data_t, 99);
+
+        dyn_array_clear_range(&da, 0, 2);
+        PCUT_ASSERT_INT_EQUALS(2, da.size);
+        PCUT_ASSERT_INT_EQUALS(12, dyn_array_at(&da, data_t, 0));
+        PCUT_ASSERT_INT_EQUALS(99, dyn_array_at(&da, data_t, 1));
+}
+
+PCUT_TEST(clear_range_end) {
+        dyn_array_append(&da, data_t, 10);
+        dyn_array_append(&da, data_t, 11);
+        dyn_array_append(&da, data_t, 12);
+        dyn_array_append(&da, data_t, 99);
+
+        dyn_array_clear_range(&da, 2, 4);
+        PCUT_ASSERT_INT_EQUALS(2, da.size);
+        PCUT_ASSERT_INT_EQUALS(10, dyn_array_at(&da, data_t, 0));
+        PCUT_ASSERT_INT_EQUALS(11, dyn_array_at(&da, data_t, 1));
+}
+
+PCUT_TEST(clear_range_empty) {
+        dyn_array_append(&da, data_t, 10);
+        dyn_array_append(&da, data_t, 99);
+
+        dyn_array_clear_range(&da, 0, 0);
+        PCUT_ASSERT_INT_EQUALS(2, da.size);
+        PCUT_ASSERT_INT_EQUALS(10, dyn_array_at(&da, data_t, 0));
+        PCUT_ASSERT_INT_EQUALS(99, dyn_array_at(&da, data_t, 1));
+}
+
+PCUT_TEST(concat_simple) {
+        dyn_array_append(&da, data_t, 10);
+        dyn_array_append(&da, data_t, 99);
+
+        dyn_array_t da2;
+        dyn_array_initialize(&da2, data_t);
+        dyn_array_append(&da2, data_t, 30);
+        dyn_array_append(&da2, data_t, 31);
+
+        dyn_array_concat(&da, &da2);
+        PCUT_ASSERT_INT_EQUALS(4, da.size);
+        PCUT_ASSERT_INT_EQUALS(2, da2.size);
+
+        PCUT_ASSERT_INT_EQUALS(10, dyn_array_at(&da, data_t, 0));
+        PCUT_ASSERT_INT_EQUALS(99, dyn_array_at(&da, data_t, 1));
+        PCUT_ASSERT_INT_EQUALS(30, dyn_array_at(&da, data_t, 2));
+        PCUT_ASSERT_INT_EQUALS(31, dyn_array_at(&da, data_t, 3));
+
+        dyn_array_destroy(&da2);
+}
+PCUT_TEST(concat_self) {
+        dyn_array_append(&da, data_t, 10);
+        dyn_array_append(&da, data_t, 99);
+
+        dyn_array_concat(&da, &da);
+        PCUT_ASSERT_INT_EQUALS(4, da.size);
+
+        PCUT_ASSERT_INT_EQUALS(10, dyn_array_at(&da, data_t, 0));
+        PCUT_ASSERT_INT_EQUALS(99, dyn_array_at(&da, data_t, 1));
+        PCUT_ASSERT_INT_EQUALS(10, dyn_array_at(&da, data_t, 2));
+        PCUT_ASSERT_INT_EQUALS(99, dyn_array_at(&da, data_t, 3));
+}
+
 PCUT_EXPORT(dyn_array);