Changeset 1eb0fafe in mainline

Timestamp:

2021-10-25T00:32:45Z (2 years ago)

Author:

jxsvoboda <5887334+jxsvoboda@…>

Branches:

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

Children:

fa792e8

Parents:

692c7f40

git-author:

Jiri Svoboda <jiri@…> (2021-10-15 16:13:21)

git-committer:

jxsvoboda <5887334+jxsvoboda@…> (2021-10-25 00:32:45)

Message:

Sort panel entries

Location:

uspace/app/nav

Files:

• panel.c (modified) (3 diffs)
• panel.h (modified) (1 diff)
• test/panel.c (modified) (1 diff)

uspace/app/nav/panel.c

@@ -44 +44 @@
 #include <ui/paint.h>
 #include <ui/resource.h>
+#include <qsort.h>
 #include "panel.h"
 #include "nav.h"
@@ -484 +485 @@
         closedir(dir);
 
+        rc = panel_sort(panel);
+        if (rc != EOK)
+                goto error;
+
         panel->cursor = panel_first(panel);
         panel->cursor_idx = 0;
@@ -492 +497 @@
         closedir(dir);
         return rc;
+}
+
+/** Sort panel entries.
+ *
+ * @param panel Panel
+ * @return EOK on success, ENOMEM if out of memory
+ */
+errno_t panel_sort(panel_t *panel)
+{
+        panel_entry_t **emap;
+        panel_entry_t *entry;
+        size_t i;
+
+        /* Create an array to hold pointer to each entry */
+        emap = calloc(panel->entries_cnt, sizeof(panel_entry_t *));
+        if (emap == NULL)
+                return ENOMEM;
+
+        /* Write entry pointers to array */
+        entry = panel_first(panel);
+        i = 0;
+        while (entry != NULL) {
+                assert(i < panel->entries_cnt);
+                emap[i++] = entry;
+                entry = panel_next(entry);
+        }
+
+        /* Sort the array of pointers */
+        qsort(emap, panel->entries_cnt, sizeof(panel_entry_t *),
+            panel_entry_ptr_cmp);
+
+        /* Unlink entries from entry list */
+        entry = panel_first(panel);
+        while (entry != NULL) {
+                list_remove(&entry->lentries);
+                entry = panel_first(panel);
+        }
+
+        /* Add entries back to entry list sorted */
+        for (i = 0; i < panel->entries_cnt; i++)
+                list_append(&emap[i]->lentries, &panel->entries);
+
+        free(emap);
+        return EOK;
+}
+
+/** Compare two panel entries indirectly referenced by pointers.
+ *
+ * @param pa Pointer to pointer to first entry
+ * @param pb Pointer to pointer to second entry
+ * @return <0, =0, >=0 if pa < b, pa == pb, pa > pb, resp.
+ */
+int panel_entry_ptr_cmp(const void *pa, const void *pb)
+{
+        panel_entry_t *a = *(panel_entry_t **)pa;
+        panel_entry_t *b = *(panel_entry_t **)pb;
+
+        return str_cmp(a->name, b->name);
 }
 

uspace/app/nav/panel.h

@@ -62 +62 @@
 extern void panel_clear_entries(panel_t *);
 extern errno_t panel_read_dir(panel_t *, const char *);
+extern errno_t panel_sort(panel_t *);
+extern int panel_entry_ptr_cmp(const void *, const void *);
 extern panel_entry_t *panel_first(panel_t *);
 extern panel_entry_t *panel_last(panel_t *);

uspace/app/nav/test/panel.c

@@ -446 +446 @@
 }
 
+/** panel_sort() sorts panel entries */
+PCUT_TEST(sort)
+{
+        panel_t *panel;
+        panel_entry_t *entry;
+        errno_t rc;
+
+        rc = panel_create(NULL, true, &panel);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        rc = panel_entry_append(panel, "b", 1);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        rc = panel_entry_append(panel, "c", 3);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        rc = panel_entry_append(panel, "a", 2);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        rc = panel_sort(panel);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        entry = panel_first(panel);
+        PCUT_ASSERT_STR_EQUALS("a", entry->name);
+        PCUT_ASSERT_INT_EQUALS(2, entry->size);
+
+        entry = panel_next(entry);
+        PCUT_ASSERT_STR_EQUALS("b", entry->name);
+        PCUT_ASSERT_INT_EQUALS(1, entry->size);
+
+        entry = panel_next(entry);
+        PCUT_ASSERT_STR_EQUALS("c", entry->name);
+        PCUT_ASSERT_INT_EQUALS(3, entry->size);
+
+        panel_destroy(panel);
+}
+
+/** panel_entry_ptr_cmp compares two indirectly referenced entries */
+PCUT_TEST(entry_ptr_cmp)
+{
+        panel_t *panel;
+        panel_entry_t *a, *b;
+        int rel;
+        errno_t rc;
+
+        rc = panel_create(NULL, true, &panel);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        rc = panel_entry_append(panel, "a", 2);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        rc = panel_entry_append(panel, "b", 1);
+        PCUT_ASSERT_ERRNO_VAL(EOK, rc);
+
+        a = panel_first(panel);
+        PCUT_ASSERT_NOT_NULL(a);
+        b = panel_next(a);
+        PCUT_ASSERT_NOT_NULL(b);
+
+        /* a < b */
+        rel = panel_entry_ptr_cmp(&a, &b);
+        PCUT_ASSERT_TRUE(rel < 0);
+
+        /* b > a */
+        rel = panel_entry_ptr_cmp(&b, &a);
+        PCUT_ASSERT_TRUE(rel > 0);
+
+        /* a == a */
+        rel = panel_entry_ptr_cmp(&a, &a);
+        PCUT_ASSERT_INT_EQUALS(0, rel);
+
+        panel_destroy(panel);
+}
+
 /** panel_first() returns valid entry or @c NULL as appropriate */
 PCUT_TEST(first)