Array1D.h

Go to the documentation of this file.

#ifndef ARRAY_1D_H
#define ARRAY_1D_H
 
#include "Array.h"
#include "Element.h"
 
namespace bridges {
    namespace datastructure {
        template <typename E>
        class Array1D : public Array<E> {
 
            private:
                int size;
 
                Array1D() {}
 
            public:
                virtual ~Array1D() {}
 
                Array1D(int sz) {
                    int dim[] = {sz, 1, 1};
                    this->setSize(1, dim);
                }
 
                E & operator[](int indx) {
                    return  Array<E>::getElement(indx).getValue();
                }
 
                E const & operator[](int indx) const {
                    return  Array<E>::getElement(indx).getValue();
                }
 
                Element<E>& getElement(int indx) {
                    return  Array<E>::getElement(indx);
                }
 
                Element<E> const & getElement(int indx) const {
                    return  Array<E>::getElement(indx);
                }
 
                void setElement(int indx, const Element<E>& e ) {
                    return  Array<E>::setElement(indx, e);
                }
 
                class iterator {
                        Array1D<E>& arr;
                        int index;
                    public:
                        iterator (Array1D<E>& a, int ind) : arr(a), index(ind) {}
                        E const & operator* () const {
                            return arr[index];
                        }
                        E & operator* () {
                            return arr[index];
                        }
                        iterator& operator++ () {
                            ++index;
                            return *this;
                        }
                        iterator& operator-- () {
                            --index;
                            return *this;
                        }
                        iterator& operator++ (int) {
                            ++index;
                            return *this;
                        }
                        iterator& operator-- (int) {
                            --index;
                            return *this;
                        }
                        bool operator == (const iterator& it) const {
                            return (&arr) == &(it.arr)
                                && index == it.index;
                        }
                        bool operator != (const iterator& it) const {
                            return !(operator==(it));
                        }
                };
 
                iterator begin() {
                    return iterator(*this, 0);
                }
                iterator end() {
                    return iterator(*this, Array<E>::getDimensions()[0]);
                }
 
                class const_iterator {
                        Array1D<E> const & arr;
                        int index;
                    public:
                        const_iterator (Array1D<E> const& a, int ind) : arr(a), index(ind) {}
                        E const & operator* () const {
                            return arr[index];
                        }
                        const_iterator& operator++ () {
                            ++index;
                            return *this;
                        }
                        const_iterator& operator-- () {
                            --index;
                            return *this;
                        }
                        const_iterator& operator++ (int) {
                            ++index;
                            return *this;
                        }
                        const_iterator& operator-- (int) {
                            --index;
                            return *this;
                        }
                        bool operator == (const const_iterator& it) const {
                            return (&arr) == &(it.arr)
                                && index == it.index;
                        }
                        bool operator != (const const_iterator& it) const {
                            return !(operator==(it));
                        }
                };
 
                const_iterator begin() const {
                    return const_iterator(*this, 0);
                }
                const_iterator end() const {
                    return iterator(*this, Array<E>::getDimensions()[0]);
                }
 
        }; // Array1D
        // use some aliases for accessing iterators
        template <class E>
        using Array1DIterator = typename Array1D<E>::iterator;
    }
}// end namespace bridges
 
#endif