tnchain.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "core/builtin/container/native/tnmap.hpp"
 
namespace by {
 
    class node;
 
    template <typename K, typename V, typename _defaultContainer = tnmap<K, V>>
    class tnchain: public tnbicontainer<K, V> {
        typedef tnbicontainer<K, V> _super_;
        typedef tnchain<K, V, _defaultContainer> _me_;
        BY(CLASS(_me_, _super_))
 
    public:
        typedef typename super::iter iter;
        typedef typename super::iteration iteration;
        friend class nchainIteration;
        typedef _defaultContainer defaultContainer;
#include "core/builtin/container/iter/nchainIteration.hpp"
 
    public:
        tnchain();
        explicit tnchain(const super& arr);
        explicit tnchain(const super& org, const me& next);
        explicit tnchain(std::initializer_list<std::pair<K, V*>> elems);
 
    public:
        // has:
        using super::in;
        nbool in(const K& key) const override;
 
        // len:
        ncnt len() const override;
        ncnt chainLen() const;
 
        using super::get;
        V* get(const K& key) override;
 
        // add:
        using super::add;
        nbool add(const K& key, const V& val) override;
 
        virtual nbool link(const iter& portion);
        nbool link(const me& new1);
        nbool link(const me* it) BY_SIDE_FUNC(link);
        nbool unlink();
 
        // del:
        using super::del;
        nbool del(const K& key) override;
        nbool del(const iter& at) override;
        nbool del(const iter& from, const iter& end) override;
 
        // etc:
        void rel() override;
 
        super& getContainer();
        const super& getContainer() const;
 
        me* getNext();
        const me* getNext() const BY_CONST_FUNC(getNext())
 
        me* getPrev();
        const me* getPrev() const BY_CONST_FUNC(getPrev())
 
        me* getTail();
        const me* getTail() const BY_CONST_FUNC(getTail())
 
        void onCloneDeep(const clonable& from) override;
 
        template <typename T> static T* wrap(const super& toShallowWrap) {
            T* ret = (T*) toShallowWrap.template cast<T>();
            if(!ret) {
                ret = new T();
                ret->_map.bind(toShallowWrap);
            }
 
            return ret;
        }
 
        template <typename T> static T* wrap(const super* it) BY_SIDE_FUNC(it, wrap<T>(*it), nullptr);
 
        static me* wrap(const super& toShallowWrap);
        static me* wrap(const super* it) BY_SIDE_FUNC(wrap);
 
        me* cloneChain(const super* until) const;
        me* cloneChain(const me* until) const;
 
        me* cloneChain() const;
 
    protected:
        iteration* _onMakeIteration(const K* key, nbool isReversed, ncnt step, nbool isBoundary) const override;
 
        void _getAll(const K& key, narr& tray) const override;
 
    private:
        iter* _getInnerIter(const iter& wrapper);
        iter _getInnerBeginOfChain(me& it, const me& fromChain, const iter& from);
        iter _getInnerEndOfChain(me& it, const me& lastChain, const iter& last);
        iter _rendOfThisChain(nbool isReversed);
        me& _getLastChain();
        void _eachChain(std::function<void(me&)> closure);
 
    private:
        tstr<super> _map;
        iter _next;
        iter _prev;
    };
 
    extern template class tnchain<std::string, node, tnmap<std::string, node, strTactic>>;
    typedef tnchain<std::string, node, tnmap<std::string, node, strTactic>> nchain;
} // namespace by