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

 * queue.c: generic queue (FIFO)

 *****************************************************************************

 * Copyright (C) 2020 Rémi Denis-Courmont

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms of the GNU Lesser General Public License as published by

 * the Free Software Foundation; either version 2.1 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * GNU Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with this program; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.

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

#ifdef HAVE_CONFIG_H

# include "config.h"

#endif

#include <assert.h>

#include <stdint.h>

#include <stdlib.h>

#include <vlc_common.h>

#include <vlc_queue.h>

/* Opaque struct type.

 *

 * ISO C uses the same representation for all pointer-to-struct types.

 * Still different pointer types are not compatible, i.e. cannot alias.

 * So use memcpy() to read/write pointer values.

 */

struct vlc_queue_entry;

static void entry_set(struct vlc_queue_entry **pp, struct vlc_queue_entry *e)

{

    memcpy(pp, &e, sizeof (e));

}

static struct vlc_queue_entry *entry_get(struct vlc_queue_entry *const *pp)

{

    struct vlc_queue_entry *e;

    memcpy(&e, pp, sizeof (e));

    return e;

}

static struct vlc_queue_entry **next_p(const struct vlc_queue_entry *e,

                                       ptrdiff_t offset)

{

    return (struct vlc_queue_entry **)(((unsigned char *)e) + offset);

}

static void next_set(struct vlc_queue_entry *e, struct vlc_queue_entry *next,

                     ptrdiff_t offset)

{

    entry_set(next_p(e, offset), next);

}

static struct vlc_queue_entry *next_get(const struct vlc_queue_entry *e,

                                        ptrdiff_t offset)

{

    return entry_get(next_p(e, offset));

}

void vlc_queue_Init(vlc_queue_t *q, ptrdiff_t next_offset)

{

    q->first = NULL;

    q->lastp = &q->first;

    q->next_offset = next_offset;

    vlc_mutex_init(&q->lock);

    vlc_cond_init(&q->wait);

}

void vlc_queue_EnqueueUnlocked(vlc_queue_t *q, void *entry)

{

    struct vlc_queue_entry **lastp;

    const ptrdiff_t offset = q->next_offset;

    vlc_mutex_assert(&q->lock);

    assert(entry_get(q->lastp) == NULL);

    entry_set(q->lastp, entry);

    for (lastp = q->lastp; entry != NULL; entry = next_get(entry, offset))

        lastp = next_p(entry, offset);

    q->lastp = lastp;

    vlc_queue_Signal(q);

}

void *vlc_queue_DequeueUnlocked(vlc_queue_t *q)

{

    vlc_mutex_assert(&q->lock);

    void *entry = q->first;

    const ptrdiff_t offset = q->next_offset;

    if (entry != NULL) {

        struct vlc_queue_entry *next = next_get(entry, offset);

        next_set(entry, NULL, offset);

        q->first = next;

        if (next == NULL)

            q->lastp = &q->first;

    }

    return entry;

}

void *vlc_queue_DequeueAllUnlocked(vlc_queue_t *q)

{

    vlc_mutex_assert(&q->lock);

    void *entry = q->first;

    q->first = NULL;

    q->lastp = &q->first;

    return entry;

}

void vlc_queue_Enqueue(vlc_queue_t *q, void *entry)

{

    vlc_queue_Lock(q);

    vlc_queue_EnqueueUnlocked(q, entry);

    vlc_queue_Unlock(q);

}

void *vlc_queue_Dequeue(vlc_queue_t *q)

{

    void *entry;

    vlc_queue_Lock(q);

    vlc_testcancel();

    while (vlc_queue_IsEmpty(q))

        vlc_queue_Wait(q);

    entry = vlc_queue_DequeueUnlocked(q);

    vlc_queue_Unlock(q);

    return entry;

}

void *vlc_queue_DequeueAll(vlc_queue_t *q)

{

    void *entry;

    vlc_queue_Lock(q);

    entry = vlc_queue_DequeueAllUnlocked(q);

    vlc_queue_Unlock(q);

    return entry;

}