iterator.h

Go to the documentation of this file.

#ifndef ITERATOR_H
#define ITERATOR_H

#include <stdbool.h>
#include <stdint.h>
#include "macros.h"

#ifdef DOXYGEN
namespace c::include::iterator {
#endif

void no_destructor(void *it);
inline void no_destructor(void *it) {}

#define IteratorTail(return_type, struct_type) \
    return_type (*const iterator_function)(struct_type *it); \
    void (*const destructor)(void *it); \
    bool exhausted : 1;\
    bool started : 1;\
    bool phase : 1; 
#define IterationHead(it) \
    it->started = 1; \
    it->phase = !(it->phase)

#define IteratorInitHead(advance, ...) {.iterator_function = &advance, AddDestructor(no_destructor), __VA_ARGS__}

#define AddDestructor(func) ExtendInit(destructor, (void (*const)(void *)) &func)

#define ExtendInit(name, value) .name = value

#define next(state) (*(state.iterator_function))(&state)

#define next_p(state) (*(state->iterator_function))(state)

#define free_iterator(it) (*(it.destructor))(&it)

#define free_iterator_p(it) (*(it->destructor))(it)

typedef struct Iterator Iterator;
struct Iterator {
    bool exhausted : 1; 
    bool started : 1; 
    bool phase : 1; 
};
// note that this exists purely for documentation purposes. The tail macro has these features
// marked to be hidden so that these attributes properly appear as inherited.

typedef struct counter counter;
struct counter {
    uintmax_t idx; 
    uintmax_t stop; 
    intmax_t step; 
    IteratorTail(uintmax_t, counter)
};

static uintmax_t iterate_counter(counter *i);
static inline uintmax_t iterate_counter(counter *i) {
    IterationHead(i);
    uintmax_t ret = i->idx;
    intmax_t step = i->step;
    i->idx += step;
    if ((step > 0 && i->idx >= i->stop) || (step < 0 && i->idx <= i->stop))   {
        i->exhausted = 1;
    }
    return ret;
}

counter count_by(uintmax_t start, uintmax_t stop, intmax_t step);
inline counter count_by(uintmax_t start, uintmax_t stop, intmax_t step) {
    return (counter) IteratorInitHead(
        iterate_counter,
        ExtendInit(idx, start),
        ExtendInit(stop, stop),
        ExtendInit(step, step)
    );
}

counter count_in_range(uintmax_t start, uintmax_t stop);
inline counter count_in_range(uintmax_t start, uintmax_t stop)  {
    return count_by(start, stop, 1);
}

counter count_to(uintmax_t stop);
inline counter count_to(uintmax_t stop)    {
    return count_in_range(0, stop);
}

#ifdef DOXYGEN
};
#endif

#endif