Line data    Source code

       1             : /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
       2             : 
       3             : #pragma once
       4             : 
       5             : /***
       6             :   This file is part of systemd.
       7             : 
       8             :   Copyright 2010 Lennart Poettering
       9             : 
      10             :   systemd is free software; you can redistribute it and/or modify it
      11             :   under the terms of the GNU Lesser General Public License as published by
      12             :   the Free Software Foundation; either version 2.1 of the License, or
      13             :   (at your option) any later version.
      14             : 
      15             :   systemd is distributed in the hope that it will be useful, but
      16             :   WITHOUT ANY WARRANTY; without even the implied warranty of
      17             :   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
      18             :   Lesser General Public License for more details.
      19             : 
      20             :   You should have received a copy of the GNU Lesser General Public License
      21             :   along with systemd; If not, see <http://www.gnu.org/licenses/>.
      22             : ***/
      23             : 
      24             : #include "hashmap.h"
      25             : #include "macro.h"
      26             : 
      27             : Set *internal_set_new(const struct hash_ops *hash_ops  HASHMAP_DEBUG_PARAMS);
      28             : #define set_new(ops) internal_set_new(ops  HASHMAP_DEBUG_SRC_ARGS)
      29             : 
      30             : 
      31       23471 : static inline void set_free(Set *s) {
      32       23471 :         internal_hashmap_free(HASHMAP_BASE(s));
      33       23471 : }
      34             : 
      35        2958 : static inline void set_free_free(Set *s) {
      36        2958 :         internal_hashmap_free_free(HASHMAP_BASE(s));
      37        2958 : }
      38             : 
      39             : /* no set_free_free_free */
      40             : 
      41             : static inline Set *set_copy(Set *s) {
      42             :         return (Set*) internal_hashmap_copy(HASHMAP_BASE(s));
      43             : }
      44             : 
      45             : int internal_set_ensure_allocated(Set **s, const struct hash_ops *hash_ops  HASHMAP_DEBUG_PARAMS);
      46             : #define set_ensure_allocated(h, ops) internal_set_ensure_allocated(h, ops  HASHMAP_DEBUG_SRC_ARGS)
      47             : 
      48             : int set_put(Set *s, const void *key);
      49             : /* no set_update */
      50             : /* no set_replace */
      51        4568 : static inline void *set_get(Set *s, void *key) {
      52        4568 :         return internal_hashmap_get(HASHMAP_BASE(s), key);
      53             : }
      54             : /* no set_get2 */
      55             : 
      56         799 : static inline bool set_contains(Set *s, const void *key) {
      57         799 :         return internal_hashmap_contains(HASHMAP_BASE(s), key);
      58             : }
      59             : 
      60       34031 : static inline void *set_remove(Set *s, const void *key) {
      61       34031 :         return internal_hashmap_remove(HASHMAP_BASE(s), key);
      62             : }
      63             : 
      64             : /* no set_remove2 */
      65             : /* no set_remove_value */
      66             : int set_remove_and_put(Set *s, const void *old_key, const void *new_key);
      67             : /* no set_remove_and_replace */
      68             : int set_merge(Set *s, Set *other);
      69             : 
      70           0 : static inline int set_reserve(Set *h, unsigned entries_add) {
      71           0 :         return internal_hashmap_reserve(HASHMAP_BASE(h), entries_add);
      72             : }
      73             : 
      74           0 : static inline int set_move(Set *s, Set *other) {
      75           0 :         return internal_hashmap_move(HASHMAP_BASE(s), HASHMAP_BASE(other));
      76             : }
      77             : 
      78             : static inline int set_move_one(Set *s, Set *other, const void *key) {
      79             :         return internal_hashmap_move_one(HASHMAP_BASE(s), HASHMAP_BASE(other), key);
      80             : }
      81             : 
      82        7554 : static inline unsigned set_size(Set *s) {
      83        7554 :         return internal_hashmap_size(HASHMAP_BASE(s));
      84             : }
      85             : 
      86        4590 : static inline bool set_isempty(Set *s) {
      87        4590 :         return set_size(s) == 0;
      88             : }
      89             : 
      90             : static inline unsigned set_buckets(Set *s) {
      91             :         return internal_hashmap_buckets(HASHMAP_BASE(s));
      92             : }
      93             : 
      94             : bool set_iterate(Set *s, Iterator *i, void **value);
      95             : 
      96           0 : static inline void set_clear(Set *s) {
      97           0 :         internal_hashmap_clear(HASHMAP_BASE(s));
      98           0 : }
      99             : 
     100         690 : static inline void set_clear_free(Set *s) {
     101         690 :         internal_hashmap_clear_free(HASHMAP_BASE(s));
     102         690 : }
     103             : 
     104             : /* no set_clear_free_free */
     105             : 
     106        1274 : static inline void *set_steal_first(Set *s) {
     107        1274 :         return internal_hashmap_steal_first(HASHMAP_BASE(s));
     108             : }
     109             : 
     110             : /* no set_steal_first_key */
     111             : /* no set_first_key */
     112             : 
     113          13 : static inline void *set_first(Set *s) {
     114          13 :         return internal_hashmap_first(HASHMAP_BASE(s));
     115             : }
     116             : 
     117             : /* no set_next */
     118             : 
     119           1 : static inline char **set_get_strv(Set *s) {
     120           1 :         return internal_hashmap_get_strv(HASHMAP_BASE(s));
     121             : }
     122             : 
     123             : int set_consume(Set *s, void *value);
     124             : int set_put_strdup(Set *s, const char *p);
     125             : int set_put_strdupv(Set *s, char **l);
     126             : 
     127             : #define SET_FOREACH(e, s, i) \
     128             :         for ((i) = ITERATOR_FIRST; set_iterate((s), &(i), (void**)&(e)); )
     129             : 
     130         349 : DEFINE_TRIVIAL_CLEANUP_FUNC(Set*, set_free);
     131         801 : DEFINE_TRIVIAL_CLEANUP_FUNC(Set*, set_free_free);
     132             : 
     133             : #define _cleanup_set_free_ _cleanup_(set_freep)
     134             : #define _cleanup_set_free_free_ _cleanup_(set_free_freep)