suif库 declare_list_class 展开效果图

/*
 * declare_list_class.cpp
 *
 *  Created on: 2011-12-22
 *      Author: Administrator
 */

class glist_e {
    friend class glist;
    friend class mtflist;
    friend class dlist;

protected:

    glist_e(const glist_e &);
    glist_e &operator=(const glist_e &);

protected:
    glist_e *next_e;

public:
    glist_e() :
        next_e(0) {
    }
    glist_e *next() const {
        return next_e;
    }
};


class glist {
private:

    glist(const glist &);
    glist &operator=(const glist &);

protected:
    glist_e *head_e, *tail_e;

public:
    glist() :
        head_e(0), tail_e(0) {
    }
    virtual ~glist();

    boolean is_empty() const {
        return head_e == NULL;
    }
    glist_e *head() const {
        return head_e;
    }
    glist_e *tail() const {
        return tail_e;
    }
    glist_e *push(glist_e *e);
    glist_e *pop();
    glist_e *append(glist_e *e);
    glist_e *insert_before(glist_e *e, glist_e *pos);
    glist_e *insert_after(glist_e *e, glist_e *pos);
    glist_e *remove(glist_e *e);
    void clear() {
        head_e = tail_e = NULL;
    }
    void erase();
    void grab_from(glist *l);
    void push(glist *l);
    void append(glist *l);
    void insert_before(glist *l, glist_e *pos);
    void insert_after(glist *l, glist_e *pos);
    int count() const;
    boolean contains(const glist_e *e) const;
    glist_e *operator[](int ndx) const;
};


class glist_iter {
private:

    glist_iter(const glist_iter &);
    glist_iter &operator=(const glist_iter &);

protected:
    glist_e *cur, *nxt;

public:
    glist_iter() :
        cur(0), nxt(0) {
    }
    glist_iter(const glist *gl) :
        cur(0), nxt(0) {
        reset(gl);
    }

    void reset(const glist *gl);
    void set(glist_e *e);

    boolean is_empty() const {
        return nxt == NULL;
    }
    glist_e *step();
    glist_e *peek() const {
        return nxt;
    }
    glist_e *cur_elem() const {
        return cur;
    }
};


class super_block_list_e: public glist_e {
private:
    super_block_list_e(const super_block_list_e &o) :
        contents(o.contents) {
        assert(0);
    }
    super_block_list_e &operator=(const super_block_list_e &) {
        assert(0);
        return *this;
    }
public:
    super_block * contents;
    super_block_list_e(super_block * t) :
        contents(t) {
    }
    super_block_list_e *next() const {
        return (super_block_list_e*) glist_e::next();
    }
    ;
};


class super_block_list: public glist {
protected:
    virtual void set_elem(super_block_list_e *) {
    }
    void set_elems(super_block_list *l) {
        super_block_list_e *i = l->head();
        while (i) {
            set_elem(i);
            i = i->next();
        }
    }
private:
    super_block_list(const super_block_list &) {
        assert(0);
    }
    super_block_list &operator=(const super_block_list &) {
        assert(0);
        return *this;
    }
public:
    super_block_list() {
    }
    super_block_list(super_block * t) {
        append(t);
    }
    super_block_list(super_block * t1, super_block * t2) {
        append(t1);
        append(t2);
    }
    super_block_list(super_block * t1, super_block * t2, super_block * t3) {
        append(t1);
        append(t2);
        append(t3);
    }
    virtual ~super_block_list() {
    }
    super_block_list_e *head() const {
        return (super_block_list_e*) glist::head();
    }
    super_block_list_e *tail() const {
        return (super_block_list_e*) glist::tail();
    }
    super_block * push(super_block * t) {
        return push(new super_block_list_e(t))->contents;
    }
    super_block_list_e *push(super_block_list_e *e) {
        set_elem(e);
        return (super_block_list_e*) glist::push(e);
    }
    super_block * pop() {
        super_block_list_e *e = (super_block_list_e *) glist::pop();
        super_block * t = e->contents;
        delete e;
        return t;
    }
    super_block * append(super_block * t) {
        return append(new super_block_list_e(t))->contents;
    }
    super_block_list_e *append(super_block_list_e *e) {
        set_elem(e);
        return (super_block_list_e*) glist::append(e);
    }
    super_block * insert_before(super_block * t, super_block_list_e *pos) {
        return insert_before(new super_block_list_e(t), pos)->contents;
    }
    super_block_list_e *insert_before(super_block_list_e *e,
            super_block_list_e *pos) {
        set_elem(e);
        return (super_block_list_e*) glist::insert_before(e, pos);
    }
    super_block * insert_after(super_block * t, super_block_list_e *pos) {
        return insert_after(new super_block_list_e(t), pos)->contents;
    }
    super_block_list_e *insert_after(super_block_list_e *e,
            super_block_list_e *pos) {
        set_elem(e);
        return (super_block_list_e*) glist::insert_after(e, pos);
    }
    super_block_list_e *remove(super_block_list_e *e) {
        return (super_block_list_e*) glist::remove(e);
    }
    void copy(const super_block_list *l) {
        super_block_list_e *i = l->head();
        while (i) {
            append(i->contents);
            i = i->next();
        }
    }
    void grab_from(super_block_list *l) {
        set_elems(l);
        glist::grab_from(l);
    }
    void push(super_block_list *l) {
        set_elems(l);
        glist::push(l);
    }
    void append(super_block_list *l) {
        set_elems(l);
        glist::append(l);
    }
    void insert_before(super_block_list *l, super_block_list_e *pos) {
        set_elems(l);
        glist::insert_before(l, pos);
    }
    void insert_after(super_block_list *l, super_block_list_e *pos) {
        set_elems(l);
        glist::insert_after(l, pos);
    }
    super_block * operator[](int ndx) const {
        return ((super_block_list_e*) glist::operator[](ndx))->contents;
    }
    super_block_list_e *lookup(const super_block * t) const {
        super_block_list_e *i = head();
        while (i) {
            if (i->contents == t)
                break;
            i = i->next();
        }
        return i;
    }
    ;
};


class super_block_list_iter: public glist_iter {
public:
    super_block_list_iter() :
        glist_iter() {
    }
    super_block_list_iter(const super_block_list *l) :
        glist_iter(l) {
    }
    super_block * step() {
        return ((super_block_list_e*) glist_iter::step())->contents;
    }
    super_block * peek() const {
        assert_msg(!is_empty(),
                ("%s_iter::peek - no next element", "super_block_list"));
        return ((super_block_list_e*) glist_iter::peek())->contents;
    }
    super_block_list_e *cur_elem() const {
        return (super_block_list_e*) glist_iter::cur_elem();
    }
};