Iterator.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <stdexcept>
#include <iterator>
#include <iostream>
 
 
namespace Gorgon {
    namespace Containers {
 
        template <class I_, class T_, class D_=long>
        class Iterator : public std::iterator<std::random_access_iterator_tag, T_, D_> {
        private:
            I_ &iterator() { return *static_cast<I_*>(this); }
            const I_ &iterator() const { return *static_cast<const I_*>(this); }
 
        protected:
            Iterator() { }
 
        public:
 
            T_ &Current() const {
                return iterator().current();
            }
 
            T_ *CurrentPtr() const {
                return &iterator().current();
            }
 
            bool MoveBy(int amount) {
                return iterator().moveby(amount);
            }
 
            bool Next() {
                return iterator().moveby(1);
            }
 
            bool Previous() {
                return iterator().moveby(-1);
            }
 
            bool IsValid() const {
                return iterator().isvalid();
            }
 
            explicit operator bool() const {
                return IsValid();
            }
 
            T_ &operator [](D_ ind) const {
                return *this+ind;
            }
 
            bool Compare(const I_ &iterator) const {
                return this->iterator().compare(iterator);
            }
 
            D_ Distance(const I_ &iterator) const {
                return this->iterator().distance(iterator);
            }
 
            bool operator ==(const I_ &iterator) const {
                return this->iterator().compare(iterator);
            }
 
            bool operator >(const I_ &iterator) const {
                return !(this->iterator() <= iterator);
            }
 
            bool operator <(const I_ &iterator) const {
                return this->iterator().isbefore(iterator);
            }
 
            bool operator >=(const I_ &iterator) const {
                return !(this->iterator() < iterator);
            }
 
            bool operator <=(const I_ &iterator) const {
                return this->iterator().isbefore(iterator) || this->iterator().compare(iterator);
            }
 
            bool operator !=(const I_ &it) const {
                return !iterator().compare(it);
            }
 
            I_ &operator =(const I_ &iterator) {
                this->iterator().set(iterator);
 
                return this->iterator();
            }
 
            D_ operator -(const I_ &iterator) const {
                return iterator.distance(this->iterator());
            }
 
            I_ operator +(D_ offset) const {
                I_ i(iterator());
                i.MoveBy(offset);
 
                return i;
            }
 
            I_ operator -(D_ offset) const {
                I_ i(iterator());
                i.MoveBy(-offset);
 
                return i;
            }
 
            I_ &operator +=(D_ offset) {
                iterator().moveby(offset);
 
                return iterator();
            }
 
            I_ &operator -=(D_ offset) {
                iterator().moveby(-offset);
 
                return iterator();
            }
 
            I_ &operator ++() {
                iterator().moveby(1);
 
                return iterator();
            }
 
            I_ &operator --() {
                iterator().moveby(-1);
 
                return iterator();
            }
 
            I_ operator ++(int) {
                I_ it=iterator();
                iterator().moveby(1);
 
                return it;
            }
 
            I_ operator --(int) {
                I_ it=iterator();
                iterator().moveby(-1);
 
                return it;
            }
 
            T_ &operator *() const {
                return iterator().current();
            }
 
            T_ *operator ->() const {
                return &iterator().current();
            }
        };
        
        template <class I_, class T_, class D_=long>
        class ValueIterator : std::iterator<std::random_access_iterator_tag, T_, D_> {
        private:
            I_ &iterator() { return *static_cast<I_*>(this); }
            const I_ &iterator() const { return *static_cast<const I_*>(this); }
            
        protected:
            ValueIterator() { }
            
        public:
            
            T_ Current() const {
                return iterator().current();
            }
            
            
            bool MoveBy(int amount) {
                return iterator().moveby(amount);
            }
            
            bool Next() {
                return iterator().moveby(1);
            }
            
            bool Previous() {
                return iterator().moveby(-1);
            }
            
            bool IsValid() const {
                return iterator().isvalid();
            }
            
            explicit operator bool() const {
                return IsValid();
            }
            
            T_ operator [](D_ ind) const {
                return *this+ind;
            }
            
            bool Compare(const I_ &iterator) const {
                return this->iterator().compare(iterator);
            }
            
            D_ Distance(const I_ &iterator) const {
                return this->iterator().distance(iterator);
            }
            
            bool operator ==(const I_ &iterator) const {
                return this->iterator().compare(iterator);
            }
            
            bool operator >(const I_ &iterator) const {
                return !(this->iterator() <= iterator);
            }
            
            bool operator <(const I_ &iterator) const {
                return this->iterator().isbefore(iterator);
            }
            
            bool operator >=(const I_ &iterator) const {
                return !(this->iterator() < iterator);
            }
            
            bool operator <=(const I_ &iterator) const {
                return this->iterator().isbefore(iterator) || this->iterator().compare(iterator);
            }
            
            bool operator !=(const I_ &it) const {
                return !iterator().compare(it);
            }
            
            I_ &operator =(const I_ &iterator) {
                this->iterator().set(iterator);
                
                return this->iterator();
            }
            
            D_ operator -(const I_ &iterator) const {
                return iterator.distance(this->iterator());
            }
            
            I_ operator +(D_ offset) const {
                I_ i(iterator());
                i.MoveBy(offset);
                
                return i;
            }
            
            I_ operator -(D_ offset) const {
                I_ i(iterator());
                i.MoveBy(-offset);
                
                return i;
            }
            
            I_ &operator +=(D_ offset) {
                iterator().moveby(offset);
                
                return iterator();
            }
            
            I_ &operator -=(D_ offset) {
                iterator().moveby(-offset);
                
                return iterator();
            }
            
            I_ &operator ++() {
                iterator().moveby(1);
                
                return iterator();
            }
            
            I_ &operator --() {
                iterator().moveby(-1);
                
                return iterator();
            }
            
            I_ operator ++(int) {
                I_ it=iterator();
                iterator().moveby(1);
                
                return it;
            }
            
            I_ operator --(int) {
                I_ it=iterator();
                iterator().moveby(-1);
                
                return it;
            }
            
            T_ operator *() const {
                return iterator().current();
            }
        };
        
        template<class I_>
        void Remove(const I_ &first, const I_ &end) {
            for(I_ i=first; i!=end; ++i) {
                i.Remove();
            }
        }
 
        template<class I_>
        void Delete(const I_ &first, const I_ &end) {
            for(I_ i=first; i!=end; ++i) {
                i.Delete();
            }
        }
 
 
        template<class I_, class T_>
        I_ Find(const I_ &first, const I_ &end, const T_ &item) {
            for(I_ i=first; i!=end; ++i) {
                if(*i==item)
                    return i;
            }
 
            return I_();
        }
 
        template<class C_, class I_>
        void AddCopy(C_ &target, const I_ &it) {
            for(I_ i=it; i.IsValid(); i.Next()) {
                target.Add(*i);
            }
        }
 
        template<class C_, class I_>
        void AddCopy(C_ &target, const I_ &begin, const I_ &end) {
            for(I_ i=begin; i!=end; ++i) {
                target.Add(*i);
            }
        }
 
        template<class T_, class I_, class A_>
        void AddCopy(std::vector<T_, A_> &target, const I_ &it) {
            for(I_ i=it; i.IsValid(); i.Next()) {
                target.push_back(*i);
            }
        }
 
        template<class T_, class I_, class A_>
        void AddCopy(std::vector<T_, A_> &target, const I_ &begin, const I_ &end) {
            for(I_ i=begin; i!=end; i++) {
                target.push_back(*i);
            }
        }
 
    }
}
 
//forbidden juju
namespace std {
 
    template<class T_>
    std::ostream &operator <<(std::ostream &out, const std::vector<T_> &vec) {
        for(auto &e : vec) {
            out<<e<<std::endl;
        }
 
        return out;
    }
 
}