source: doc/theses/mike_brooks_MMath/programs/lst-issues-attach-reduction.hpp @ 4c8f29ff

// excerpt of <sys/queue.h>, modified to work in C++ along with templates

#define LIST_HEAD(name, type)                                           \
struct name {                                                           \
        type *lh_first; /* first element */                     \
}

#define LIST_HEAD_INITIALIZER(head)                                     \
        { NULL }

#define LIST_ENTRY(type)                                                \
struct {                                                                \
        type *le_next;  /* next element */                      \
        type **le_prev; /* address of previous next element */  \
}

/*
 * List functions.
 */
#define LIST_INIT(head) do {                                            \
        (head)->lh_first = NULL;                                        \
} while (/*CONSTCOND*/0)

#define LIST_INSERT_AFTER(listelm, elm, field) do {                     \
        if (((elm)->field.le_next = (listelm)->field.le_next) != NULL)  \
                (listelm)->field.le_next->field.le_prev =               \
                    &(elm)->field.le_next;                              \
        (listelm)->field.le_next = (elm);                               \
        (elm)->field.le_prev = &(listelm)->field.le_next;               \
} while (/*CONSTCOND*/0)

#define LIST_INSERT_BEFORE(listelm, elm, field) do {                    \
        (elm)->field.le_prev = (listelm)->field.le_prev;                \
        (elm)->field.le_next = (listelm);                               \
        *(listelm)->field.le_prev = (elm);                              \
        (listelm)->field.le_prev = &(elm)->field.le_next;               \
} while (/*CONSTCOND*/0)

#define LIST_INSERT_HEAD(head, elm, field) do {                         \
        if (((elm)->field.le_next = (head)->lh_first) != NULL)          \
                (head)->lh_first->field.le_prev = &(elm)->field.le_next;\
        (head)->lh_first = (elm);                                       \
        (elm)->field.le_prev = &(head)->lh_first;                       \
} while (/*CONSTCOND*/0)

#define LIST_REMOVE(elm, field) do {                                    \
        if ((elm)->field.le_next != NULL)                               \
                (elm)->field.le_next->field.le_prev =                   \
                    (elm)->field.le_prev;                               \
        *(elm)->field.le_prev = (elm)->field.le_next;                   \
} while (/*CONSTCOND*/0)

#define LIST_FOREACH(var, head, field)                                  \
        for ((var) = ((head)->lh_first);                                \
                (var);                                                  \
                (var) = ((var)->field.le_next))

/*
 * List access methods.
 */
#define LIST_EMPTY(head)                ((head)->lh_first == NULL)
#define LIST_FIRST(head)                ((head)->lh_first)
#define LIST_NEXT(elm, field)           ((elm)->field.le_next)







namespace my {


























template<typename El>
class list {
        struct node {
                @LIST_ENTRY(node) links;@
                @El elem;@
        };
        LIST_HEAD(Impl, node);
        Impl impl;
  public:
        list() {
                LIST_INIT(&impl);
        }
        void push_front( const El & src ) {
                node * n = @new node()@;
                n->elem = src;
                LIST_INSERT_HEAD(&impl, n, links);
        }
        // ... `emplace` elided













        template<typename... CtorArgs>
        void emplace_front( CtorArgs... args ) {  
                El tempEl{args...}; // (mock: avoid real emplacing to keep `struct node` simple; disucssion is about allocation, not copying)
                push_front(tempEl);
        }
        class IType {
                node* p;
          public:
                IType(node* p) : p(p) {}
                bool operator!=(IType rhs) {return p != rhs.p;}
                const El& operator*() {return p->elem;}
                void operator++() { p = LIST_NEXT(p, links); }
        };
        IType begin() {return IType(LIST_FIRST(&impl)); }
        IType end() {return IType(NULL); }




};






}