slist.c

Go to the documentation of this file.

 
#include "config.h"
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include "mutt/lib.h"
#include "set.h"
#include "types.h"
 
static void slist_destroy(void *var, const struct ConfigDef *cdef)
{
  struct Slist **l = (struct Slist **) var;
  if (!*l)
    return;
 
  slist_free(l);
}
 
static int slist_string_set(void *var, struct ConfigDef *cdef,
                            const char *value, struct Buffer *err)
{
  /* Store empty string list as NULL */
  if (value && (value[0] == '\0'))
    value = NULL;
 
  struct Slist *list = NULL;
 
  int rc = CSR_SUCCESS;
 
  if (var)
  {
    list = slist_parse(value, cdef->type);
 
    if (slist_equal(list, *(struct Slist **) var))
    {
      slist_free(&list);
      return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
    }
 
    if (startup_only(cdef, err))
    {
      slist_free(&list);
      return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
    }
 
    if (cdef->validator)
    {
      rc = cdef->validator(cdef, (intptr_t) list, err);
 
      if (CSR_RESULT(rc) != CSR_SUCCESS)
      {
        slist_free(&list);
        return rc | CSR_INV_VALIDATOR;
      }
    }
 
    slist_destroy(var, cdef);
 
    *(struct Slist **) var = list;
 
    if (!list)
      rc |= CSR_SUC_EMPTY;
  }
  else
  {
    if (cdef->type & D_INTERNAL_INITIAL_SET)
      FREE(&cdef->initial);
 
    cdef->type |= D_INTERNAL_INITIAL_SET;
    cdef->initial = (intptr_t) mutt_str_dup(value);
  }
 
  return rc;
}
 
static int slist_string_get(void *var, const struct ConfigDef *cdef, struct Buffer *result)
{
  if (var)
  {
    struct Slist *list = *(struct Slist **) var;
    if (!list)
      return CSR_SUCCESS | CSR_SUC_EMPTY; /* empty string */
 
    slist_to_buffer(list, result);
  }
  else
  {
    buf_addstr(result, (char *) cdef->initial);
  }
 
  int rc = CSR_SUCCESS;
  if (buf_is_empty(result))
    rc |= CSR_SUC_EMPTY;
 
  return rc;
}
 
static int slist_native_set(void *var, const struct ConfigDef *cdef,
                            intptr_t value, struct Buffer *err)
{
  int rc;
 
  if (slist_equal((struct Slist *) value, *(struct Slist **) var))
    return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
 
  if (startup_only(cdef, err))
    return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
 
  if (cdef->validator)
  {
    rc = cdef->validator(cdef, value, err);
 
    if (CSR_RESULT(rc) != CSR_SUCCESS)
      return rc | CSR_INV_VALIDATOR;
  }
 
  slist_free(var);
 
  struct Slist *list = slist_dup((struct Slist *) value);
 
  rc = CSR_SUCCESS;
  if (!list)
    rc |= CSR_SUC_EMPTY;
 
  *(struct Slist **) var = list;
  return rc;
}
 
static intptr_t slist_native_get(void *var, const struct ConfigDef *cdef, struct Buffer *err)
{
  struct Slist *list = *(struct Slist **) var;
 
  return (intptr_t) list;
}
 
static int slist_string_plus_equals(void *var, const struct ConfigDef *cdef,
                                    const char *value, struct Buffer *err)
{
  int rc = CSR_SUCCESS;
 
  /* Store empty strings as NULL */
  if (value && (value[0] == '\0'))
    value = NULL;
 
  if (!value)
    return rc | CSR_SUC_NO_CHANGE;
 
  if (startup_only(cdef, err))
    return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
 
  struct Slist *orig = *(struct Slist **) var;
  if (slist_is_member(orig, value))
    return rc | CSR_SUC_NO_CHANGE;
 
  struct Slist *copy = slist_dup(orig);
  if (!copy)
    copy = slist_new(cdef->type & D_SLIST_SEP_MASK);
 
  slist_add_string(copy, value);
 
  if (cdef->validator)
  {
    rc = cdef->validator(cdef, (intptr_t) copy, err);
    if (CSR_RESULT(rc) != CSR_SUCCESS)
    {
      slist_free(&copy);
      return rc | CSR_INV_VALIDATOR;
    }
  }
 
  slist_free(&orig);
  *(struct Slist **) var = copy;
 
  return rc;
}
 
static int slist_string_minus_equals(void *var, const struct ConfigDef *cdef,
                                     const char *value, struct Buffer *err)
{
  int rc = CSR_SUCCESS;
 
  /* Store empty strings as NULL */
  if (value && (value[0] == '\0'))
    value = NULL;
 
  if (!value)
    return rc | CSR_SUC_NO_CHANGE;
 
  if (startup_only(cdef, err))
    return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
 
  struct Slist *orig = *(struct Slist **) var;
  if (!slist_is_member(orig, value))
    return rc | CSR_SUC_NO_CHANGE;
 
  struct Slist *copy = slist_dup(orig);
  slist_remove_string(copy, value);
 
  if (cdef->validator)
  {
    rc = cdef->validator(cdef, (intptr_t) copy, err);
    if (CSR_RESULT(rc) != CSR_SUCCESS)
    {
      slist_free(&copy);
      return rc | CSR_INV_VALIDATOR;
    }
  }
 
  slist_free(&orig);
  *(struct Slist **) var = copy;
 
  return rc;
}
 
static bool slist_has_been_set(void *var, const struct ConfigDef *cdef)
{
  struct Slist *list = NULL;
  const char *initial = (const char *) cdef->initial;
 
  if (initial)
    list = slist_parse(initial, cdef->type);
 
  bool rc = !slist_equal(list, *(struct Slist **) var);
  slist_free(&list);
  return rc;
}
 
static int slist_reset(void *var, const struct ConfigDef *cdef, struct Buffer *err)
{
  struct Slist *list = NULL;
  const char *initial = (const char *) cdef->initial;
 
  if (initial)
    list = slist_parse(initial, cdef->type);
 
  if (slist_equal(list, *(struct Slist **) var))
  {
    slist_free(&list);
    return CSR_SUCCESS | CSR_SUC_NO_CHANGE;
  }
 
  if (startup_only(cdef, err))
  {
    slist_free(&list);
    return CSR_ERR_INVALID | CSR_INV_VALIDATOR;
  }
 
  int rc = CSR_SUCCESS;
 
  if (cdef->validator)
  {
    rc = cdef->validator(cdef, (intptr_t) list, err);
 
    if (CSR_RESULT(rc) != CSR_SUCCESS)
    {
      slist_destroy(&list, cdef);
      return rc | CSR_INV_VALIDATOR;
    }
  }
 
  if (!list)
    rc |= CSR_SUC_EMPTY;
 
  slist_destroy(var, cdef);
 
  *(struct Slist **) var = list;
  return rc;
}
 
const struct ConfigSetType CstSlist = {
  DT_SLIST,
  "slist",
  slist_string_set,
  slist_string_get,
  slist_native_set,
  slist_native_get,
  slist_string_plus_equals,
  slist_string_minus_equals,
  slist_has_been_set,
  slist_reset,
  slist_destroy,
};