search.c

   1 /*
   2  * Copyright Timo Hirvonen
   3  */
   4
   5 #include "search.h"
   6 #include "editable.h"
   7 #include "xmalloc.h"
   8
   9 struct searchable {
  10         void *data;
  11         struct iter head;
  12         struct searchable_ops ops;
  13 };
  14
  15 static void search_lock(void)
  16 {
  17         editable_lock();
  18 }
  19
  20 static void search_unlock(void)
  21 {
  22         editable_unlock();
  23 }
  24
  25 /* returns next matching track (can be current!) or NULL if not found */
  26 static int do_search(struct searchable *s, struct iter *iter, const char *text, int direction)
  27 {
  28         while (1) {
  29                 if (s->ops.matches(s->data, iter, text))
  30                         return 1;
  31                 if (direction == SEARCH_FORWARD) {
  32                         if (!s->ops.get_next(iter))
  33                                 return 0;
  34                 } else {
  35                         if (!s->ops.get_prev(iter))
  36                                 return 0;
  37                 }
  38         }
  39 }
  40
  41 struct searchable *searchable_new(void *data, const struct iter *head, const struct searchable_ops *ops)
  42 {
  43         struct searchable *s;
  44
  45         s = xnew(struct searchable, 1);
  46         s->data = data;
  47         s->head = *head;
  48         s->ops = *ops;
  49         return s;
  50 }
  51
  52 void searchable_free(struct searchable *s)
  53 {
  54         free(s);
  55 }
  56
  57 int search(struct searchable *s, const char *text, enum search_direction dir, int beginning)
  58 {
  59         struct iter iter;
  60         int ret;
  61
  62         search_lock();
  63         if (beginning) {
  64                 /* first or last item */
  65                 iter = s->head;
  66                 if (dir == SEARCH_FORWARD){
  67                         ret = s->ops.get_next(&iter);
  68                 } else {
  69                         ret = s->ops.get_prev(&iter);
  70                 }
  71         } else {
  72                 /* selected item */
  73                 ret = s->ops.get_current(s->data, &iter);
  74         }
  75         if (ret)
  76                 ret = do_search(s, &iter, text, dir);
  77         search_unlock();
  78         return ret;
  79 }
  80
  81 int search_next(struct searchable *s, const char *text, enum search_direction dir)
  82 {
  83         struct iter iter;
  84         int ret;
  85
  86         search_lock();
  87         if (!s->ops.get_current(s->data, &iter)) {
  88                 search_unlock();
  89                 return 0;
  90         }
  91         if (dir == SEARCH_FORWARD) {
  92                 ret = s->ops.get_next(&iter);
  93         } else {
  94                 ret = s->ops.get_prev(&iter);
  95         }
  96         if (ret)
  97                 ret = do_search(s, &iter, text, dir);
  98         search_unlock();
  99         return ret;
 100 }