Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: LGPL-2.1+ */
       2                 :            : 
       3                 :            : #include "fileio.h"
       4                 :            : #include "ordered-set.h"
       5                 :            : #include "strv.h"
       6                 :            : 
       7                 :         12 : int ordered_set_consume(OrderedSet *s, void *p) {
       8                 :            :         int r;
       9                 :            : 
      10                 :         12 :         r = ordered_set_put(s, p);
      11         [ +  + ]:         12 :         if (r <= 0)
      12                 :          4 :                 free(p);
      13                 :            : 
      14                 :         12 :         return r;
      15                 :            : }
      16                 :            : 
      17                 :         12 : int ordered_set_put_strdup(OrderedSet *s, const char *p) {
      18                 :            :         char *c;
      19                 :            :         int r;
      20                 :            : 
      21         [ -  + ]:         12 :         assert(s);
      22         [ -  + ]:         12 :         assert(p);
      23                 :            : 
      24                 :         12 :         c = strdup(p);
      25         [ -  + ]:         12 :         if (!c)
      26                 :          0 :                 return -ENOMEM;
      27                 :            : 
      28                 :         12 :         r = ordered_set_consume(s, c);
      29         [ +  + ]:         12 :         if (r == -EEXIST)
      30                 :          4 :                 return 0;
      31                 :            : 
      32                 :          8 :         return r;
      33                 :            : }
      34                 :            : 
      35                 :          0 : int ordered_set_put_strdupv(OrderedSet *s, char **l) {
      36                 :          0 :         int n = 0, r;
      37                 :            :         char **i;
      38                 :            : 
      39   [ #  #  #  # ]:          0 :         STRV_FOREACH(i, l) {
      40                 :          0 :                 r = ordered_set_put_strdup(s, *i);
      41         [ #  # ]:          0 :                 if (r < 0)
      42                 :          0 :                         return r;
      43                 :            : 
      44                 :          0 :                 n += r;
      45                 :            :         }
      46                 :            : 
      47                 :          0 :         return n;
      48                 :            : }
      49                 :            : 
      50                 :          4 : int ordered_set_put_string_set(OrderedSet *s, OrderedSet *l) {
      51                 :          4 :         int n = 0, r;
      52                 :            :         Iterator i;
      53                 :            :         char *p;
      54                 :            : 
      55                 :            :         /* Like ordered_set_put_strv, but for an OrderedSet of strings */
      56                 :            : 
      57         [ +  + ]:         16 :         ORDERED_SET_FOREACH(p, l, i) {
      58                 :         12 :                 r = ordered_set_put_strdup(s, p);
      59         [ -  + ]:         12 :                 if (r < 0)
      60                 :          0 :                         return r;
      61                 :            : 
      62                 :         12 :                 n += r;
      63                 :            :         }
      64                 :            : 
      65                 :          4 :         return n;
      66                 :            : }
      67                 :            : 
      68                 :         16 : void ordered_set_print(FILE *f, const char *field, OrderedSet *s) {
      69                 :         16 :         bool space = false;
      70                 :            :         Iterator i;
      71                 :            :         char *p;
      72                 :            : 
      73         [ +  + ]:         16 :         if (ordered_set_isempty(s))
      74                 :          4 :                 return;
      75                 :            : 
      76                 :         12 :         fputs(field, f);
      77                 :            : 
      78         [ +  + ]:         56 :         ORDERED_SET_FOREACH(p, s, i)
      79                 :         44 :                 fputs_with_space(f, p, NULL, &space);
      80                 :            : 
      81                 :         12 :         fputc('\n', f);
      82                 :            : }