CircDLelement.h

Go to the documentation of this file.

#ifndef  CIRC_DL_ELEMENT_H

#define CIRC_DL_ELEMENT_H
#include "DLelement.h"

namespace bridges {
    namespace datastructure {
        template <typename E>
        class CircDLelement : public  DLelement<E> {
            public:
                CircDLelement() : DLelement<E> (this, this, E()) {
                }

                CircDLelement (E e, string label)
                    : DLelement<E>(this, this, e, label) {
                }

                CircDLelement(CircDLelement<E> next, CircDLelement<E> prev)
                    : DLelement<E>(this, this) {
                }

                CircDLelement(E e, CircDLelement<E> next, CircDLelement<E> prev)
                    : DLelement<E>(this, this, e) {
                }

                virtual const string getDStype() const override {
                    return "CircularDoublyLinkedList";
                }

                const CircDLelement<E> *getNext() const override {
                    return static_cast<const CircDLelement*>(SLelement<E>::getNext());
                }

                virtual CircDLelement<E> *getNext() override {
                    return static_cast<CircDLelement*> (SLelement<E>::getNext());
                }

                void setNext(CircDLelement<E> *next) {
                    DLelement<E>::setNext(next);
                }

                CircDLelement<E> *getPrev() override {
                    return static_cast<CircDLelement*>(DLelement<E>::getPrev());
                }

                const CircDLelement<E> *getPrev() const override {
                    return static_cast<const CircDLelement*>(DLelement<E>::getPrev());
                }

                void setPrev(CircDLelement<E> *prev) {
                    DLelement<E>::setPrev(prev);
                }
            public:

                class CircDLelement_listhelper {
                        typename bridges::datastructure::CircDLelement<E> *start, *last;

                    public:
                        CircDLelement_listhelper (typename bridges::datastructure::CircDLelement< E > * s)
                            : start(s), last(s) {

                        }

                        class iterator {

                                typename bridges::datastructure::CircDLelement<E> *current;

                            public:

                                iterator(typename bridges::datastructure::CircDLelement<E> * c )
                                    : current(c)
                                {}

                                bool operator!= (const iterator& it) const {
                                    return this->current != it.current;
                                }

                                E const &  operator* () const {
                                    return current->getValue();
                                }

                                E &  operator* ()  {
                                    return current->getValue();
                                }

                                iterator& operator++ () {
                                    current = current->getNext();
                                    return *this;
                                }
                                iterator operator++ (int) {
                                    iterator clone(*this);
                                    current = current->getNext();
                                    return clone;
                                }
                                iterator& operator-- () {
                                    current = current->getPrev();
                                    return *this;
                                }
                                iterator operator-- (int) {
                                    iterator clone(*this);
                                    current = current->getPrev();
                                    return clone;
                                }
                        };

                        // forward iteration
                        iterator begin() {
                            return iterator(start);
                        }

                        iterator end() {
                            return iterator(last);
                        }

                        // reverse iteration
                        iterator rbegin() {
                            return iterator(last);
                        }
                        iterator rend() {
                            return iterator(start);
                        }
                };

                class CircDLelement_constlisthelper {
                        typename bridges::datastructure::CircDLelement<E> const *start;

                    public:
                        CircDLelement_constlisthelper (typename bridges::datastructure::CircDLelement< E > const * s) : start(s) {
                        }
                        class iterator {

                                typename bridges::datastructure::CircDLelement< E > const  * current;
                            public:
                                iterator(    typename bridges::datastructure::CircDLelement< E > const   * c )
                                    : current(c)
                                {}

                                bool operator!=(const iterator& it) const {
                                    return this->current != it.current;
                                }

                                E const &  operator*() const {
                                    return current->getValue();
                                }

                                iterator& operator++() {
                                    current = current->getNext();
                                    return *this;
                                }
                                iterator& operator-- () {
                                    current = current->getPrev();
                                    return *this;
                                }
                                iterator operator-- (int) {
                                    iterator clone(*this);
                                    current = current->getPrev();
                                    return clone;
                                }
                        };

                        // forward iteration
                        iterator begin() {
                            return iterator(start);
                        }
                        iterator end() {
                            return iterator(start);
                        }
                        // reverse iteration
                        iterator rbegin() {
                            return iterator(start->getPrev());
                        }
                        iterator rend() {
                            return iterator(start->getPrev());
                        }
                };
        }; // end CircDLelement
        template <class E>
        using CircDLelement_List = typename CircDLelement<E>::CircDLelement_listhelper;
        template <class E>
        using CircDLelement_ConstList = typename CircDLelement<E>::CircDLelement_constlisthelper;

    }
} //namespace bridges
#endif