repos/pEpEngine: src/stringpair.c@b1695eef237b

     1 #include "pEp_internal.h"

     3 #include <stdlib.h>

     4 #include <assert.h>

     5 #include <string.h>

     7 #include "stringpair.h"

     9 DYNAMIC_API stringpair_t * new_stringpair(const char *key, const char *value)

    10 {

    11     stringpair_t *pair = NULL;

    13     assert(key);

    14     assert(value),

    16     pair = calloc(1, sizeof(stringpair_t));

    17     assert(pair);

    18     if (pair == NULL)

    19         goto enomem;

    21     pair->key = strdup(key);

    22     assert(pair->key);

    23     if (pair->key == NULL)

    24         goto enomem;

    26     pair->value = strdup(value);

    27     assert(pair->value);

    28     if (pair->value == NULL)

    29         goto enomem;

    31     return pair;

    33 enomem:

    34     free_stringpair(pair);

    35     return NULL;

    36 }

    38 DYNAMIC_API void free_stringpair(stringpair_t * pair)

    39 {

    40     if (pair) {

    41         free(pair->key);

    42         free(pair->value);

    43         free(pair);

    44     }

    45 }

    47 DYNAMIC_API stringpair_t * stringpair_dup(const stringpair_t *src)

    48 {

    49     assert(src);

    50     if (src == NULL)

    51         return NULL;

    53     return new_stringpair(src->key, src->value);

    54 }

    56 DYNAMIC_API stringpair_list_t *new_stringpair_list(stringpair_t *value)

    57 {

    58     stringpair_list_t *result = calloc(1, sizeof(stringpair_list_t));

    59     assert(result);

    61     if (result && value)

    62         result->value = value;

    64     result->next = NULL;

    66     return result;

    67 }

    69 DYNAMIC_API stringpair_list_t *stringpair_list_dup(

    70         const stringpair_list_t *src

    71     )

    72 {

    73     assert(src);

    74     if (src == NULL)

    75         return NULL;

    77     stringpair_t* copy_pair = stringpair_dup(src->value);

    79     stringpair_list_t *dst = new_stringpair_list(copy_pair);

    80     if (dst == NULL)

    81         return NULL;

    83     stringpair_list_t* src_curr = src->next;

    84     stringpair_list_t** dst_curr_ptr = &dst->next;

    86     while (src_curr) {

    87         copy_pair = stringpair_dup(src_curr->value);

    88         *dst_curr_ptr = new_stringpair_list(copy_pair);

    89         src_curr = src_curr->next;

    90         dst_curr_ptr = &((*dst_curr_ptr)->next);

    91     }

    93     return dst;

    95 }

    97 DYNAMIC_API stringpair_list_t *stringpair_list_add(

    98         stringpair_list_t *stringpair_list,

    99         stringpair_t *value

   100     )

   101 {

   102     assert(value);

   104     // empty list (no nodes)

   105     if (stringpair_list == NULL)

   106         return new_stringpair_list(value);

   108     // empty list (one node, no value)

   109     if (stringpair_list->value == NULL) {

   110         if (stringpair_list->next)

   111             return NULL; // invalid list

   113         stringpair_list->value = value;

   114         assert(stringpair_list->value);

   116         if (stringpair_list->value == NULL)

   117             return NULL;

   119         return stringpair_list;

   120     }

   122     stringpair_list_t* list_curr = stringpair_list;

   124     while (list_curr->next)

   125         list_curr = list_curr->next;

   127     list_curr->next = new_stringpair_list(value);

   129     assert(list_curr->next);

   130     if (list_curr->next == NULL)

   131         return NULL;

   133     return list_curr->next;

   135 }

   137 DYNAMIC_API stringpair_list_t *stringpair_list_append(

   138         stringpair_list_t *stringpair_list,

   139         stringpair_list_t *second

   140     )

   141 {

   142     assert(stringpair_list);

   143     if (stringpair_list == NULL)

   144         return NULL;

   146     // second list is empty

   147     if (second == NULL || second->value == NULL)

   148         return stringpair_list;

   150     stringpair_list_t *_s = stringpair_list;

   151     stringpair_list_t *_s2;

   152     for (_s2 = second; _s2 != NULL; _s2 = _s2->next) {

   153         stringpair_t *_sp = stringpair_dup(_s2->value);

   154         if (_sp == NULL)

   155             return NULL;

   156         _s = stringpair_list_add(_s, _sp);

   157         if (_s == NULL){

   158             free_stringpair(_sp);

   159             return NULL;

   160         }

   161     }

   162     return _s;

   163 }

   165 DYNAMIC_API int stringpair_list_length(

   166         const stringpair_list_t *stringpair_list

   167     )

   168 {

   169     int len = 0;

   171     const stringpair_list_t *_sl;

   172     for (_sl = stringpair_list; _sl && _sl->value; _sl = _sl->next)

   173         len++;

   175     return len;

   176 }

   178 DYNAMIC_API void free_stringpair_list(stringpair_list_t *stringpair_list)

   179 {

   180     if (stringpair_list) {

   181         free_stringpair_list(stringpair_list->next);

   182         free_stringpair(stringpair_list->value);

   183         free(stringpair_list);

   184     }

   185 }

   187 DYNAMIC_API stringpair_list_t *stringpair_list_find(

   188         stringpair_list_t *stringpair_list,

   189         const char *key

   190     )

   191 {

   192     assert(key);

   194     stringpair_list_t *_l;

   195     for (_l = stringpair_list; _l; _l = _l->next) {

   196         if (strcoll(key, _l->value->key) == 0)

   197             return _l;

   198     }

   200     return NULL;

   201 }

author	Krista Grothoff <krista@pep-project.org>
	Tue, 12 Jul 2016 13:32:55 +0200
changeset 843	b1695eef237b
parent 836	8e7dac747b49
child 895	79a4cc341524
permissions	-rw-r--r--