New upstream version 1.32.12 upstream/1.32.12

1 files changed, 0 insertions, 1065 deletions

diff --git a/shared/nm-glib-aux/nm-dedup-multi.c b/shared/nm-glib-aux/nm-dedup-multi.c
deleted file mode 100644
index 99da3b35..00000000
--- a/shared/nm-glib-aux/nm-dedup-multi.c
+++ /dev/null
@@ -1,1065 +0,0 @@
-/* SPDX-License-Identifier: LGPL-2.1-or-later */
-/*
- * Copyright (C) 2017 Red Hat, Inc.
- */
-
-#include "nm-glib-aux/nm-default-glib-i18n-lib.h"
-
-#include "nm-dedup-multi.h"
-
-#include "nm-hash-utils.h"
-#include "nm-c-list.h"
-
-/*****************************************************************************/
-
-typedef struct {
-    /* the stack-allocated lookup entry. It has a compatible
-     * memory layout with NMDedupMultiEntry and NMDedupMultiHeadEntry.
-     *
-     * It is recognizable by having lst_entries_sentinel.next set to NULL.
-     * Contrary to the other entries, which have lst_entries.next
-     * always non-NULL.
-     * */
-    CList                      lst_entries_sentinel;
-    const NMDedupMultiObj *    obj;
-    const NMDedupMultiIdxType *idx_type;
-    bool                       lookup_head;
-} LookupEntry;
-
-struct _NMDedupMultiIndex {
-    int         ref_count;
-    GHashTable *idx_entries;
-    GHashTable *idx_objs;
-};
-
-/*****************************************************************************/
-
-static void
-ASSERT_idx_type(const NMDedupMultiIdxType *idx_type)
-{
-    nm_assert(idx_type);
-#if NM_MORE_ASSERTS > 10
-    nm_assert(idx_type->klass);
-    nm_assert(idx_type->klass->idx_obj_id_hash_update);
-    nm_assert(idx_type->klass->idx_obj_id_equal);
-    nm_assert(!!idx_type->klass->idx_obj_partition_hash_update
-              == !!idx_type->klass->idx_obj_partition_equal);
-    nm_assert(idx_type->lst_idx_head.next);
-#endif
-}
-
-void
-nm_dedup_multi_idx_type_init(NMDedupMultiIdxType *idx_type, const NMDedupMultiIdxTypeClass *klass)
-{
-    nm_assert(idx_type);
-    nm_assert(klass);
-
-    *idx_type = (NMDedupMultiIdxType){
-        .klass        = klass,
-        .lst_idx_head = C_LIST_INIT(idx_type->lst_idx_head),
-    };
-
-    ASSERT_idx_type(idx_type);
-}
-
-/*****************************************************************************/
-
-static NMDedupMultiEntry *
-_entry_lookup_obj(const NMDedupMultiIndex *  self,
-                  const NMDedupMultiIdxType *idx_type,
-                  const NMDedupMultiObj *    obj)
-{
-    const LookupEntry stack_entry = {
-        .obj         = obj,
-        .idx_type    = idx_type,
-        .lookup_head = FALSE,
-    };
-
-    ASSERT_idx_type(idx_type);
-    return g_hash_table_lookup(self->idx_entries, &stack_entry);
-}
-
-static NMDedupMultiHeadEntry *
-_entry_lookup_head(const NMDedupMultiIndex *  self,
-                   const NMDedupMultiIdxType *idx_type,
-                   const NMDedupMultiObj *    obj)
-{
-    NMDedupMultiHeadEntry *head_entry;
-    const LookupEntry      stack_entry = {
-        .obj         = obj,
-        .idx_type    = idx_type,
-        .lookup_head = TRUE,
-    };
-
-    ASSERT_idx_type(idx_type);
-
-    if (!idx_type->klass->idx_obj_partition_equal) {
-        if (c_list_is_empty(&idx_type->lst_idx_head))
-            head_entry = NULL;
-        else {
-            nm_assert(c_list_length(&idx_type->lst_idx_head) == 1);
-            head_entry = c_list_entry(idx_type->lst_idx_head.next, NMDedupMultiHeadEntry, lst_idx);
-        }
-        nm_assert(head_entry == g_hash_table_lookup(self->idx_entries, &stack_entry));
-        return head_entry;
-    }
-
-    return g_hash_table_lookup(self->idx_entries, &stack_entry);
-}
-
-static void
-_entry_unpack(const NMDedupMultiEntry *   entry,
-              const NMDedupMultiIdxType **out_idx_type,
-              const NMDedupMultiObj **    out_obj,
-              gboolean *                  out_lookup_head)
-{
-    const NMDedupMultiHeadEntry *head_entry;
-    const LookupEntry *          lookup_entry;
-
-    nm_assert(entry);
-
-    G_STATIC_ASSERT_EXPR(G_STRUCT_OFFSET(LookupEntry, lst_entries_sentinel)
-                         == G_STRUCT_OFFSET(NMDedupMultiEntry, lst_entries));
-    G_STATIC_ASSERT_EXPR(G_STRUCT_OFFSET(NMDedupMultiEntry, lst_entries)
-                         == G_STRUCT_OFFSET(NMDedupMultiHeadEntry, lst_entries_head));
-    G_STATIC_ASSERT_EXPR(G_STRUCT_OFFSET(NMDedupMultiEntry, obj)
-                         == G_STRUCT_OFFSET(NMDedupMultiHeadEntry, idx_type));
-    G_STATIC_ASSERT_EXPR(G_STRUCT_OFFSET(NMDedupMultiEntry, is_head)
-                         == G_STRUCT_OFFSET(NMDedupMultiHeadEntry, is_head));
-
-    if (!entry->lst_entries.next) {
-        /* the entry is stack-allocated by _entry_lookup(). */
-        lookup_entry     = (LookupEntry *) entry;
-        *out_obj         = lookup_entry->obj;
-        *out_idx_type    = lookup_entry->idx_type;
-        *out_lookup_head = lookup_entry->lookup_head;
-    } else if (entry->is_head) {
-        head_entry = (NMDedupMultiHeadEntry *) entry;
-        nm_assert(!c_list_is_empty(&head_entry->lst_entries_head));
-        *out_obj =
-            c_list_entry(head_entry->lst_entries_head.next, NMDedupMultiEntry, lst_entries)->obj;
-        *out_idx_type    = head_entry->idx_type;
-        *out_lookup_head = TRUE;
-    } else {
-        *out_obj         = entry->obj;
-        *out_idx_type    = entry->head->idx_type;
-        *out_lookup_head = FALSE;
-    }
-
-    nm_assert(NM_IN_SET(*out_lookup_head, FALSE, TRUE));
-    ASSERT_idx_type(*out_idx_type);
-
-    /* for lookup of the head, we allow to omit object, but only
-     * if the idx_type does not partition the objects. Otherwise, we
-     * require a obj to compare. */
-    nm_assert(!*out_lookup_head || (*out_obj || !(*out_idx_type)->klass->idx_obj_partition_equal));
-
-    /* lookup of the object requires always an object. */
-    nm_assert(*out_lookup_head || *out_obj);
-}
-
-static guint
-_dict_idx_entries_hash(const NMDedupMultiEntry *entry)
-{
-    const NMDedupMultiIdxType *idx_type;
-    const NMDedupMultiObj *    obj;
-    gboolean                   lookup_head;
-    NMHashState                h;
-
-    _entry_unpack(entry, &idx_type, &obj, &lookup_head);
-
-    nm_hash_init(&h, 1914869417u);
-    if (idx_type->klass->idx_obj_partition_hash_update) {
-        nm_assert(obj);
-        idx_type->klass->idx_obj_partition_hash_update(idx_type, obj, &h);
-    }
-
-    if (!lookup_head)
-        idx_type->klass->idx_obj_id_hash_update(idx_type, obj, &h);
-
-    nm_hash_update_val(&h, idx_type);
-    return nm_hash_complete(&h);
-}
-
-static gboolean
-_dict_idx_entries_equal(const NMDedupMultiEntry *entry_a, const NMDedupMultiEntry *entry_b)
-{
-    const NMDedupMultiIdxType *idx_type_a, *idx_type_b;
-    const NMDedupMultiObj *    obj_a, *obj_b;
-    gboolean                   lookup_head_a, lookup_head_b;
-
-    _entry_unpack(entry_a, &idx_type_a, &obj_a, &lookup_head_a);
-    _entry_unpack(entry_b, &idx_type_b, &obj_b, &lookup_head_b);
-
-    if (idx_type_a != idx_type_b || lookup_head_a != lookup_head_b)
-        return FALSE;
-    if (!nm_dedup_multi_idx_type_partition_equal(idx_type_a, obj_a, obj_b))
-        return FALSE;
-    if (!lookup_head_a && !nm_dedup_multi_idx_type_id_equal(idx_type_a, obj_a, obj_b))
-        return FALSE;
-    return TRUE;
-}
-
-/*****************************************************************************/
-
-static gboolean
-_add(NMDedupMultiIndex *       self,
-     NMDedupMultiIdxType *     idx_type,
-     const NMDedupMultiObj *   obj,
-     NMDedupMultiEntry *       entry,
-     NMDedupMultiIdxMode       mode,
-     const NMDedupMultiEntry * entry_order,
-     NMDedupMultiHeadEntry *   head_existing,
-     const NMDedupMultiEntry **out_entry,
-     const NMDedupMultiObj **  out_obj_old)
-{
-    NMDedupMultiHeadEntry *head_entry;
-    const NMDedupMultiObj *obj_new, *obj_old;
-    gboolean               add_head_entry = FALSE;
-
-    nm_assert(self);
-    ASSERT_idx_type(idx_type);
-    nm_assert(obj);
-    nm_assert(NM_IN_SET(mode,
-                        NM_DEDUP_MULTI_IDX_MODE_PREPEND,
-                        NM_DEDUP_MULTI_IDX_MODE_PREPEND_FORCE,
-                        NM_DEDUP_MULTI_IDX_MODE_APPEND,
-                        NM_DEDUP_MULTI_IDX_MODE_APPEND_FORCE));
-    nm_assert(!head_existing || head_existing->idx_type == idx_type);
-    nm_assert(({
-        const NMDedupMultiHeadEntry *_h;
-        gboolean                     _ok = TRUE;
-        if (head_existing) {
-            _h = nm_dedup_multi_index_lookup_head(self, idx_type, obj);
-            if (head_existing == NM_DEDUP_MULTI_HEAD_ENTRY_MISSING)
-                _ok = (_h == NULL);
-            else
-                _ok = (_h == head_existing);
-        }
-        _ok;
-    }));
-
-    if (entry) {
-        gboolean changed = FALSE;
-
-        nm_dedup_multi_entry_set_dirty(entry, FALSE);
-
-        nm_assert(!head_existing || entry->head == head_existing);
-        nm_assert(!entry_order || entry_order->head == entry->head);
-        nm_assert(!entry_order || c_list_contains(&entry->lst_entries, &entry_order->lst_entries));
-        nm_assert(!entry_order || c_list_contains(&entry_order->lst_entries, &entry->lst_entries));
-
-        switch (mode) {
-        case NM_DEDUP_MULTI_IDX_MODE_PREPEND_FORCE:
-            if (entry_order) {
-                if (nm_c_list_move_before((CList *) &entry_order->lst_entries, &entry->lst_entries))
-                    changed = TRUE;
-            } else {
-                if (nm_c_list_move_front((CList *) &entry->head->lst_entries_head,
-                                         &entry->lst_entries))
-                    changed = TRUE;
-            }
-            break;
-        case NM_DEDUP_MULTI_IDX_MODE_APPEND_FORCE:
-            if (entry_order) {
-                if (nm_c_list_move_after((CList *) &entry_order->lst_entries, &entry->lst_entries))
-                    changed = TRUE;
-            } else {
-                if (nm_c_list_move_tail((CList *) &entry->head->lst_entries_head,
-                                        &entry->lst_entries))
-                    changed = TRUE;
-            }
-            break;
-        case NM_DEDUP_MULTI_IDX_MODE_PREPEND:
-        case NM_DEDUP_MULTI_IDX_MODE_APPEND:
-            break;
-        };
-
-        nm_assert(obj->klass == ((const NMDedupMultiObj *) entry->obj)->klass);
-        if (obj == entry->obj || obj->klass->obj_full_equal(obj, entry->obj)) {
-            NM_SET_OUT(out_entry, entry);
-            NM_SET_OUT(out_obj_old, nm_dedup_multi_obj_ref(entry->obj));
-            return changed;
-        }
-
-        obj_new = nm_dedup_multi_index_obj_intern(self, obj);
-
-        obj_old    = entry->obj;
-        entry->obj = obj_new;
-
-        NM_SET_OUT(out_entry, entry);
-        if (out_obj_old)
-            *out_obj_old = obj_old;
-        else
-            nm_dedup_multi_obj_unref(obj_old);
-        return TRUE;
-    }
-
-    if (idx_type->klass->idx_obj_partitionable
-        && !idx_type->klass->idx_obj_partitionable(idx_type, obj)) {
-        /* this object cannot be partitioned by this idx_type. */
-        nm_assert(!head_existing || head_existing == NM_DEDUP_MULTI_HEAD_ENTRY_MISSING);
-        NM_SET_OUT(out_entry, NULL);
-        NM_SET_OUT(out_obj_old, NULL);
-        return FALSE;
-    }
-
-    obj_new = nm_dedup_multi_index_obj_intern(self, obj);
-
-    if (!head_existing)
-        head_entry = _entry_lookup_head(self, idx_type, obj_new);
-    else if (head_existing == NM_DEDUP_MULTI_HEAD_ENTRY_MISSING)
-        head_entry = NULL;
-    else
-        head_entry = head_existing;
-
-    if (!head_entry) {
-        head_entry           = g_slice_new0(NMDedupMultiHeadEntry);
-        head_entry->is_head  = TRUE;
-        head_entry->idx_type = idx_type;
-        c_list_init(&head_entry->lst_entries_head);
-        c_list_link_tail(&idx_type->lst_idx_head, &head_entry->lst_idx);
-        add_head_entry = TRUE;
-    } else
-        nm_assert(c_list_contains(&idx_type->lst_idx_head, &head_entry->lst_idx));
-
-    if (entry_order) {
-        nm_assert(!add_head_entry);
-        nm_assert(entry_order->head == head_entry);
-        nm_assert(c_list_contains(&head_entry->lst_entries_head, &entry_order->lst_entries));
-        nm_assert(c_list_contains(&entry_order->lst_entries, &head_entry->lst_entries_head));
-    }
-
-    entry       = g_slice_new0(NMDedupMultiEntry);
-    entry->obj  = obj_new;
-    entry->head = head_entry;
-
-    switch (mode) {
-    case NM_DEDUP_MULTI_IDX_MODE_PREPEND:
-    case NM_DEDUP_MULTI_IDX_MODE_PREPEND_FORCE:
-        if (entry_order)
-            c_list_link_before((CList *) &entry_order->lst_entries, &entry->lst_entries);
-        else
-            c_list_link_front(&head_entry->lst_entries_head, &entry->lst_entries);
-        break;
-    default:
-        if (entry_order)
-            c_list_link_after((CList *) &entry_order->lst_entries, &entry->lst_entries);
-        else
-            c_list_link_tail(&head_entry->lst_entries_head, &entry->lst_entries);
-        break;
-    };
-
-    idx_type->len++;
-    head_entry->len++;
-
-    if (add_head_entry && !g_hash_table_add(self->idx_entries, head_entry))
-        nm_assert_not_reached();
-
-    if (!g_hash_table_add(self->idx_entries, entry))
-        nm_assert_not_reached();
-
-    NM_SET_OUT(out_entry, entry);
-    NM_SET_OUT(out_obj_old, NULL);
-    return TRUE;
-}
-
-gboolean
-nm_dedup_multi_index_add(NMDedupMultiIndex *                        self,
-                         NMDedupMultiIdxType *                      idx_type,
-                         /*const NMDedupMultiObj * */ gconstpointer obj,
-                         NMDedupMultiIdxMode                        mode,
-                         const NMDedupMultiEntry **                 out_entry,
-                         /* const NMDedupMultiObj ** */ gpointer    out_obj_old)
-{
-    NMDedupMultiEntry *entry;
-
-    g_return_val_if_fail(self, FALSE);
-    g_return_val_if_fail(idx_type, FALSE);
-    g_return_val_if_fail(obj, FALSE);
-    g_return_val_if_fail(NM_IN_SET(mode,
-                                   NM_DEDUP_MULTI_IDX_MODE_PREPEND,
-                                   NM_DEDUP_MULTI_IDX_MODE_PREPEND_FORCE,
-                                   NM_DEDUP_MULTI_IDX_MODE_APPEND,
-                                   NM_DEDUP_MULTI_IDX_MODE_APPEND_FORCE),
-                         FALSE);
-
-    entry = _entry_lookup_obj(self, idx_type, obj);
-    return _add(self, idx_type, obj, entry, mode, NULL, NULL, out_entry, out_obj_old);
-}
-
-/* nm_dedup_multi_index_add_full:
- * @self: the index instance.
- * @idx_type: the index handle for storing @obj.
- * @obj: the NMDedupMultiObj instance to add.
- * @mode: whether to append or prepend the new item. If @entry_order is given,
- *   the entry will be sorted after/before, instead of appending/prepending to
- *   the entire list. If a comparable object is already tracked, then it may
- *   still be resorted by specifying one of the "FORCE" modes.
- * @entry_order: if not NULL, the new entry will be sorted before or after @entry_order.
- *   If given, @entry_order MUST be tracked by @self, and the object it points to MUST
- *   be in the same partition tracked by @idx_type. That is, they must have the same
- *   head_entry and it means, you must ensure that @entry_order and the created/modified
- *   entry will share the same head.
- * @entry_existing: if not NULL, it safes a hash lookup of the entry where the
- *   object will be placed in. You can omit this, and it will be automatically
- *   detected (at the expense of an additional hash lookup).
- *   Basically, this is the result of nm_dedup_multi_index_lookup_obj(),
- *   with the peculiarity that if you know that @obj is not yet tracked,
- *   you may specify %NM_DEDUP_MULTI_ENTRY_MISSING.
- * @head_existing: an optional argument to safe a lookup for the head. If specified,
- *   it must be identical to nm_dedup_multi_index_lookup_head(), with the peculiarity
- *   that if the head is not yet tracked, you may specify %NM_DEDUP_MULTI_HEAD_ENTRY_MISSING
- * @out_entry: if give, return the added entry. This entry may have already exists (update)
- *   or be newly created. If @obj is not partitionable according to @idx_type, @obj
- *   is not to be added and it returns %NULL.
- * @out_obj_old: if given, return the previously contained object. It only
- *   returns a  object, if a matching entry was tracked previously, not if a
- *   new entry was created. Note that when passing @out_obj_old you obtain a reference
- *   to the boxed object and MUST return it with nm_dedup_multi_obj_unref().
- *
- * Adds and object to the index.
- *
- * Return: %TRUE if anything changed, %FALSE if nothing changed.
- */
-gboolean
-nm_dedup_multi_index_add_full(NMDedupMultiIndex *                        self,
-                              NMDedupMultiIdxType *                      idx_type,
-                              /*const NMDedupMultiObj * */ gconstpointer obj,
-                              NMDedupMultiIdxMode                        mode,
-                              const NMDedupMultiEntry *                  entry_order,
-                              const NMDedupMultiEntry *                  entry_existing,
-                              const NMDedupMultiHeadEntry *              head_existing,
-                              const NMDedupMultiEntry **                 out_entry,
-                              /* const NMDedupMultiObj ** */ gpointer    out_obj_old)
-{
-    NMDedupMultiEntry *entry;
-
-    g_return_val_if_fail(self, FALSE);
-    g_return_val_if_fail(idx_type, FALSE);
-    g_return_val_if_fail(obj, FALSE);
-    g_return_val_if_fail(NM_IN_SET(mode,
-                                   NM_DEDUP_MULTI_IDX_MODE_PREPEND,
-                                   NM_DEDUP_MULTI_IDX_MODE_PREPEND_FORCE,
-                                   NM_DEDUP_MULTI_IDX_MODE_APPEND,
-                                   NM_DEDUP_MULTI_IDX_MODE_APPEND_FORCE),
-                         FALSE);
-
-    if (entry_existing == NULL)
-        entry = _entry_lookup_obj(self, idx_type, obj);
-    else if (entry_existing == NM_DEDUP_MULTI_ENTRY_MISSING) {
-        nm_assert(!_entry_lookup_obj(self, idx_type, obj));
-        entry = NULL;
-    } else {
-        nm_assert(entry_existing == _entry_lookup_obj(self, idx_type, obj));
-        entry = (NMDedupMultiEntry *) entry_existing;
-    }
-    return _add(self,
-                idx_type,
-                obj,
-                entry,
-                mode,
-                entry_order,
-                (NMDedupMultiHeadEntry *) head_existing,
-                out_entry,
-                out_obj_old);
-}
-
-/*****************************************************************************/
-
-static void
-_remove_entry(NMDedupMultiIndex *self, NMDedupMultiEntry *entry, gboolean *out_head_entry_removed)
-{
-    const NMDedupMultiObj *obj;
-    NMDedupMultiHeadEntry *head_entry;
-    NMDedupMultiIdxType *  idx_type;
-
-    nm_assert(self);
-    nm_assert(entry);
-    nm_assert(entry->obj);
-    nm_assert(entry->head);
-    nm_assert(!c_list_is_empty(&entry->lst_entries));
-    nm_assert(g_hash_table_lookup(self->idx_entries, entry) == entry);
-
-    head_entry = (NMDedupMultiHeadEntry *) entry->head;
-    obj        = entry->obj;
-
-    nm_assert(head_entry);
-    nm_assert(head_entry->len > 0);
-    nm_assert(g_hash_table_lookup(self->idx_entries, head_entry) == head_entry);
-
-    idx_type = (NMDedupMultiIdxType *) head_entry->idx_type;
-    ASSERT_idx_type(idx_type);
-
-    nm_assert(idx_type->len >= head_entry->len);
-    if (--head_entry->len > 0) {
-        nm_assert(idx_type->len > 1);
-        idx_type->len--;
-        head_entry = NULL;
-    }
-
-    NM_SET_OUT(out_head_entry_removed, head_entry != NULL);
-
-    if (!g_hash_table_remove(self->idx_entries, entry))
-        nm_assert_not_reached();
-
-    if (head_entry && !g_hash_table_remove(self->idx_entries, head_entry))
-        nm_assert_not_reached();
-
-    c_list_unlink_stale(&entry->lst_entries);
-    g_slice_free(NMDedupMultiEntry, entry);
-
-    if (head_entry) {
-        nm_assert(c_list_is_empty(&head_entry->lst_entries_head));
-        c_list_unlink_stale(&head_entry->lst_idx);
-        g_slice_free(NMDedupMultiHeadEntry, head_entry);
-    }
-
-    nm_dedup_multi_obj_unref(obj);
-}
-
-static guint
-_remove_head(NMDedupMultiIndex *    self,
-             NMDedupMultiHeadEntry *head_entry,
-             gboolean               remove_all /* otherwise just dirty ones */,
-             gboolean               mark_survivors_dirty)
-{
-    guint    n;
-    gboolean head_entry_removed;
-    CList *  iter_entry, *iter_entry_safe;
-
-    nm_assert(self);
-    nm_assert(head_entry);
-    nm_assert(head_entry->len > 0);
-    nm_assert(head_entry->len == c_list_length(&head_entry->lst_entries_head));
-    nm_assert(g_hash_table_lookup(self->idx_entries, head_entry) == head_entry);
-
-    n = 0;
-    c_list_for_each_safe (iter_entry, iter_entry_safe, &head_entry->lst_entries_head) {
-        NMDedupMultiEntry *entry;
-
-        entry = c_list_entry(iter_entry, NMDedupMultiEntry, lst_entries);
-        if (remove_all || entry->dirty) {
-            _remove_entry(self, entry, &head_entry_removed);
-            n++;
-            if (head_entry_removed)
-                break;
-        } else if (mark_survivors_dirty)
-            nm_dedup_multi_entry_set_dirty(entry, TRUE);
-    }
-
-    return n;
-}
-
-static guint
-_remove_idx_entry(NMDedupMultiIndex *  self,
-                  NMDedupMultiIdxType *idx_type,
-                  gboolean             remove_all /* otherwise just dirty ones */,
-                  gboolean             mark_survivors_dirty)
-{
-    guint  n;
-    CList *iter_idx, *iter_idx_safe;
-
-    nm_assert(self);
-    ASSERT_idx_type(idx_type);
-
-    n = 0;
-    c_list_for_each_safe (iter_idx, iter_idx_safe, &idx_type->lst_idx_head) {
-        n += _remove_head(self,
-                          c_list_entry(iter_idx, NMDedupMultiHeadEntry, lst_idx),
-                          remove_all,
-                          mark_survivors_dirty);
-    }
-    return n;
-}
-
-guint
-nm_dedup_multi_index_remove_entry(NMDedupMultiIndex *self, gconstpointer entry)
-{
-    g_return_val_if_fail(self, 0);
-
-    nm_assert(entry);
-
-    if (!((NMDedupMultiEntry *) entry)->is_head) {
-        _remove_entry(self, (NMDedupMultiEntry *) entry, NULL);
-        return 1;
-    }
-    return _remove_head(self, (NMDedupMultiHeadEntry *) entry, TRUE, FALSE);
-}
-
-guint
-nm_dedup_multi_index_remove_obj(NMDedupMultiIndex *                          self,
-                                NMDedupMultiIdxType *                        idx_type,
-                                /*const NMDedupMultiObj * */ gconstpointer   obj,
-                                /*const NMDedupMultiObj ** */ gconstpointer *out_obj)
-{
-    const NMDedupMultiEntry *entry;
-
-    entry = nm_dedup_multi_index_lookup_obj(self, idx_type, obj);
-    if (!entry) {
-        NM_SET_OUT(out_obj, NULL);
-        return 0;
-    }
-
-    /* since we are about to remove the object, we obviously pass
-     * a reference to @out_obj, the caller MUST unref the object,
-     * if he chooses to provide @out_obj. */
-    NM_SET_OUT(out_obj, nm_dedup_multi_obj_ref(entry->obj));
-
-    _remove_entry(self, (NMDedupMultiEntry *) entry, NULL);
-    return 1;
-}
-
-guint
-nm_dedup_multi_index_remove_head(NMDedupMultiIndex *                        self,
-                                 NMDedupMultiIdxType *                      idx_type,
-                                 /*const NMDedupMultiObj * */ gconstpointer obj)
-{
-    const NMDedupMultiHeadEntry *entry;
-
-    entry = nm_dedup_multi_index_lookup_head(self, idx_type, obj);
-    return entry ? _remove_head(self, (NMDedupMultiHeadEntry *) entry, TRUE, FALSE) : 0;
-}
-
-guint
-nm_dedup_multi_index_remove_idx(NMDedupMultiIndex *self, NMDedupMultiIdxType *idx_type)
-{
-    g_return_val_if_fail(self, 0);
-    g_return_val_if_fail(idx_type, 0);
-
-    return _remove_idx_entry(self, idx_type, TRUE, FALSE);
-}
-
-/*****************************************************************************/
-
-/**
- * nm_dedup_multi_index_lookup_obj:
- * @self: the index cache
- * @idx_type: the lookup index type
- * @obj: the object to lookup. This means the match is performed
- *   according to NMDedupMultiIdxTypeClass's idx_obj_id_equal()
- *   of @idx_type.
- *
- * Returns: the cache entry or %NULL if the entry wasn't found.
- */
-const NMDedupMultiEntry *
-nm_dedup_multi_index_lookup_obj(const NMDedupMultiIndex *                  self,
-                                const NMDedupMultiIdxType *                idx_type,
-                                /*const NMDedupMultiObj * */ gconstpointer obj)
-{
-    g_return_val_if_fail(self, FALSE);
-    g_return_val_if_fail(idx_type, FALSE);
-    g_return_val_if_fail(obj, FALSE);
-
-    nm_assert(idx_type && idx_type->klass);
-    return _entry_lookup_obj(self, idx_type, obj);
-}
-
-/**
- * nm_dedup_multi_index_lookup_head:
- * @self: the index cache
- * @idx_type: the lookup index type
- * @obj: the object to lookup, of type "const NMDedupMultiObj *".
- *   Depending on the idx_type, you *must* also provide a selector
- *   object, even when looking up the list head. That is, because
- *   the idx_type implementation may choose to partition the objects
- *   in distinct list, so you need a selector object to know which
- *   list head to lookup.
- *
- * Returns: the cache entry or %NULL if the entry wasn't found.
- */
-const NMDedupMultiHeadEntry *
-nm_dedup_multi_index_lookup_head(const NMDedupMultiIndex *                  self,
-                                 const NMDedupMultiIdxType *                idx_type,
-                                 /*const NMDedupMultiObj * */ gconstpointer obj)
-{
-    g_return_val_if_fail(self, FALSE);
-    g_return_val_if_fail(idx_type, FALSE);
-
-    return _entry_lookup_head(self, idx_type, obj);
-}
-
-/*****************************************************************************/
-
-void
-nm_dedup_multi_index_dirty_set_head(NMDedupMultiIndex *                        self,
-                                    const NMDedupMultiIdxType *                idx_type,
-                                    /*const NMDedupMultiObj * */ gconstpointer obj)
-{
-    NMDedupMultiHeadEntry *head_entry;
-    CList *                iter_entry;
-
-    g_return_if_fail(self);
-    g_return_if_fail(idx_type);
-
-    head_entry = _entry_lookup_head(self, idx_type, obj);
-    if (!head_entry)
-        return;
-
-    c_list_for_each (iter_entry, &head_entry->lst_entries_head) {
-        NMDedupMultiEntry *entry;
-
-        entry = c_list_entry(iter_entry, NMDedupMultiEntry, lst_entries);
-        nm_dedup_multi_entry_set_dirty(entry, TRUE);
-    }
-}
-
-void
-nm_dedup_multi_index_dirty_set_idx(NMDedupMultiIndex *self, const NMDedupMultiIdxType *idx_type)
-{
-    CList *iter_idx, *iter_entry;
-
-    g_return_if_fail(self);
-    g_return_if_fail(idx_type);
-
-    c_list_for_each (iter_idx, &idx_type->lst_idx_head) {
-        NMDedupMultiHeadEntry *head_entry;
-
-        head_entry = c_list_entry(iter_idx, NMDedupMultiHeadEntry, lst_idx);
-        c_list_for_each (iter_entry, &head_entry->lst_entries_head) {
-            NMDedupMultiEntry *entry;
-
-            entry = c_list_entry(iter_entry, NMDedupMultiEntry, lst_entries);
-            nm_dedup_multi_entry_set_dirty(entry, TRUE);
-        }
-    }
-}
-
-/**
- * nm_dedup_multi_index_dirty_remove_idx:
- * @self: the index instance
- * @idx_type: the index-type to select the objects.
- * @mark_survivors_dirty: while the function removes all entries that are
- *   marked as dirty, if @set_dirty is true, the surviving objects
- *   will be marked dirty right away.
- *
- * Deletes all entries for @idx_type that are marked dirty. Only
- * non-dirty objects survive. If @mark_survivors_dirty is set to TRUE, the survivors
- * are marked as dirty right away.
- *
- * Returns: number of deleted entries.
- */
-guint
-nm_dedup_multi_index_dirty_remove_idx(NMDedupMultiIndex *  self,
-                                      NMDedupMultiIdxType *idx_type,
-                                      gboolean             mark_survivors_dirty)
-{
-    g_return_val_if_fail(self, 0);
-    g_return_val_if_fail(idx_type, 0);
-
-    return _remove_idx_entry(self, idx_type, FALSE, mark_survivors_dirty);
-}
-
-/*****************************************************************************/
-
-static guint
-_dict_idx_objs_hash(const NMDedupMultiObj *obj)
-{
-    NMHashState h;
-
-    nm_hash_init(&h, 1748638583u);
-    obj->klass->obj_full_hash_update(obj, &h);
-    return nm_hash_complete(&h);
-}
-
-static gboolean
-_dict_idx_objs_equal(const NMDedupMultiObj *obj_a, const NMDedupMultiObj *obj_b)
-{
-    return obj_a == obj_b
-           || (obj_a->klass == obj_b->klass && obj_a->klass->obj_full_equal(obj_a, obj_b));
-}
-
-void
-nm_dedup_multi_index_obj_release(NMDedupMultiIndex *                         self,
-                                 /* const NMDedupMultiObj * */ gconstpointer obj)
-{
-    nm_assert(self);
-    nm_assert(obj);
-    nm_assert(g_hash_table_lookup(self->idx_objs, obj) == obj);
-    nm_assert(((const NMDedupMultiObj *) obj)->_multi_idx == self);
-
-    ((NMDedupMultiObj *) obj)->_multi_idx = NULL;
-    if (!g_hash_table_remove(self->idx_objs, obj))
-        nm_assert_not_reached();
-}
-
-gconstpointer
-nm_dedup_multi_index_obj_find(NMDedupMultiIndex *                         self,
-                              /* const NMDedupMultiObj * */ gconstpointer obj)
-{
-    g_return_val_if_fail(self, NULL);
-    g_return_val_if_fail(obj, NULL);
-
-    return g_hash_table_lookup(self->idx_objs, obj);
-}
-
-gconstpointer
-nm_dedup_multi_index_obj_intern(NMDedupMultiIndex *                         self,
-                                /* const NMDedupMultiObj * */ gconstpointer obj)
-{
-    const NMDedupMultiObj *obj_new = obj;
-    const NMDedupMultiObj *obj_old;
-
-    nm_assert(self);
-    nm_assert(obj_new);
-
-    if (obj_new->_multi_idx == self) {
-        nm_assert(g_hash_table_lookup(self->idx_objs, obj_new) == obj_new);
-        nm_dedup_multi_obj_ref(obj_new);
-        return obj_new;
-    }
-
-    obj_old = g_hash_table_lookup(self->idx_objs, obj_new);
-    nm_assert(obj_old != obj_new);
-
-    if (obj_old) {
-        nm_assert(obj_old->_multi_idx == self);
-        nm_dedup_multi_obj_ref(obj_old);
-        return obj_old;
-    }
-
-    if (nm_dedup_multi_obj_needs_clone(obj_new))
-        obj_new = nm_dedup_multi_obj_clone(obj_new);
-    else
-        obj_new = nm_dedup_multi_obj_ref(obj_new);
-
-    nm_assert(obj_new);
-    nm_assert(!obj_new->_multi_idx);
-
-    if (!g_hash_table_add(self->idx_objs, (gpointer) obj_new))
-        nm_assert_not_reached();
-
-    ((NMDedupMultiObj *) obj_new)->_multi_idx = self;
-    return obj_new;
-}
-
-void
-nm_dedup_multi_obj_unref(const NMDedupMultiObj *obj)
-{
-    if (obj) {
-        nm_assert(obj->_ref_count > 0);
-        nm_assert(obj->_ref_count != NM_OBJ_REF_COUNT_STACKINIT);
-
-again:
-        if (--(((NMDedupMultiObj *) obj)->_ref_count) <= 0) {
-            if (obj->_multi_idx) {
-                /* restore the ref-count to 1 and release the object first
-                 * from the index. Then, retry again to unref. */
-                ((NMDedupMultiObj *) obj)->_ref_count++;
-                nm_dedup_multi_index_obj_release(obj->_multi_idx, obj);
-                nm_assert(obj->_ref_count == 1);
-                nm_assert(!obj->_multi_idx);
-                goto again;
-            }
-
-            obj->klass->obj_destroy((NMDedupMultiObj *) obj);
-        }
-    }
-}
-
-gboolean
-nm_dedup_multi_obj_needs_clone(const NMDedupMultiObj *obj)
-{
-    nm_assert(obj);
-
-    if (obj->_multi_idx || obj->_ref_count == NM_OBJ_REF_COUNT_STACKINIT)
-        return TRUE;
-
-    if (obj->klass->obj_needs_clone && obj->klass->obj_needs_clone(obj))
-        return TRUE;
-
-    return FALSE;
-}
-
-const NMDedupMultiObj *
-nm_dedup_multi_obj_clone(const NMDedupMultiObj *obj)
-{
-    const NMDedupMultiObj *o;
-
-    nm_assert(obj);
-
-    o = obj->klass->obj_clone(obj);
-    nm_assert(o);
-    nm_assert(o->_ref_count == 1);
-    return o;
-}
-
-gconstpointer *
-nm_dedup_multi_objs_to_array_head(const NMDedupMultiHeadEntry *  head_entry,
-                                  NMDedupMultiFcnSelectPredicate predicate,
-                                  gpointer                       user_data,
-                                  guint *                        out_len)
-{
-    gconstpointer *result;
-    CList *        iter;
-    guint          i;
-
-    if (!head_entry) {
-        NM_SET_OUT(out_len, 0);
-        return NULL;
-    }
-
-    result = g_new(gconstpointer, head_entry->len + 1);
-    i      = 0;
-    c_list_for_each (iter, &head_entry->lst_entries_head) {
-        const NMDedupMultiObj *obj = c_list_entry(iter, NMDedupMultiEntry, lst_entries)->obj;
-
-        if (!predicate || predicate(obj, user_data)) {
-            nm_assert(i < head_entry->len);
-            result[i++] = obj;
-        }
-    }
-
-    if (i == 0) {
-        g_free(result);
-        NM_SET_OUT(out_len, 0);
-        return NULL;
-    }
-
-    nm_assert(i <= head_entry->len);
-    NM_SET_OUT(out_len, i);
-    result[i++] = NULL;
-    return result;
-}
-
-GPtrArray *
-nm_dedup_multi_objs_to_ptr_array_head(const NMDedupMultiHeadEntry *  head_entry,
-                                      NMDedupMultiFcnSelectPredicate predicate,
-                                      gpointer                       user_data)
-{
-    GPtrArray *result;
-    CList *    iter;
-
-    if (!head_entry)
-        return NULL;
-
-    result = g_ptr_array_new_full(head_entry->len, (GDestroyNotify) nm_dedup_multi_obj_unref);
-    c_list_for_each (iter, &head_entry->lst_entries_head) {
-        const NMDedupMultiObj *obj = c_list_entry(iter, NMDedupMultiEntry, lst_entries)->obj;
-
-        if (!predicate || predicate(obj, user_data))
-            g_ptr_array_add(result, (gpointer) nm_dedup_multi_obj_ref(obj));
-    }
-
-    if (result->len == 0) {
-        g_ptr_array_unref(result);
-        return NULL;
-    }
-    return result;
-}
-
-/**
- * nm_dedup_multi_entry_reorder:
- * @entry: the entry to reorder. It must not be NULL (and tracked in an index).
- * @entry_order: (allow-none): an optional other entry. It MUST be in the same
- *   list as entry. If given, @entry will be ordered after/before @entry_order.
- *   If left at %NULL, @entry will be moved to the front/end of the list.
- * @order_after: if @entry_order is given, %TRUE means to move @entry after
- *   @entry_order (otherwise before).
- *   If @entry_order is %NULL, %TRUE means to move @entry to the tail of the list
- *   (otherwise the beginning). Note that "tail of the list" here means that @entry
- *   will be linked before the head of the circular list.
- *
- * Returns: %TRUE, if anything was changed. Otherwise, @entry was already at the
- * right place and nothing was done.
- */
-gboolean
-nm_dedup_multi_entry_reorder(const NMDedupMultiEntry *entry,
-                             const NMDedupMultiEntry *entry_order,
-                             gboolean                 order_after)
-{
-    nm_assert(entry);
-
-    if (!entry_order) {
-        const NMDedupMultiHeadEntry *head_entry = entry->head;
-
-        if (order_after) {
-            if (nm_c_list_move_tail((CList *) &head_entry->lst_entries_head,
-                                    (CList *) &entry->lst_entries))
-                return TRUE;
-        } else {
-            if (nm_c_list_move_front((CList *) &head_entry->lst_entries_head,
-                                     (CList *) &entry->lst_entries))
-                return TRUE;
-        }
-    } else {
-        if (order_after) {
-            if (nm_c_list_move_after((CList *) &entry_order->lst_entries,
-                                     (CList *) &entry->lst_entries))
-                return TRUE;
-        } else {
-            if (nm_c_list_move_before((CList *) &entry_order->lst_entries,
-                                      (CList *) &entry->lst_entries))
-                return TRUE;
-        }
-    }
-
-    return FALSE;
-}
-
-/*****************************************************************************/
-
-NMDedupMultiIndex *
-nm_dedup_multi_index_new(void)
-{
-    NMDedupMultiIndex *self;
-
-    self            = g_slice_new0(NMDedupMultiIndex);
-    self->ref_count = 1;
-    self->idx_entries =
-        g_hash_table_new((GHashFunc) _dict_idx_entries_hash, (GEqualFunc) _dict_idx_entries_equal);
-    self->idx_objs =
-        g_hash_table_new((GHashFunc) _dict_idx_objs_hash, (GEqualFunc) _dict_idx_objs_equal);
-    return self;
-}
-
-NMDedupMultiIndex *
-nm_dedup_multi_index_ref(NMDedupMultiIndex *self)
-{
-    g_return_val_if_fail(self, NULL);
-    g_return_val_if_fail(self->ref_count > 0, NULL);
-
-    self->ref_count++;
-    return self;
-}
-
-NMDedupMultiIndex *
-nm_dedup_multi_index_unref(NMDedupMultiIndex *self)
-{
-    GHashTableIter             iter;
-    const NMDedupMultiIdxType *idx_type;
-    NMDedupMultiEntry *        entry;
-    const NMDedupMultiObj *    obj;
-
-    g_return_val_if_fail(self, NULL);
-    g_return_val_if_fail(self->ref_count > 0, NULL);
-
-    if (--self->ref_count > 0)
-        return NULL;
-
-more:
-    g_hash_table_iter_init(&iter, self->idx_entries);
-    while (g_hash_table_iter_next(&iter, (gpointer *) &entry, NULL)) {
-        if (entry->is_head)
-            idx_type = ((NMDedupMultiHeadEntry *) entry)->idx_type;
-        else
-            idx_type = entry->head->idx_type;
-        _remove_idx_entry(self, (NMDedupMultiIdxType *) idx_type, TRUE, FALSE);
-        goto more;
-    }
-
-    nm_assert(g_hash_table_size(self->idx_entries) == 0);
-
-    g_hash_table_iter_init(&iter, self->idx_objs);
-    while (g_hash_table_iter_next(&iter, (gpointer *) &obj, NULL)) {
-        nm_assert(obj->_multi_idx == self);
-        ((NMDedupMultiObj *) obj)->_multi_idx = NULL;
-    }
-    g_hash_table_remove_all(self->idx_objs);
-
-    g_hash_table_unref(self->idx_entries);
-    g_hash_table_unref(self->idx_objs);
-
-    g_slice_free(NMDedupMultiIndex, self);
-    return NULL;
-}