outbox_queue.h

Go to the documentation of this file.

#pragma once
#include <stdbool.h>


#define OUTBOX_QUEUE_MAX 6

typedef enum
{
    OUTBOX_NONE,     
    OUTBOX_WEATHER,  
    OUTBOX_SETTINGS, 
    OUTBOX_FRESH,    
    OUTBOX_STOCK,    
    OUTBOX_CALENDAR  
} OutboxKind;

typedef struct
{
    OutboxKind kind;         
    int        retries_left; 
} OutboxJob;

typedef struct
{
    OutboxJob queue[OUTBOX_QUEUE_MAX];  
    int       queue_len;                
    OutboxJob failed[OUTBOX_QUEUE_MAX]; 
    int       failed_len;               
    OutboxJob inflight;                 
} OutboxQueue;

static inline bool outbox_busy(const OutboxQueue *outbox)
{
    return outbox->inflight.kind != OUTBOX_NONE;
}

static inline bool outbox_pending(const OutboxQueue *outbox, OutboxKind kind)
{
    if (kind == OUTBOX_NONE)
    {
        // the empty flight slot and every unused array entry read as OUTBOX_NONE, so without this
        // an idle outbox would answer that nothing is already pending
        return false;
    }
 
    if (outbox->inflight.kind == kind)
    {
        return true;
    }
 
    for (int i = 0; i < outbox->queue_len; i++)
    {
        if (outbox->queue[i].kind == kind)
        {
            return true;
        }
    }
 
    for (int i = 0; i < outbox->failed_len; i++)
    {
        if (outbox->failed[i].kind == kind)
        {
            return true;
        }
    }
 
    return false;
}

static inline bool outbox_push(OutboxQueue *outbox, OutboxKind kind, int retries)
{
    if (outbox_pending(outbox, kind) || outbox->queue_len >= OUTBOX_QUEUE_MAX)
    {
        return false;
    }
 
    outbox->queue[outbox->queue_len].kind = kind;
    outbox->queue[outbox->queue_len].retries_left = retries;
    outbox->queue_len++;
    return true;
}

static inline void outbox_pop_front(OutboxQueue *outbox)
{
    for (int i = 1; i < outbox->queue_len; i++)
    {
        outbox->queue[i - 1] = outbox->queue[i];
    }
 
    if (outbox->queue_len > 0)
    {
        outbox->queue_len--;
    }
}

static inline void outbox_take_head(OutboxQueue *outbox)
{
    if (outbox->queue_len == 0)
    {
        return;  // outbox_clear leaves the array behind, so an empty queue still has one to read
    }
 
    outbox->inflight = outbox->queue[0];
    outbox_pop_front(outbox);
}

static inline OutboxJob outbox_release(OutboxQueue *outbox)
{
    OutboxJob settled = outbox->inflight;
    outbox->inflight.kind = OUTBOX_NONE;
    return settled;
}

static inline void outbox_hold_failed(OutboxQueue *outbox, OutboxJob job)
{
    // a failure reported once the slot is already free comes with no job, and holding it would
    // queue a send for nothing ahead of the real requests
    if (job.kind == OUTBOX_NONE || job.retries_left <= 0)
    {
        return;
    }
 
    if (outbox->failed_len < OUTBOX_QUEUE_MAX)
    {
        outbox->failed[outbox->failed_len].kind = job.kind;
        outbox->failed[outbox->failed_len].retries_left = job.retries_left - 1;
        outbox->failed_len++;
    }
}

static inline int outbox_retry_pass(OutboxQueue *outbox)
{
    int moved = 0;
 
    while (outbox->failed_len > 0 && outbox->queue_len < OUTBOX_QUEUE_MAX)
    {
        outbox->queue[outbox->queue_len++] = outbox->failed[0];
        for (int i = 1; i < outbox->failed_len; i++)
        {
            outbox->failed[i - 1] = outbox->failed[i];
        }
        outbox->failed_len--;
        moved++;
    }
 
    return moved;
}

static inline void outbox_clear(OutboxQueue *outbox)
{
    outbox->queue_len = 0;
    outbox->failed_len = 0;
}