Line data    Source code

       1             : /* SPDX-License-Identifier: LGPL-2.1+ */
       2             : #pragma once
       3             : 
       4             : #include "extract-word.h"
       5             : #include "hashmap.h"
       6             : #include "macro.h"
       7             : 
       8             : Set *internal_set_new(const struct hash_ops *hash_ops HASHMAP_DEBUG_PARAMS);
       9             : #define set_new(ops) internal_set_new(ops HASHMAP_DEBUG_SRC_ARGS)
      10             : 
      11       13348 : static inline Set *set_free(Set *s) {
      12       13348 :         return (Set*) internal_hashmap_free(HASHMAP_BASE(s), NULL, NULL);
      13             : }
      14             : 
      15       28849 : static inline Set *set_free_free(Set *s) {
      16       28849 :         return (Set*) internal_hashmap_free(HASHMAP_BASE(s), free, NULL);
      17             : }
      18             : 
      19             : /* no set_free_free_free */
      20             : 
      21             : static inline Set *set_copy(Set *s) {
      22             :         return (Set*) internal_hashmap_copy(HASHMAP_BASE(s));
      23             : }
      24             : 
      25             : int internal_set_ensure_allocated(Set **s, const struct hash_ops *hash_ops HASHMAP_DEBUG_PARAMS);
      26             : #define set_ensure_allocated(h, ops) internal_set_ensure_allocated(h, ops HASHMAP_DEBUG_SRC_ARGS)
      27             : 
      28             : int set_put(Set *s, const void *key);
      29             : /* no set_update */
      30             : /* no set_replace */
      31       26883 : static inline void *set_get(const Set *s, void *key) {
      32       26883 :         return internal_hashmap_get(HASHMAP_BASE((Set *) s), key);
      33             : }
      34             : /* no set_get2 */
      35             : 
      36        8533 : static inline bool set_contains(const Set *s, const void *key) {
      37        8533 :         return internal_hashmap_contains(HASHMAP_BASE((Set *) s), key);
      38             : }
      39             : 
      40        6891 : static inline void *set_remove(Set *s, const void *key) {
      41        6891 :         return internal_hashmap_remove(HASHMAP_BASE(s), key);
      42             : }
      43             : 
      44             : /* no set_remove2 */
      45             : /* no set_remove_value */
      46             : int set_remove_and_put(Set *s, const void *old_key, const void *new_key);
      47             : /* no set_remove_and_replace */
      48             : int set_merge(Set *s, Set *other);
      49             : 
      50           0 : static inline int set_reserve(Set *h, unsigned entries_add) {
      51           0 :         return internal_hashmap_reserve(HASHMAP_BASE(h), entries_add);
      52             : }
      53             : 
      54          27 : static inline int set_move(Set *s, Set *other) {
      55          27 :         return internal_hashmap_move(HASHMAP_BASE(s), HASHMAP_BASE(other));
      56             : }
      57             : 
      58             : static inline int set_move_one(Set *s, Set *other, const void *key) {
      59             :         return internal_hashmap_move_one(HASHMAP_BASE(s), HASHMAP_BASE(other), key);
      60             : }
      61             : 
      62       39718 : static inline unsigned set_size(const Set *s) {
      63       39718 :         return internal_hashmap_size(HASHMAP_BASE((Set *) s));
      64             : }
      65             : 
      66       31764 : static inline bool set_isempty(const Set *s) {
      67       31764 :         return set_size(s) == 0;
      68             : }
      69             : 
      70             : static inline unsigned set_buckets(const Set *s) {
      71             :         return internal_hashmap_buckets(HASHMAP_BASE((Set *) s));
      72             : }
      73             : 
      74             : bool set_iterate(const Set *s, Iterator *i, void **value);
      75             : 
      76           0 : static inline void set_clear(Set *s) {
      77           0 :         internal_hashmap_clear(HASHMAP_BASE(s), NULL, NULL);
      78           0 : }
      79             : 
      80           0 : static inline void set_clear_free(Set *s) {
      81           0 :         internal_hashmap_clear(HASHMAP_BASE(s), free, NULL);
      82           0 : }
      83             : 
      84             : /* no set_clear_free_free */
      85             : 
      86       15299 : static inline void *set_steal_first(Set *s) {
      87       15299 :         return internal_hashmap_first_key_and_value(HASHMAP_BASE(s), true, NULL);
      88             : }
      89             : 
      90             : #define set_clear_with_destructor(_s, _f)               \
      91             :         ({                                              \
      92             :                 void *_item;                            \
      93             :                 while ((_item = set_steal_first(_s)))   \
      94             :                         _f(_item);                      \
      95             :         })
      96             : #define set_free_with_destructor(_s, _f)                \
      97             :         ({                                              \
      98             :                 set_clear_with_destructor(_s, _f);      \
      99             :                 set_free(_s);                           \
     100             :         })
     101             : 
     102             : /* no set_steal_first_key */
     103             : /* no set_first_key */
     104             : 
     105           0 : static inline void *set_first(Set *s) {
     106           0 :         return internal_hashmap_first_key_and_value(HASHMAP_BASE(s), false, NULL);
     107             : }
     108             : 
     109             : /* no set_next */
     110             : 
     111           3 : static inline char **set_get_strv(Set *s) {
     112           3 :         return internal_hashmap_get_strv(HASHMAP_BASE(s));
     113             : }
     114             : 
     115             : int set_consume(Set *s, void *value);
     116             : int set_put_strdup(Set *s, const char *p);
     117             : int set_put_strdupv(Set *s, char **l);
     118             : int set_put_strsplit(Set *s, const char *v, const char *separators, ExtractFlags flags);
     119             : 
     120             : #define SET_FOREACH(e, s, i) \
     121             :         for ((i) = ITERATOR_FIRST; set_iterate((s), &(i), (void**)&(e)); )
     122             : 
     123             : #define SET_FOREACH_MOVE(e, d, s)                                       \
     124             :         for (; ({ e = set_first(s); assert_se(!e || set_move_one(d, s, e) >= 0); e; }); )
     125             : 
     126        2036 : DEFINE_TRIVIAL_CLEANUP_FUNC(Set*, set_free);
     127        7580 : DEFINE_TRIVIAL_CLEANUP_FUNC(Set*, set_free_free);
     128             : 
     129             : #define _cleanup_set_free_ _cleanup_(set_freep)
     130             : #define _cleanup_set_free_free_ _cleanup_(set_free_freep)