nchainIteration.hpp

Go to the documentation of this file.

 
class nchainIteration: public iteration {
    BY(CLASS(nchainIteration, iteration))
    friend class tnchain;
 
public:
    nchainIteration(tnchain* iteratingChain, const K* key, nbool isReversed):
        me(iteratingChain, key, isReversed, false, true) {}
 
    nchainIteration(tnchain* iteratingChain, const K* key, nbool isReversed, nbool isBoundary, nbool isAutoAdvance):
        super(isReversed),
        _chainIter(iteratingChain),
        _key(key ? *key : _getDummyKey()),
        _isDummyKey(!key),
        _iter(_makeContainerIter(false)),
        _isBoundary(isBoundary) {
        if(isAutoAdvance && !_iter) {
            next(1);
            _setBoundary(isBoundary);
        }
    }
 
    nbool isEnd() const override {
        WHEN(_getNextContainer()) .ret(false);
        return !_iter;
    }
 
    void rel() override {
        _iter.rel();
        _chainIter.rel();
    }
 
    nbool isBoundary() const { return _isBoundary; }
 
    ncnt next(ncnt step) override { return _step(super::NEXT, step); }
 
    ncnt prev(ncnt step) override { return _step(super::PREV, step); }
 
    ncnt stepForward(ncnt step) override { return _step(super::FORWARD, step); }
 
    ncnt stepBackward(ncnt step) override { return _step(super::BACKWARD, step); }
 
    using super::getContainer;
 
    tbicontainable<K, V>* getContainer() override {
        WHEN(!_chainIter) .ret(nullptr);
        return _chainIter.get();
    }
 
    const K* getKey() const override { return _iter.getKey(); }
 
    using super::getVal;
 
    V* getVal() override { return _iter.getVal(); }
 
    using super::setVal;
 
    void setVal(const V& new1) override { _iter.setVal(new1); }
 
protected:
    nbool _onSame(const typeProvidable& rhs) const override {
        const me& cast = (const me&) rhs;
        return (isEnd() && cast.isEnd()) || _iter == cast._iter;
    }
 
private:
    ncnt _step(typename super::iterationType type, ncnt step) {
        ncnt remain = step;
 
        // if _chainIter was invalidated then _iter too.
        while(remain > 0) {
            if(!_isSubIterEndAtMiddle()) remain -= _iterate(type, remain);
            if(remain <= 0) break;
 
            // _iter moved to 'End' state now.
            if(isEnd()) break;
            _updateIter();
            if(_iter) remain--;
        }
 
        return step - remain;
    }
 
    ncnt _iterate(typename super::iterationType type, ncnt step) {
        _isBoundary = false;
        switch(type) {
            case super::FORWARD: return _iter.stepForward(step);
            case super::BACKWARD: return _iter.stepBackward(step);
            case super::PREV: return _iter.prev(step);
            default:
            case super::NEXT: return _iter.next(step);
        }
    }
 
    const iter* _getNextIter() const {
        WHEN(!_chainIter) .ret(nullptr);
        return this->isReversed() ? &_chainIter->_prev : &_chainIter->_next;
    }
 
    const tnchain* _getNextContainer() const {
        WHEN(!_chainIter) .ret(nullptr);
        return this->isReversed() ? _chainIter->getPrev() : _chainIter->getNext();
    }
 
    void _updateIter() {
        const iter& nextIter = _getNextIter() OR_DO {
            _chainIter.rel();
            _iter.rel();
            return;
        };
 
        // proceed to next chain:
        _chainIter.bind(_castChain(nextIter));
        // init container iter:
        me& nextIteration = _castIteration(nextIter) OR.ret();
        _iter = nextIteration._isBoundary ? _makeContainerIter(nextIteration.isReversed()) : nextIteration._iter;
        if(!_isDummyKey && (!_iter.getKey() || _key != *_iter.getKey())) _iter.next(1);
    }
 
    iter _makeContainerIter(nbool isReversed) const {
        return isReversed ? (this->isReversed() ? _chainIter->_map->begin(_getFindingKey()) :
                                                  _chainIter->_map->rbegin(_getFindingKey())) :
                            (this->isReversed() ? _chainIter->_map->rbegin(_getFindingKey()) :
                                                  _chainIter->_map->begin(_getFindingKey()));
    }
 
    void _setBoundary(nbool new1) { _isBoundary = new1; }
 
    me* _castIteration(const iter& e) { return (me*) (e._iteration.get()); }
    const me* _castIteration(const iter& e) const BY_CONST_FUNC(_castIteration(e))
 
    tnchain* _castChain(const iter& e) { return (tnchain*) e.getContainer(); }
 
    tnchain* _castChain(const iter* it) BY_SIDE_FUNC(_castChain);
 
    const tnchain* _castChain(const iter& e) const BY_CONST_FUNC(_castChain(e));
    const tnchain* _castChain(const iter* e) const BY_CONST_FUNC(_castChain(e));
 
    // check whether sub iter has been reached to reversed non-boundary end iter.
    // e.g.
    //  chain A has {1, 2, 3} elements.
    //  chain B has {4, 5, 6} elements.
    //  when A linked B from the 2nd element, chains will be follow:
    //      {1, 2, 3, 5, 6}
    //  in this case, what if user wants to iterate in reversed?
    //  then elements to be out should be:
    //      {6, 5, 3, 2, 1}
    //  our sub iterate can detect end of the sub container inside of its logic when
    //  you call `next()` in `_iterate()`.
    //  however, in above example, after sub iter reached to `5`, it's not possible for it
    //  to detect the end of iteration of the sub container. because actually there is one
    //  more element to iterate, `4`.
    //  so only who is capable of knowing that reversed iteration reached to the end for
    //  reversed iterator is need to be done by `nchainIteration` class.
    //  and this func is for that.
    nbool _isSubIterEndAtMiddle()
        const { // if this iter is not reversed, there is no case you have the `end at middle`.
        WHEN(!this->isReversed()) .ret(false);
 
        // if there is no prev chain, I'll just regard it as `end()` soon.
        const tnchain& prev = _castChain(_getNextIter()) OR.ret(false);
        const me& prevNext = _castIteration(prev._next) OR.ret(false);
        WHEN(prevNext.isBoundary()) .ret(false);
        return _iter == prevNext._iter;
    }
 
    static const K& _getDummyKey() {
        static K inner;
        return inner;
    }
 
    const K* _getFindingKey() const { return _isDummyKey ? nullptr : &_key; }
 
private:
    tstr<tnchain> _chainIter;
    K _key;
    nbool _isDummyKey;
    iter _iter;
 
    nbool _isBoundary;
};