src/stringpair.c
author Krista Grothoff <krista@pep-project.org>
Mon, 17 Oct 2016 13:15:11 +0200
changeset 1283 e5b5143795b5
parent 909 e39e9fec2da0
child 1284 ced04ed25f9b
permissions -rw-r--r--
assert without if
     1 #include "pEp_internal.h"
     2 
     3 #include <stdlib.h>
     4 #include <assert.h>
     5 #include <string.h>
     6 
     7 #include "stringpair.h"
     8 
     9 DYNAMIC_API stringpair_t * new_stringpair(const char *key, const char *value)
    10 {
    11     stringpair_t *pair = NULL;
    12 
    13     assert(key);
    14     assert(value);
    15 
    16     if (!key || !value) {
    17         return NULL;
    18     }
    19     
    20     pair = calloc(1, sizeof(stringpair_t));
    21     assert(pair);
    22     if (pair == NULL)
    23         goto enomem;
    24 
    25     pair->key = strdup(key);
    26     assert(pair->key);
    27     if (pair->key == NULL)
    28         goto enomem;
    29 
    30     pair->value = strdup(value);
    31     assert(pair->value);
    32     if (pair->value == NULL)
    33         goto enomem;
    34 
    35     return pair;
    36 
    37 enomem:
    38     free_stringpair(pair);
    39     return NULL;
    40 }
    41 
    42 DYNAMIC_API void free_stringpair(stringpair_t * pair)
    43 {
    44     if (pair) {
    45         free(pair->key);
    46         free(pair->value);
    47         free(pair);
    48     }
    49 }
    50 
    51 DYNAMIC_API stringpair_t * stringpair_dup(const stringpair_t *src)
    52 {
    53     assert(src);
    54     if (src == NULL)
    55         return NULL;
    56     
    57     return new_stringpair(src->key, src->value);
    58 }
    59 
    60 DYNAMIC_API stringpair_list_t *new_stringpair_list(stringpair_t *value)
    61 {
    62     stringpair_list_t *result = calloc(1, sizeof(stringpair_list_t));
    63     assert(result);
    64 
    65     if (result && value)
    66         result->value = value;
    67     
    68     return result;
    69 }
    70 
    71 DYNAMIC_API stringpair_list_t *stringpair_list_dup(
    72         const stringpair_list_t *src
    73     )
    74 {
    75     assert(src);
    76     if (src == NULL)
    77         return NULL;
    78 
    79     stringpair_t* copy_pair = stringpair_dup(src->value);
    80     
    81     stringpair_list_t *dst = new_stringpair_list(copy_pair);
    82     if (dst == NULL)
    83         return NULL;
    84 
    85     stringpair_list_t* src_curr = src->next;
    86     stringpair_list_t** dst_curr_ptr = &dst->next;
    87 
    88     while (src_curr) {
    89         copy_pair = stringpair_dup(src_curr->value);
    90         if (copy_pair == NULL) {
    91             free_stringpair_list(dst);
    92             return NULL;
    93         }
    94         *dst_curr_ptr = new_stringpair_list(copy_pair);
    95         if (*dst_curr_ptr == NULL) {
    96             free_stringpair(copy_pair);
    97             free_stringpair_list(dst);
    98             return NULL;
    99         }
   100         src_curr = src_curr->next;
   101         dst_curr_ptr = &((*dst_curr_ptr)->next);
   102     }
   103 
   104     return dst;
   105     
   106 }
   107 
   108 DYNAMIC_API stringpair_list_t *stringpair_list_add(
   109         stringpair_list_t *stringpair_list,
   110         stringpair_t *value
   111     )
   112 {
   113     assert(value);
   114 
   115     // empty list (no nodes)
   116     if (stringpair_list == NULL)
   117         return new_stringpair_list(value);
   118 
   119     // empty list (one node, no value)
   120     if (stringpair_list->value == NULL) {
   121         if (stringpair_list->next)
   122             return NULL; // invalid list
   123             
   124         stringpair_list->value = value;
   125         assert(stringpair_list->value);
   126         
   127         if (stringpair_list->value == NULL)
   128             return NULL;
   129         
   130         return stringpair_list;
   131     }
   132     
   133     stringpair_list_t* list_curr = stringpair_list;
   134     
   135     while (list_curr->next)
   136         list_curr = list_curr->next;
   137      
   138     list_curr->next = new_stringpair_list(value);
   139 
   140     assert(list_curr->next);
   141     if (list_curr->next == NULL)
   142         return NULL;
   143 
   144     return list_curr->next;
   145     
   146 }
   147 
   148 DYNAMIC_API stringpair_list_t *stringpair_list_append(
   149         stringpair_list_t *stringpair_list,
   150         stringpair_list_t *second
   151     )
   152 {
   153     assert(stringpair_list);
   154     if (stringpair_list == NULL)
   155         return NULL;
   156 
   157     // second list is empty
   158     if (second == NULL || second->value == NULL)
   159         return stringpair_list;
   160 
   161     stringpair_list_t *_s = stringpair_list;
   162     stringpair_list_t *_s2;
   163     for (_s2 = second; _s2 != NULL; _s2 = _s2->next) {
   164         stringpair_t *_sp = stringpair_dup(_s2->value);
   165         if (_sp == NULL)
   166             return NULL;
   167         _s = stringpair_list_add(_s, _sp);
   168         if (_s == NULL){
   169             free_stringpair(_sp);
   170             return NULL;
   171         }
   172     }
   173     return _s;
   174 }
   175 
   176 DYNAMIC_API int stringpair_list_length(
   177         const stringpair_list_t *stringpair_list
   178     )
   179 {
   180     int len = 0;
   181 
   182     const stringpair_list_t *_sl;
   183     for (_sl = stringpair_list; _sl && _sl->value; _sl = _sl->next)
   184         len++;
   185 
   186     return len;
   187 }
   188 
   189 DYNAMIC_API void free_stringpair_list(stringpair_list_t *stringpair_list)
   190 {
   191     if (stringpair_list) {
   192         free_stringpair_list(stringpair_list->next);
   193         free_stringpair(stringpair_list->value);
   194         free(stringpair_list);
   195     }
   196 }
   197 
   198 DYNAMIC_API stringpair_list_t *stringpair_list_find(
   199         stringpair_list_t *stringpair_list,
   200         const char *key
   201     )
   202 {
   203     assert(key);
   204 
   205     stringpair_list_t *_l;
   206     for (_l = stringpair_list; _l; _l = _l->next) {
   207         if (strcoll(key, _l->value->key) == 0)
   208             return _l;
   209     }
   210 
   211     return NULL;
   212 }
   213