/* SPDX-License-Identifier: LGPL-2.1-or-later */

/*

 * Copyright (C) 2014 Red Hat, Inc.

 */

#ifndef __NM_C_LIST_H__

#define __NM_C_LIST_H__

#include "c-list/src/c-list.h"

/*****************************************************************************/

#define nm_c_list_contains_entry(list, what, member)   \

    ({                                                 \

        typeof(what) _what = (what);                   \

                                                       \

        _what &&c_list_contains(list, &_what->member); \

    })

/*****************************************************************************/

typedef struct {

    CList lst;

    void *data;

} NMCListElem;

static inline NMCListElem *

nm_c_list_elem_new_stale(void *data)

{

    NMCListElem *elem;

    elem       = g_slice_new(NMCListElem);

    elem->data = data;

    return elem;

}

static inline gboolean

nm_c_list_elem_free_full(NMCListElem *elem, GDestroyNotify free_fcn)

{

    if (!elem)

        return FALSE;

    c_list_unlink_stale(&elem->lst);

    if (free_fcn)

        free_fcn(elem->data);

    g_slice_free(NMCListElem, elem);

    return TRUE;

}

static inline gboolean

nm_c_list_elem_free(NMCListElem *elem)

{

    return nm_c_list_elem_free_full(elem, NULL);

}

static inline void *

nm_c_list_elem_free_steal(NMCListElem *elem)

{

    gpointer data;

    if (!elem)

        return NULL;

    data = elem->data;

    nm_c_list_elem_free_full(elem, NULL);

    return data;

}

static inline void

nm_c_list_elem_free_all(CList *head, GDestroyNotify free_fcn)

{

    NMCListElem *elem;

    while ((elem = c_list_first_entry(head, NMCListElem, lst)))

        nm_c_list_elem_free_full(elem, free_fcn);

}

#define nm_c_list_elem_find_first(head, arg, predicate) \

    ({                                                  \

        CList *const _head   = (head);                  \

        NMCListElem *_result = NULL;                    \

        NMCListElem *_elem;                             \

                                                        \

        c_list_for_each_entry (_elem, _head, lst) {     \

            void *const arg = _elem->data;              \

                                                        \

            if (predicate) {                            \

                _result = _elem;                        \

                break;                                  \

            }                                           \

        }                                               \

        _result;                                        \

    })

/**

 * nm_c_list_elem_find_first_ptr:

 * @head: the @CList head of a list containing #NMCListElem elements.

 *   Note that the head is not itself part of the list.

 * @needle: the needle pointer.

 *

 * Iterates the list and returns the first #NMCListElem with the matching @needle,

 * using pointer equality.

 *

 * Returns: the found list element or %NULL if not found.

 */

static inline NMCListElem *

nm_c_list_elem_find_first_ptr(CList *head, gconstpointer needle)

{

    return nm_c_list_elem_find_first(head, x, x == needle);

}

/*****************************************************************************/

/**

 * nm_c_list_move_before:

 * @lst: the list element to which @elem will be prepended.

 * @elem: the list element to move.

 *

 * This unlinks @elem from the current list and linkes it before

 * @lst. This is like c_list_link_before(), except that @elem must

 * be initialized and linked. Note that @elem may be linked in @lst

 * or in another list. In both cases it gets moved.

 *

 * Returns: %TRUE if there were any changes. %FALSE if elem was already

 *   linked at the right place.

 */

static inline gboolean

nm_c_list_move_before(CList *lst, CList *elem)

{

    nm_assert(lst);

    nm_assert(elem);

    if (lst != elem && lst->prev != elem) {

        c_list_unlink_stale(elem);

        c_list_link_before(lst, elem);

        return TRUE;

    }

    return FALSE;

}

#define nm_c_list_move_tail(lst, elem) nm_c_list_move_before(lst, elem)

/**

 * nm_c_list_move_after:

 * @lst: the list element to which @elem will be prepended.

 * @elem: the list element to move.

 *

 * This unlinks @elem from the current list and linkes it after

 * @lst. This is like c_list_link_after(), except that @elem must

 * be initialized and linked. Note that @elem may be linked in @lst

 * or in another list. In both cases it gets moved.

 *

 * Returns: %TRUE if there were any changes. %FALSE if elem was already

 *   linked at the right place.

 */

static inline gboolean

nm_c_list_move_after(CList *lst, CList *elem)

{

    nm_assert(lst);

    nm_assert(elem);

    if (lst != elem && lst->next != elem) {

        c_list_unlink_stale(elem);

        c_list_link_after(lst, elem);

        return TRUE;

    }

    return FALSE;

}

#define nm_c_list_move_front(lst, elem) nm_c_list_move_after(lst, elem)

#define nm_c_list_free_all(lst, type, member, destroy_fcn)         \

    G_STMT_START                                                   \

    {                                                              \

        CList *const _lst = (lst);                                 \

        type *       _elem;                                        \

                                                                   \

        while ((_elem = c_list_first_entry(_lst, type, member))) { \

            destroy_fcn(_elem);                                    \

        }                                                          \

    }                                                              \

    G_STMT_END

#endif /* __NM_C_LIST_H__ */