deque.h

Go to the documentation of this file.

#pragma once
 
/* ************************************************************************** */
/*      ____    _    _____ ____     _    _   _   _____ _  _   ____  ____      */
/*     / ___|  / \  |  ___|  _ \   / \  | \ | | |_   _| || | |  _ \/ ___|     */
/*     \___ \ / _ \ | |_  | |_) | / _ \ |  \| |   | | | || |_| | | \___ \     */
/*      ___) / ___ \|  _| |  _ < / ___ \| |\  |   | | |__   _| |_| |___) |    */
/*     |____/_/   \_|_|   |_| \_/_/   \_|_| \_|   |_|    |_| |____/|____/     */
/*                                                                            */
/* ************************************************************************** */
 
#include <stdbool.h> // bool
#include <stddef.h>  // size_t
 
/* Forward declaration */
struct array;

typedef struct deque
{
    void*  storage;   
    void*  front;     
    void*  back;      
    size_t count;     
    size_t capacity;  
    size_t type_size; 
} deque_t;

deque_t deque_new(void* storage, size_t capacity, size_t type_size);
void    deque_clear(deque_t* self);
//void    deque_clear_f(deque_t* self, void (*cleanup)());

#define DequeNew(Storage, Capacity, Type) \
    deque_new(Storage, Capacity, sizeof(Type))


deque_t deque_allocate(size_t capacity, size_t type_size);
void    deque_free(deque_t* self);
//void    deque_free_f(deque_t* self, void (*cleanup)());

#define DequeAllocate(Capacity, Type) deque_allocate(Capacity, sizeof(Type))

#define Deque                         __attribute__((cleanup(deque_free))) deque_t

void*  deque_first(const deque_t* self);
void*  deque_last(const deque_t* self);
void*  deque_get(const deque_t* self, size_t index);

bool   deque_is_empty(const deque_t* self);
bool   deque_is_full(const deque_t* self);
 
size_t deque_count(const deque_t* self);
size_t deque_capacity(const deque_t* self);
size_t deque_room(const deque_t* self);
 
void   deque_reserve(deque_t* self, size_t count);

bool   deque_push_front(deque_t* self, const void* element);
bool   deque_push_front_n(deque_t* self, const void* elements, size_t count);
 
bool   deque_push_back(deque_t* self, const void* element);
bool   deque_push_back_n(deque_t* self, const void* elements, size_t count);

bool   deque_pop_front(deque_t* self, void* destination);
bool   deque_pop_front_n(deque_t* self, void* destination, size_t count);
 
bool   deque_pop_back(deque_t* self, void* destination);
bool   deque_pop_back_n(deque_t* self, void* destination, size_t count);
 
bool   deque_pop_front_into_array(deque_t* self, struct array* destination, size_t count);

//void   deque_iter(const deque_t* self, void (*f)());
//void   deque_iter1(const deque_t* self, void (*f)(), void* ext);
//void   deque_iter2(const deque_t* self, void (*f)(), void* ext1, void* ext2);

#define deque_foreach(TYPE, DEQUE, ELEMENT) \
    for (unsigned _i = 0; _i < deque_count(DEQUE) \
                          && ((*(ELEMENT) = *(TYPE*)deque_get(DEQUE, _i)) || true); \
         _i++)

#define deque_enumerate(TYPE, DEQUE, ELEMENT, INDEX) \
    for (*(INDEX) = 0; *(INDEX) < deque_count(DEQUE) \
                       && ((*(ELEMENT) = *(TYPE*)deque_get(DEQUE, *(INDEX))) || true); \
         (*(INDEX))++)