iter.h

Go to the documentation of this file.

// Evo C++ Library
/* Copyright 2019 Justin Crowell
Distributed under the BSD 2-Clause License -- see included file LICENSE.txt for details.
*/

#pragma once
#ifndef INCL_evo_impl_iter_h
#define INCL_evo_impl_iter_h

#include "../type.h"

namespace evo {


enum IteratorPos {
    iterFIRST,          
    iterLAST,           
    iterEND             
};

enum IteratorDir {
    iterNONE,           
    iterFW,             
    iterRV              
};


template<class T>
class IteratorBase : public SafeBool< IteratorBase<T> > {
public:
    typedef typename T::Size    Size;               
    typedef typename T::IterKey Key;                
    typedef typename StaticIf< IsConst<T>::value,
        const typename T::IterItem,
        typename T::IterItem
    >::Type                     Item;               

    typedef IteratorBase<T> IterBaseType;           

    typedef IteratorBase<const T>                                    Const;         
    typedef IteratorBase<typename RemoveConst<T>::Type>              Mutable;       
    typedef typename StaticIf<IsConst<T>::value,Mutable,Const>::Type ToggleConst;   

    typedef T Target;                               

    explicit IteratorBase(T& obj) : obj_(&obj), end_(true), data_(NULL)
        { init(); }

    IteratorBase(T& obj, const Key& key, Item* data) : obj_(&obj), end_(false), key_(key), data_(data)
        { init(); }

    IteratorBase(const IterBaseType& src)
        { memcpy(this, &src, sizeof(src)); init(); }

    IterBaseType& operator=(const IterBaseType& src)
        { memcpy(this, &src, sizeof(src)); init(); return *this; }

    IterBaseType& operator=(const ToggleConst& src) {
        STATIC_ASSERT(IsConst<T>::value, ERROR_cannot_assign_const_iterator_to_mutable_iterator);
        operator=((IterBaseType&)src);
        return *this;
    }

    IterBaseType& operator=(T& obj)
        { obj_ = &obj; end_ = true; data_ = NULL; return *this; }

    IterBaseType& operator=(IteratorPos pos) {
        EVO_PARAM_UNUSED(pos);
        end_ = true; data_ = NULL; return *this;
    }

    Item& operator*()
        { return *data_; }

    Item* operator->()
        { return data_; }

    bool operator!() const
        { return end_; }

    bool operator==(const IterBaseType& iter) const
        { return (this == &iter || (end_ == iter.end_ && data_ == iter.data_)); }

    bool operator!=(const IterBaseType& iter) const
        { return (this != &iter && (end_ != iter.end_ || data_ != iter.data_)); }

    template<typename T_>
    bool operator==(const IteratorBase<T_>& oth) const
        { return IterBaseType::operator==((const IterBaseType&)oth); }

    template<typename T_>
    bool operator!=(const IteratorBase<T_>& oth) const
        { return IterBaseType::operator!=((const IterBaseType&)oth); }

    T& getParent() const
        { return *obj_; }

    bool getEnd() const
        { return end_; }

    const Key& getKey() const
        { return key_; }

    Key& getKey()
        { return key_; }

    void set(const Key& key, const Item* data) {
        key_  = key;
        data_ = (Item*)data;
        end_  = (data_ == NULL);
    }

    void setData(const Item* item)
        { data_ = (Item*)item; }
    static const IterBaseType& end()
        { static const IterBaseType End; return End; }

protected:
    T*    obj_;             
    bool  end_;             
    Key   key_;             
    Item* data_;            

    explicit IteratorBase() : obj_(NULL), end_(true), data_(NULL)
        { }

    explicit IteratorBase(T* obj) : obj_(obj)
        { init(); }

private:
    void init() {
        if (obj_ != NULL && !IsConst<T>::value)
            // Only called with mutable iterator
            ((typename RemoveConst<T>::Type*)obj_)->iterInitMutable();
    }
};


template<class T>
class IteratorFw : public IteratorBase<T> {
protected:
    using IteratorBase<T>::obj_;
    using IteratorBase<T>::end_;
    using IteratorBase<T>::key_;
    using IteratorBase<T>::data_;

public:
    typedef typename IteratorBase<T>::Size Size;                                    
    typedef typename IteratorBase<T>::Key  Key;                                     
    typedef typename IteratorBase<T>::Item Item;                                    

    typedef IteratorFw<const T>                       Const;                        
    typedef IteratorFw<typename RemoveConst<T>::Type> Mutable;                      
    typedef IteratorFw<T>                             IterType;                     
    typedef IteratorBase<T>                           IterBaseType;                 

    typedef typename StaticIf<IsConst<T>::value,Mutable,Const>::Type ToggleConst;   

    IteratorFw() : IteratorBase<T>()
        { }

    explicit IteratorFw(T& obj) : IteratorBase<T>(obj)
        { first(); }

    explicit IteratorFw(T& obj, IteratorPos pos) : IteratorBase<T>(&obj) {
        switch (pos) {
            case iterFIRST: first(); break;
            default: end_ = true; data_ = NULL; break;
        };
    }

    IteratorFw(T& obj, const Key& key, Item* data) : IteratorBase<T>(obj, key, data)
        { }

    IteratorFw(const IterType& src) : IteratorBase<T>(src)
        { }

    IteratorFw(const IterBaseType& src) : IteratorBase<T>(src)
        { }

    IterType& operator=(const IterType& src)
        { IterBaseType::operator=(src); return *this; }

    IterType& operator=(const IterBaseType& src)
        { IterBaseType::operator=(src); return *this; }

    IterType& operator=(const ToggleConst& src) {
        STATIC_ASSERT(IsConst<T>::value, ERROR_cannot_assign_const_iterator_to_mutable_iterator);
        IterBaseType::operator=((IterType&)src);
        return *this;
    }

    IterType& operator=(const typename IterBaseType::ToggleConst& src) {
        STATIC_ASSERT(IsConst<T>::value, ERROR_cannot_assign_const_iterator_to_mutable_iterator);
        IterBaseType::operator=((IterType&)src);
        return *this;
    }

    IterType& operator=(T& obj)
        { IterBaseType::operator=(obj); first(); return *this; }

    IterType& operator=(IteratorPos pos) {
        switch (pos) {
            case iterFIRST: first(); break;
            default: end_ = true; data_ = NULL; break;
        };
        return *this;
    }

    IterType& operator++()
        { next(); return *this; }

    IterType operator++(int)
        { IterType tmp(*this); next(); return tmp; }

    // Inherited overloads
    using IteratorBase<T>::operator==;
    using IteratorBase<T>::operator!=;

protected:
    explicit IteratorFw(T* obj) : IteratorBase<T>(obj)
        { }

    bool first() {
        data_ = (Item*)obj_->iterFirst(key_);
        return end_ = (data_ == NULL);
    }

    bool next() {
        if (end_)
            return false;
        data_ = (Item*)obj_->iterNext(key_);
        if (data_ == NULL)
            end_ = true;
        return !end_;
    }
};


template<class T>
class IteratorBi : public IteratorFw<T> {
protected:
    using IteratorBase<T>::obj_;
    using IteratorBase<T>::end_;
    using IteratorBase<T>::key_;
    using IteratorBase<T>::data_;

    using IteratorFw<T>::first;

public:
    typedef typename IteratorBase<T>::Size Size;                                    
    typedef typename IteratorBase<T>::Key  Key;                                     
    typedef typename IteratorBase<T>::Item Item;                                    

    typedef IteratorBi<const T>                       Const;                        
    typedef IteratorBi<typename RemoveConst<T>::Type> Mutable;                      
    typedef IteratorBi<T>                             IterType;                     
    typedef IteratorBase<T>                           IterBaseType;                 

    typedef typename StaticIf<IsConst<T>::value,Mutable,Const>::Type ToggleConst;   

    IteratorBi() : IteratorFw<T>()
        { }

    explicit IteratorBi(T& obj) : IteratorFw<T>(obj)
        { }

    explicit IteratorBi(T& obj, IteratorPos pos) : IteratorFw<T>(&obj) {
        switch (pos) {
            case iterFIRST: first(); break;
            case iterLAST:  last();  break;
            default: end_ = true; data_ = NULL; break;
        };
    }

    IteratorBi(T& obj, const Key& key, Item* data) : IteratorFw<T>(obj, key, data)
        { }

    IteratorBi(const IterType& src) : IteratorFw<T>(src)
        { }

    IteratorBi(const IterBaseType& src) : IteratorFw<T>(src)
        { }

    IterType& operator=(const IterType& src)
        { IterBaseType::operator=(src); return *this; }

    IterType& operator=(const IterBaseType& src)
        { IterBaseType::operator=(src); return *this; }

    IterType& operator=(const ToggleConst& src) {
        STATIC_ASSERT(IsConst<T>::value, ERROR_cannot_assign_const_iterator_to_mutable_iterator);
        IterBaseType::operator=((IterType&)src);
        return *this;
    }

    IterType& operator=(const typename IterBaseType::ToggleConst& src) {
        STATIC_ASSERT(IsConst<T>::value, ERROR_cannot_assign_const_iterator_to_mutable_iterator);
        IterBaseType::operator=((IterType&)src);
        return *this;
    }

    IterType& operator=(T& obj)
        { IterBaseType::operator=(obj); first(); return *this; }

    IterType& operator=(IteratorPos pos) {
        switch (pos) {
            case iterFIRST: first(); break;
            case iterLAST:  last();  break;
            default: end_ = true; data_ = NULL; break;
        };
        return *this;
    }

    IterType& operator--()
        { prev(); return *this; }

    IterType operator--(int)
        { IterType tmp(*this); prev(); return tmp; }

    // Inherited overloads
    using IteratorFw<T>::operator==;
    using IteratorFw<T>::operator!=;

protected:
    explicit IteratorBi(T* obj) : IteratorFw<T>(obj)
        { }

    bool last() {
        data_ = (Item*)obj_->iterLast(key_);
        return end_ = (data_ == NULL);
    }

    bool prev() {
        if (end_)
            return false;
        data_ = (Item*)obj_->iterPrev(key_);
        if (data_ == NULL)
            end_ = true;
        return !end_;
    }
};


template<class T>
class IteratorRa : public IteratorBi<T> {
protected:
    using IteratorBase<T>::obj_;
    using IteratorBase<T>::end_;
    using IteratorBase<T>::key_;
    using IteratorBase<T>::data_;

    using IteratorFw<T>::first;

public:
    typedef typename IteratorBase<T>::Size Size;                                    
    typedef typename IteratorBase<T>::Key  Key;                                     
    typedef typename IteratorBase<T>::Item Item;                                    

    typedef IteratorRa<const T>                       Const;                        
    typedef IteratorRa<typename RemoveConst<T>::Type> Mutable;                      
    typedef IteratorRa<T>                             IterType;                     
    typedef IteratorBase<T>                           IterBaseType;                 

    typedef typename StaticIf<IsConst<T>::value,Mutable,Const>::Type ToggleConst;   

    IteratorRa() : IteratorBi<T>()
        { }

    explicit IteratorRa(T& obj) : IteratorBi<T>(obj)
        { }

    explicit IteratorRa(T& obj, IteratorPos pos) : IteratorBi<T>(obj, pos)
        { }

    IteratorRa(T& obj, Key num) : IteratorBi<T>(&obj) {
        data_ = (Item*)obj_->iterSet(num);
        end_ = (data_ == NULL);
        key_ = num;
    }

    IteratorRa(T& obj, const Key& key, Item* data) : IteratorBi<T>(obj, key, data)
        { }

    IteratorRa(const IterType& src) : IteratorBi<T>(src)
        { }

    IteratorRa(const IterBaseType& src) : IteratorBi<T>(src)
        { }

    IterType& operator=(const IterType& src)
        { IterBaseType::operator=(src); return *this; }

    IterType& operator=(const IterBaseType& src)
        { IterBaseType::operator=(src); return *this; }

    IterType& operator=(const ToggleConst& src) {
        STATIC_ASSERT(IsConst<T>::value, ERROR_cannot_assign_const_iterator_to_mutable_iterator);
        IterBaseType::operator=((IterType&)src);
        return *this;
    }

    IterType& operator=(const typename IterBaseType::ToggleConst& src) {
        STATIC_ASSERT(IsConst<T>::value, ERROR_cannot_assign_const_iterator_to_mutable_iterator);
        IterBaseType::operator=((IterType&)src);
        return *this;
    }

    IterType& operator=(T& obj)
        { IterBaseType::operator=(obj); first(); return *this; }

    IterType& operator=(IteratorPos pos)
        { IteratorBi<T>::operator=(pos); return *this; }

    IterType& operator=(Key num) {
        data_ = (Item*)obj_->iterSet(num);
        end_ = (data_ == NULL);
        key_ = num;
        return *this;
    }

    IterType& operator+=(Size count)
        { next(count); return *this; }

    IterType& operator-=(Size count)
        { prev(count); return *this; }

    IterType operator+(Size count) const
        { IterType tmp(*this); tmp.next(count); return tmp; }

    IterType operator-(Size count) const
        { IterType tmp(*this); tmp.prev(count); return tmp; }

    int compare(const IterBaseType& iter) const {
        if (iter.getEnd())
            return (end_ ? 0 : -1);
        else if (end_)
            return 1;
        else if (key_ == iter.getKey())
            return 0;
        else
            return (key_ < iter.getKey() ? -1 : 1);
    }

    int compare(Key num) const {
        if (num == END)
            return (end_ ? 0 : -1);
        else if (end_)
            return 1;
        else if (key_ == num)
            return 0;
        else
            return (key_ < num ? -1 : 1);
    }

    bool operator<(const IterBaseType& iter) const
        { return (compare(iter) < 0); }

    bool operator<(Key num) const
        { return (compare(num) < 0); }

    bool operator<=(const IterBaseType& iter) const
        { return (compare(iter) <= 0); }

    bool operator<=(Key num) const
        { return (compare(num) <= 0); }

    bool operator>(const IterBaseType& iter) const
        { return (compare(iter) > 0); }

    bool operator>(Key num) const
        { return (compare(num) > 0); }

    bool operator>=(const IterBaseType& iter) const
        { return (compare(iter) >= 0); }

    bool operator>=(Key num) const
        { return (compare(num) >= 0); }

    // Inherited overloads
    using IteratorBi<T>::operator==;
    using IteratorBi<T>::operator!=;

    bool operator==(Key num) const
        { return (compare(num) == 0); }

    bool operator!=(Key num) const
        { return (compare(num) != 0); }

    Size count() const
        { return obj_->iterCount(); }

    Key index() const
        { return (end_ ? Key(END) : key_); }

protected:
    bool next(Size count) {
        if (end_)
            return false;
        data_ = (Item*)obj_->iterNext(count, key_);
        if (data_ == NULL)
            end_ = true;
        return !end_;
    }

    bool prev(Size count) {
        if (end_)
            return false;
        data_ = (Item*)obj_->iterPrev(count, key_);
        if (data_ == NULL)
            end_ = true;
        return !end_;
    }
};


template<class T, int F, int L>
class EnumIterator : public SafeBool< EnumIterator<T,F,L> > {
public:
    typedef EnumIterator<T,F,L> This;
    typedef T EnumType;
    static const T FIRST = (T)F;
    static const T LAST = (T)L;

    EnumIterator() : value_(FIRST), end_(false) {
    }

    EnumIterator(const This& src) : value_(src.value_), end_(src.end_) {
    }

    EnumIterator(EnumType value) : value_(value), end_(false) {
    }

    EnumIterator(IteratorPos pos) {
        setpos(pos);
    }

    This& operator=(const This& src) {
        value_ = src.value_;
        end_ = src.end_;
        return *this;
    }

    This& operator=(EnumType value) {
        value_ = value;
        end_ = false;
        return *this;
    }

    This& operator=(IteratorPos pos) {
        setpos(pos);
        return *this;
    }

    bool operator!() const
        { return end_; }

    EnumType operator*() const
        { return value_; }

    bool operator==(const This& oth) const
        { return (end_ == oth.end_ && value_ == oth.value_); }

    bool operator!=(const This& oth) const
        { return (end_ != oth.end_ || value_ != oth.value_); }

    This& operator++() {
        next();
        return *this;
    }

    This operator++(int) {
        This result(*this);
        next();
        return result;
    }

    This& operator--() {
        prev();
        return *this;
    }

    This operator--(int) {
        This result(*this);
        prev();
        return result;
    }

    EnumType value() const
        { return value_; }

    int value_num(int endvalue=0) const {
        if (end_)
            return endvalue;
        return (int)value_;
    }

protected:
    EnumType value_;
    bool end_;

    void setpos(IteratorPos pos) {
        switch (pos) {
            case iterFIRST:
                value_ = FIRST;
                end_ = false;
                break;
            case iterLAST:
                value_ = LAST;
                end_ = false;
                break;
            default:
                value_ = LAST;
                end_ = true;
                break;
        }
    }

    void prev() {
        if (!end_) {
            if (value_ <= FIRST)
                end_ = true;
            else
                value_ = (EnumType)((int)value_ - 1);
        }
    }

    void next() {
        if (!end_) {
            if (value_ >= LAST)
                end_ = true;
            else
                value_ = (EnumType)((int)value_ + 1);
        }
    }
};


}
#endif