p≡p trac…repos/pEpEngine / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
src/stringpair.c
author Volker Birk <vb@pep-project.org>
Mon, 25 May 2015 23:31:17 +0200
changeset 281 9f7691853773
parent 125 5119178815d8
child 301 d8b44dc4b0c8
permissions -rw-r--r--
opt_fields added with decrypt 
     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     pair = calloc(1, sizeof(stringpair_t));

    17     assert(pair);

    18     if (pair == NULL)

    19         goto enomem;

    20 

    21     pair->key = strdup(key);

    22     assert(pair->key);

    23     if (pair->key == NULL)

    24         goto enomem;

    25 

    26     pair->value = strdup(value);

    27     assert(pair->value);

    28     if (pair->value == NULL)

    29         goto enomem;

    30 

    31     return pair;

    32 

    33 enomem:

    34     free_stringpair(pair);

    35     return NULL;

    36 }

    37 

    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 }

    46 

    47 DYNAMIC_API stringpair_t * stringpair_dup(const stringpair_t *src)

    48 {

    49     assert(src);

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

    51 }

    52 

    53 DYNAMIC_API stringpair_list_t *new_stringpair_list(stringpair_t *value)

    54 {

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

    56     assert(result);

    57 

    58     if (result && value)

    59         result->value = value;

    60 

    61     return result;

    62 }

    63 

    64 DYNAMIC_API stringpair_list_t *stringpair_list_dup(

    65         const stringpair_list_t *src

    66     )

    67 {

    68     assert(src);

    69     if (src == NULL)

    70         return NULL;

    71 

    72     stringpair_list_t *dst = new_stringpair_list(src->value);

    73     if (dst == NULL)

    74         return NULL;

    75 

    76     if (src->next) {

    77         dst->next = stringpair_list_dup(src->next);

    78         if (dst->next == NULL) {

    79             free_stringpair_list(dst);

    80             return NULL;

    81         }

    82     }

    83 

    84     return dst;

    85 }

    86 

    87 DYNAMIC_API stringpair_list_t *stringpair_list_add(

    88         stringpair_list_t *stringpair_list,

    89         stringpair_t *value

    90     )

    91 {

    92     assert(value);

    93 

    94     if (stringpair_list == NULL)

    95         return new_stringpair_list(value);

    96 

    97     if (stringpair_list->next)

    98         return stringpair_list_add(stringpair_list->next, value);

    99 

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

   101         stringpair_list->value = value;

   102         return stringpair_list;

   103     }

   104 

   105     stringpair_list->next = new_stringpair_list(value);

   106     if (stringpair_list->next == NULL)

   107         return NULL;

   108 

   109     return stringpair_list->next;

   110 }

   111 

   112 DYNAMIC_API stringpair_list_t *stringpair_list_append(

   113         stringpair_list_t *stringpair_list,

   114         stringpair_list_t *second

   115     )

   116 {

   117     assert(stringpair_list);

   118 

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

   120         return stringpair_list;

   121 

   122     stringpair_list_t *_s = stringpair_list;

   123     stringpair_list_t *_s2;

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

   125         _s = stringpair_list_add(_s, _s2->value);

   126         if (_s == NULL)

   127             return NULL;

   128     }

   129     return _s;

   130 }

   131 

   132 DYNAMIC_API int stringpair_list_length(

   133         const stringpair_list_t *stringpair_list

   134     )

   135 {

   136     int len = 1;

   137     stringpair_list_t *_stringpair_list;

   138 

   139     assert(stringpair_list);

   140 

   141     if (stringpair_list->value == NULL)

   142         return 0;

   143 

   144     for (_stringpair_list=stringpair_list->next; _stringpair_list!=NULL;

   145             _stringpair_list=_stringpair_list->next)

   146         len += 1;

   147 

   148     return len;

   149 }

   150 

   151 DYNAMIC_API void free_stringpair_list(stringpair_list_t *stringpair_list)

   152 {

   153     if (stringpair_list) {

   154         free_stringpair_list(stringpair_list->next);

   155         free_stringpair(stringpair_list->value);

   156         free(stringpair_list);

   157     }

   158 }

   159 

   160 DYNAMIC_API stringpair_list_t *stringpair_list_find(

   161         stringpair_list_t *stringpair_list,

   162         const char *key

   163     )

   164 {

   165     assert(key);

   166 

   167     stringpair_list_t *_l;

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

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

   170             return _l;

   171     }

   172 

   173     return NULL;

   174 }

   175
repos/pEpEngine