queue.h

#ifndef _AVRIO_QUEUE_H_
#  define _AVRIO_QUEUE_H_

#  include <avrio/defs.h>
#  include <avrio/mutex.h>

__BEGIN_C_DECLS
  /* ======================================================================== */
  /* structures ============================================================= */
   struct xQueue;

/* constants ================================================================ */

/* internal public functions ================================================ */
void vQueuePush (struct xQueue *pxQueue, uint8_t ucByte);

uint8_t ucQueuePull (struct xQueue *pxQueue);

void vQueueDrop (struct xQueue *pxQueue);

uint8_t ucQueueRead (struct xQueue *pxQueue, size_t xIndex);

void vQueuePushWord (struct xQueue *pxQueue, uint16_t usWord);

uint16_t usQueuePullWord (struct xQueue *pxQueue);

uint16_t usQueueReadWord (struct xQueue *pxQueue, size_t xIndex);

const char *pcQueuePushString (struct xQueue *pxQueue, const char *pcString);

size_t xQueuePushBytes (struct xQueue *pxQueue, const uint8_t * pucBytes,
                        size_t xLength);

size_t xQueuePushBytesOfQueue (struct xQueue *pxDstQueue,
                               struct xQueue *pxSrcQueue, size_t xLength);

size_t xQueuePullBytes (struct xQueue *pxQueue,
                        uint8_t * pucBytes, size_t xLength);

size_t xQueuePullAll (struct xQueue *pxQueue, uint8_t * pucBytes);

void vQueueDropBytes (struct xQueue *pxQueue, size_t xLength);

void vQueueFlush (struct xQueue *pxQueue);

void vQueueSetBuffer (struct xQueue *pxQueue, uint8_t * pucBuffer, size_t xBufferSize);

size_t xQueueLength (struct xQueue *pxQueue);

size_t xQueueSize (struct xQueue *pxQueue);

int iQueueCompare (struct xQueue *pxQueue1, struct xQueue *pxQueue2);

size_t xQueueFree (struct xQueue *pxQueue);

struct xQueue *pxQueueNew (size_t xBufferSize);

void vQueueDelete (struct xQueue *pxQueue);

#  if defined(__DOXYGEN__)
/*
 * __DOXYGEN__ defined
 * Partie documentation ne devant pas être compilée.
 * =============================================================================
 */
/* macros =================================================================== */
#    define QUEUE_DECLARE(xVarName, xBufferSize)

#    define QUEUE_STATIC_DECLARE(xVarName, xBufferSize)

/* inline public functions ================================================== */

bool xQueueIsEmpty (struct xQueue *pxQueue);

bool xQueueIsFull (struct xQueue *pxQueue);

size_t xQueuePushQueue (struct xQueue *pxDstQueue, struct xQueue *pxSrcQueue);

size_t xQueueSizeOf (struct xQueue *pxQueue);

void vQueueCopy (struct xQueue *pxDst, const struct xQueue *pxSrc);

#  else
/*
 * __DOXYGEN__ not defined
 * Partie ne devant pas être documentée.
 * =============================================================================
 */
#    include "avrio-config.h"
#    include <string.h>

/* structures =============================================================== */
struct xQueue {
  uint8_t *pxFirst;
  uint8_t *pxLast;
  uint8_t * volatile pxIn;
  uint8_t * volatile pxOut;
  volatile bool isEmpty;
  volatile bool isFull;
  // TODO: suppression
  xMutex xLock;
};

/* types ==================================================================== */
typedef struct xQueue xQueue;

/* macros =================================================================== */
#define QUEUE_MUTEX_INITIALIZER (MUTEX_INITIALIZER & ~QUEUE_LOCK_EMPTY)

  // ----------------------------------------------------------------------------
#      define QUEUE_DECLARE(__name,__size)                          \
    uint8_t __name ## Buffer[__size];                           \
    xQueue __name = { .pxFirst = __name ## Buffer,              \
                      .pxLast  = __name ## Buffer + __size - 1, \
                      .pxIn    = __name ## Buffer,              \
                      .pxOut   = __name ## Buffer,              \
                      .isEmpty = true,                          \
                      .isFull  = false,                         \
                      .xLock   = MUTEX_INITIALIZER }

  // ----------------------------------------------------------------------------
#      define QUEUE_STATIC_DECLARE(__name,__size)                           \
    static uint8_t __name ## Buffer[__size];                            \
    static xQueue __name = {  .pxFirst = __name ## Buffer,              \
                              .pxLast  = __name ## Buffer + __size - 1, \
                              .pxIn    = __name ## Buffer,              \
                              .pxOut   = __name ## Buffer,              \
                              .isEmpty = true,                          \
                              .isFull  = false,                         \
                              .xLock   = MUTEX_INITIALIZER }

/* inline public functions ================================================== */
// ------------------------------------------------------------------------------
INLINE bool xQueueIsEmpty (xQueue * q) {

  return q->isEmpty;
}

// ------------------------------------------------------------------------------
INLINE bool xQueueIsFull (xQueue * q) {

  return q->isFull;
}

// ------------------------------------------------------------------------------
INLINE size_t xQueuePushQueue (struct xQueue *pxDstQueue,
                               struct xQueue *pxSrcQueue) {

  return xQueuePushBytesOfQueue (pxDstQueue, pxSrcQueue,
                                 xQueueLength (pxSrcQueue));
}

// ------------------------------------------------------------------------------
INLINE size_t xQueueSizeOf (xQueue * q) {

  return sizeof (xQueue) + xQueueSize (q);
}

// ------------------------------------------------------------------------------
INLINE void
  vQueueCopy (struct xQueue *pxDst, const struct xQueue *pxSrc) {

  memcpy (pxDst, pxSrc, sizeof(xQueue));
}

//
// TODO:
//  Suppression des mutex (recherche dépendances dans avrio et autres projets
//
/* constants ================================================================ */
typedef enum {

  QUEUE_LOCK_RD     = 0x01,  
  QUEUE_LOCK_WR     = 0x02,  
  QUEUE_LOCK_FULL   = 0x04,  
  QUEUE_LOCK_EMPTY  = 0x08,  
  QUEUE_LOCK_FREE   = QUEUE_LOCK_RD | QUEUE_LOCK_WR,
  QUEUE_LOCK_ALL    = QUEUE_LOCK_RD | QUEUE_LOCK_WR | QUEUE_LOCK_FULL
} eQueueLock;

// ----------------------------------------------------------------------------
INLINE void
                        vQueueUnlock (struct xQueue *q,
                                      uint8_t ucMask) {

  vMutexUnlockBit (&(q->xLock), ucMask);
}

// ----------------------------------------------------------------------------
INLINE void
                        vQueueLock (struct xQueue *q, uint8_t ucMask) {

  vMutexLockBit (&(q->xLock), ucMask);
}

// ----------------------------------------------------------------------------
INLINE void
                        vQueueUntilLocked (struct xQueue *q, uint8_t ucMask) {

  vMutexUntilBitUnlocked (&(q->xLock), ucMask);
}

// ----------------------------------------------------------------------------
INLINE int8_t
                        xQueueTryLock (struct xQueue *q,
                                       uint8_t ucMask) {

  return xMutexTryLockBit (&(q->xLock), ucMask);
}

// ------------------------------------------------------------------------------
INLINE void vQueueWaitUntilIsFull (struct xQueue * q) {

  vQueueUntilLocked    (q, QUEUE_LOCK_FULL);
}

// ------------------------------------------------------------------------------
INLINE void vQueueWaitUntilIsEmpty (struct xQueue * q) {

  vQueueUntilLocked    (q, QUEUE_LOCK_EMPTY);
}

#  endif /* __DOXYGEN__ not defined */
/* ========================================================================== */
__END_C_DECLS
#endif /* _AVRIO_QUEUE_H_ */