slist.c

Go to the documentation of this file.

 
#include "config.h"
#include <stddef.h>
#include "slist.h"
#include "buffer.h"
#include "list.h"
#include "memory.h"
#include "queue.h"
#include "string2.h"
 
struct Slist *slist_new(uint32_t flags)
{
  struct Slist *list = mutt_mem_calloc(1, sizeof(*list));
  list->flags = flags;
  STAILQ_INIT(&list->head);
 
  return list;
}
 
struct Slist *slist_add_list(struct Slist *list, const struct Slist *add)
{
  if (!add)
    return list;
  if (!list)
    return slist_dup(add);
 
  struct ListNode *np = NULL;
  STAILQ_FOREACH(np, &add->head, entries)
  {
    mutt_list_insert_tail(&list->head, mutt_str_dup((char *) np->data));
    list->count++;
  }
  return list;
}
 
struct Slist *slist_add_string(struct Slist *list, const char *str)
{
  if (!list)
    return NULL;
 
  if (str && (str[0] == '\0'))
    str = NULL;
 
  if (!str && !(list->flags & SLIST_ALLOW_EMPTY))
    return list;
 
  mutt_list_insert_tail(&list->head, mutt_str_dup(str));
  list->count++;
 
  return list;
}
 
bool slist_compare(const struct Slist *a, const struct Slist *b)
{
  if (!a && !b) /* both empty */
    return true;
  if (!a ^ !b) /* one is empty, but not the other */
    return false;
  if (a->count != b->count)
    return false;
 
  return mutt_list_compare(&a->head, &b->head);
}
 
struct Slist *slist_dup(const struct Slist *list)
{
  if (!list)
    return NULL;
 
  struct Slist *list_new = slist_new(list->flags);
 
  struct ListNode *np = NULL;
  STAILQ_FOREACH(np, &list->head, entries)
  {
    mutt_list_insert_tail(&list_new->head, mutt_str_dup(np->data));
  }
  list_new->count = list->count;
  return list_new;
}
 
struct Slist *slist_empty(struct Slist **list)
{
  if (!list || !*list)
    return NULL;
 
  mutt_list_free(&(*list)->head);
 
  if ((*list)->flags & SLIST_ALLOW_EMPTY)
  {
    (*list)->count = 0;
    return *list;
  }
 
  FREE(list);
  return NULL;
}
 
void slist_free(struct Slist **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  struct Slist *slist = *ptr;
  mutt_list_free(&slist->head);
 
  FREE(ptr);
}
 
bool slist_is_empty(const struct Slist *list)
{
  if (!list)
    return true;
 
  return list->count == 0;
}
 
bool slist_is_member(const struct Slist *list, const char *str)
{
  if (!list)
    return false;
 
  if (!str && !(list->flags & SLIST_ALLOW_EMPTY))
    return false;
 
  struct ListNode *np = NULL;
  STAILQ_FOREACH(np, &list->head, entries)
  {
    if (mutt_str_equal(np->data, str))
      return true;
  }
  return false;
}
 
struct Slist *slist_parse(const char *str, uint32_t flags)
{
  char *src = mutt_str_dup(str);
  if (!src && !(flags & SLIST_ALLOW_EMPTY))
    return NULL;
 
  char sep = ' ';
  if ((flags & SLIST_SEP_MASK) == SLIST_SEP_COMMA)
    sep = ',';
  else if ((flags & SLIST_SEP_MASK) == SLIST_SEP_COLON)
    sep = ':';
 
  struct Slist *list = mutt_mem_calloc(1, sizeof(struct Slist));
  list->flags = flags;
  STAILQ_INIT(&list->head);
 
  if (!src)
    return list;
 
  char *start = src;
  for (char *p = start; *p; p++)
  {
    if ((p[0] == '\\') && (p[1] != '\0'))
    {
      p++;
      continue;
    }
 
    if (p[0] == sep)
    {
      p[0] = '\0';
      if (slist_is_member(list, start))
      {
        start = p + 1;
        continue;
      }
      mutt_list_insert_tail(&list->head, mutt_str_dup(start));
      list->count++;
      start = p + 1;
    }
  }
 
  if (!slist_is_member(list, start))
  {
    mutt_list_insert_tail(&list->head, mutt_str_dup(start));
    list->count++;
  }
 
  FREE(&src);
  return list;
}
 
struct Slist *slist_remove_string(struct Slist *list, const char *str)
{
  if (!list)
    return NULL;
  if (!str && !(list->flags & SLIST_ALLOW_EMPTY))
    return list;
 
  struct ListNode *prev = NULL;
  struct ListNode *np = NULL;
  struct ListNode *tmp = NULL;
  STAILQ_FOREACH_SAFE(np, &list->head, entries, tmp)
  {
    if (mutt_str_equal(np->data, str))
    {
      if (prev)
        STAILQ_REMOVE_AFTER(&list->head, prev, entries);
      else
        STAILQ_REMOVE_HEAD(&list->head, entries);
      FREE(&np->data);
      FREE(&np);
      list->count--;
      break;
    }
    prev = np;
  }
  return list;
}
 
int slist_to_buffer(const struct Slist *list, struct Buffer *buf)
{
  if (!list || !buf || (list->count == 0))
    return 0;
 
  struct ListNode *np = NULL;
  STAILQ_FOREACH(np, &list->head, entries)
  {
    buf_addstr(buf, np->data);
    if (STAILQ_NEXT(np, entries))
    {
      const int sep = (list->flags & SLIST_SEP_MASK);
      if (sep == SLIST_SEP_COMMA)
        buf_addch(buf, ',');
      else if (sep == SLIST_SEP_COLON)
        buf_addch(buf, ':');
      else
        buf_addch(buf, ' ');
    }
  }
 
  return list->count;
}