Line data    Source code

       1             : /* SPDX-License-Identifier: LGPL-2.1+ */
       2             : #pragma once
       3             : 
       4             : #include <stdio.h>
       5             : 
       6             : #include "hashmap.h"
       7             : 
       8             : typedef struct OrderedSet OrderedSet;
       9             : 
      10           5 : static inline OrderedSet* ordered_set_new(const struct hash_ops *ops) {
      11           5 :         return (OrderedSet*) ordered_hashmap_new(ops);
      12             : }
      13             : 
      14           0 : static inline int ordered_set_ensure_allocated(OrderedSet **s, const struct hash_ops *ops) {
      15           0 :         if (*s)
      16           0 :                 return 0;
      17             : 
      18           0 :         *s = ordered_set_new(ops);
      19           0 :         if (!*s)
      20           0 :                 return -ENOMEM;
      21             : 
      22           0 :         return 0;
      23             : }
      24             : 
      25           4 : static inline OrderedSet* ordered_set_free(OrderedSet *s) {
      26           4 :         return (OrderedSet*) ordered_hashmap_free((OrderedHashmap*) s);
      27             : }
      28             : 
      29          91 : static inline OrderedSet* ordered_set_free_free(OrderedSet *s) {
      30          91 :         return (OrderedSet*) ordered_hashmap_free_free((OrderedHashmap*) s);
      31             : }
      32             : 
      33          22 : static inline int ordered_set_put(OrderedSet *s, void *p) {
      34          22 :         return ordered_hashmap_put((OrderedHashmap*) s, p, p);
      35             : }
      36             : 
      37           0 : static inline unsigned ordered_set_size(OrderedSet *s) {
      38           0 :         return ordered_hashmap_size((OrderedHashmap*) s);
      39             : }
      40             : 
      41           5 : static inline bool ordered_set_isempty(OrderedSet *s) {
      42           5 :         return ordered_hashmap_isempty((OrderedHashmap*) s);
      43             : }
      44             : 
      45          18 : static inline bool ordered_set_iterate(OrderedSet *s, Iterator *i, void **value) {
      46          18 :         return ordered_hashmap_iterate((OrderedHashmap*) s, i, value, NULL);
      47             : }
      48             : 
      49           1 : static inline void* ordered_set_remove(OrderedSet *s, void *p) {
      50           1 :         return ordered_hashmap_remove((OrderedHashmap*) s, p);
      51             : }
      52             : 
      53           4 : static inline void* ordered_set_steal_first(OrderedSet *s) {
      54           4 :         return ordered_hashmap_steal_first((OrderedHashmap*) s);
      55             : }
      56             : 
      57           2 : static inline char **ordered_set_get_strv(OrderedSet *s) {
      58           2 :         return internal_hashmap_get_strv(HASHMAP_BASE((OrderedHashmap*) s));
      59             : }
      60             : 
      61             : int ordered_set_consume(OrderedSet *s, void *p);
      62             : int ordered_set_put_strdup(OrderedSet *s, const char *p);
      63             : int ordered_set_put_strdupv(OrderedSet *s, char **l);
      64             : int ordered_set_put_string_set(OrderedSet *s, OrderedSet *l);
      65             : void ordered_set_print(FILE *f, const char *field, OrderedSet *s);
      66             : 
      67             : #define ORDERED_SET_FOREACH(e, s, i)                                    \
      68             :         for ((i) = ITERATOR_FIRST; ordered_set_iterate((s), &(i), (void**)&(e)); )
      69             : 
      70           3 : DEFINE_TRIVIAL_CLEANUP_FUNC(OrderedSet*, ordered_set_free);
      71           1 : DEFINE_TRIVIAL_CLEANUP_FUNC(OrderedSet*, ordered_set_free_free);
      72             : 
      73             : #define _cleanup_ordered_set_free_ _cleanup_(ordered_set_freep)
      74             : #define _cleanup_ordered_set_free_free_ _cleanup_(ordered_set_free_freep)