CircSLelement.h

Go to the documentation of this file.

#ifndef  CIRC_SL_ELEMENT_H
 
#define CIRC_SL_ELEMENT_H
#include "SLelement.h"
 
namespace bridges {
    namespace datastructure {
        template <typename E>
        class CircSLelement : public SLelement<E> {
 
            public:
                CircSLelement() : SLelement<E> (this) {
                }
                CircSLelement (E val = E(), string label = string())
                    : SLelement<E> (this, val, label) {
                }
 
                CircSLelement (E e = E(), CircSLelement *next = nullptr)
                    : SLelement<E> (next, e) {
                }
 
                CircSLelement (CircSLelement *next) : SLelement<E> (next) {
                }
 
                virtual const string getDStype() const override {
                    return "CircularSinglyLinkedList";
                }
 
                virtual CircSLelement<E> *getNext() override {
                    return static_cast<CircSLelement*> (SLelement<E>::getNext());
                }
 
                void setNext(CircSLelement<E> *next) {
                    SLelement<E>::setNext(next);
                }
 
            public:
                class CircSLelement_listhelper {
                        typename bridges::datastructure::CircSLelement<E> *start,
                                 *last;
 
                    public:
                        CircSLelement_listhelper (typename bridges::datastructure::CircSLelement< E > * s) : start(s), last (s) {}
 
                        class iterator {
                                typename bridges::datastructure::CircSLelement<E> *current;
                            public:
                                iterator(typename bridges::datastructure::CircSLelement<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 begin() {
                            return iterator(start);
                        }
 
                        iterator end() {
                            return iterator(last);
                        }
                };
 
                class CircSLelement_constlisthelper {
                        typename bridges::datastructure::CircSLelement<E> const * start, *last;
 
                    public:
                        CircSLelement_constlisthelper (typename bridges::datastructure::CircSLelement< E > const * s)
                            : start(s), last(s)
                        {}
 
                        class iterator {
 
                                typename bridges::datastructure::CircSLelement< E > const  * current;
                            public:
                                iterator(    typename bridges::datastructure::CircSLelement< 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 begin() {
                            return iterator(start);
                        }
 
                        iterator end() {
                            return iterator(last);
                        }
                };
 
        }; // end CircSLelement
        template <class E>
        using CircSLelement_List = typename CircSLelement<E>::CircSLelement_listhelper;
        template <class E>
        using CircSLelement_ConstList = typename CircSLelement<E>::CircSLelement_constlisthelper;
 
    }
} // namespace bridges
#endif