// is editing


#ifndef __ZCPPMAIN__ZTCLINKLIST_H__
#define __ZCPPMAIN__ZTCLINKLIST_H__


#include "ZCppMain/ZMainHead.H"


namespace ZNsMain
{

    template
        <typename TCLink, typename TTypSize>
    class ZtCLinkList;


    template
        <typename TTypBase, typename TChild>
    class ZtCLink : public TTypBase
    {
    public   :
        template
            <typename TCLink, typename TTypSize>
        friend class ZtCLinkList;
    public   :
        typedef ZtCLink  TypeThis ;
        typedef TTypBase TypeBase ;
        typedef TChild   TypeChild;
    protected:
        ZtCLink* mp_NextLink;
        ZtCLink* mp_PrevLink;
    protected:

        void JoinLink(ZtCLink* AP_PrevLink, ZtCLink* AP_NextLink)
        {
            AP_PrevLink->mp_NextLink=AP_NextLink;
            AP_NextLink->mp_PrevLink=AP_PrevLink;
        }/*
        void JoinLink(ZtCLink* AP_PrevLink, ZtCLink* AP_NextLink)*/

        void MakeRing(ZtCLink* AP_HeadLink, ZtCLink* AP_TailLink)
        {
            AP_HeadLink->mp_PrevLink=AP_TailLink;
            AP_TailLink->mp_NextLink=AP_HeadLink;
        }/*
        void MakeRing(ZtCLink* AP_HeadLink, ZtCLink* AP_TailLink)*/

  /*protected:*/
    public   :

        ZtCLink()
        {
            mp_NextLink=0;
            mp_PrevLink=0;
        }/*
        ZtCLink()*/

        ZtCLink(const ZtCLink& rhs)
        {
            mp_NextLink=0;
            mp_PrevLink=0;

            *(TypeBase*)(this) = rhs ;
        }/*
        ZtCLink(const ZtCLink& rhs)*/

        ZtCLink& operator=(const ZtCLink& rhs)
        {
            static_cast<TypeBase&>(*this) =
            static_cast<TypeBase&>( rhs ) ;

            return *this;
        }/*
        ZtCLink& operator=(const ZtCLink& rhs)*/


        ZtCLink* GetNextPtr(){return mp_NextLink;}
        ZtCLink* GetPrevPtr(){return mp_PrevLink;}

        const ZtCLink* GetNextPtr() const{return mp_NextLink;}
        const ZtCLink* GetPrevPtr() const{return mp_PrevLink;}


        ZtCLink* GetNextPtr(TypeSize AL_Distance)
        {
            TypeSize VL_LoopIndex=0   ;
            ZtCLink* VP_TmpLink  =this;

            while(VL_LoopIndex++ < AL_Distance)
                VP_TmpLink = VP_TmpLink->mp_NextLink ;

            return VP_TmpLink;
        }/*
        ZtCLink* GetNextPtr(TypeSize AL_Distance)*/

        ZtCLink* GetPrevPtr(TypeSize AL_Distance)
        {
            TypeSize VL_LoopIndex=0   ;
            ZtCLink* VP_TmpLink  =this;

            while(VL_LoopIndex++ < AL_Distance)
                VP_TmpLink = VP_TmpLink->mp_PrevLink ;

            return VP_TmpLink;
        }/*
        ZtCLink* GetPrevPtr(TypeSize AL_Distance)*/


        const ZtCLink* GetNextPtr(TypeSize AL_Distance) const
        {
            TypeSize VL_LoopIndex=0 ;
            ZtCLink* VP_TmpLink  =const_cast<ZtCLink*>(this);

            while(VL_LoopIndex++ < AL_Distance)
                VP_TmpLink = VP_TmpLink->mp_NextLink ;

            return VP_TmpLink;
        }/*
        const ZtCLink* GetNextPtr(TypeSize AL_Distance) const*/

        const ZtCLink* GetPrevPtr(TypeSize AL_Distance) const
        {
            TypeSize VL_LoopIndex=0 ;
            ZtCLink* VP_TmpLink  = const_cast<ZtCLink*>(this) ;

            while(VL_LoopIndex++ < AL_Distance)
                VP_TmpLink = VP_TmpLink->mp_PrevLink ;

            return VP_TmpLink;
        }/*
        const ZtCLink* GetPrevPtr(TypeSize AL_Distance) const*/


        ZtCLink& operator+(TypeSize AL_Distance)
        {
            if(AL_Distance>=0)
                  return *GetNextPtr(AL_Distance);
            else  return *GetPrevPtr(AL_Distance);
        }/*
        ZtCLink& operator+(TypeSize AL_Distance)*/

        ZtCLink& operator-(TypeSize AL_Distance)
        {
            if(AL_Distance>=0)
                  return *GetPrevPtr(AL_Distance);
            else  return *GetNextPtr(AL_Distance);
        }/*
        ZtCLink& operator-(TypeSize AL_Distance)*/


        const ZtCLink& operator+(TypeSize AL_Distance) const
        {
            if(AL_Distance>=0)
                  return *GetNextPtr(AL_Distance);
            else  return *GetPrevPtr(AL_Distance);
        }/*
        const ZtCLink& operator+(TypeSize AL_Distance) const*/

        const ZtCLink& operator-(TypeSize AL_Distance) const
        {
            if(AL_Distance>=0)
                  return *GetPrevPtr(AL_Distance);
            else  return *GetNextPtr(AL_Distance);
        }/*
        const ZtCLink& operator-(TypeSize AL_Distance) const*/

    public   :
    };/*
    template
        <typename TTypBase, typename TChild>
    class ZtCLink : public TTypBase
    */

    template<typename TTypBase>
        class ZtCLink<TTypBase, ZCEmpty> : public TTypBase
    {
    public   :
        template
            <typename TCLink, typename TTypSize>
        friend class ZtCLinkList;
    public   :
        typedef ZtCLink<TTypBase, ZCEmpty> TypeThis ;
        typedef TTypBase /*+++++++++++++*/ TypeBase ;
        typedef ZCEmpty  /*+++++++++++++*/ TypeChild;
    protected:
        ZtCLink* mp_NextLink;
        ZtCLink* mp_PrevLink;
    public   :

        ZtCLink* GetNextPtr(){return mp_NextLink;}
        ZtCLink* GetPrevPtr(){return mp_PrevLink;}

        void JoinLink(ZtCLink* AP_PrevLink, ZtCLink* AP_NextLink)
        {
            AP_PrevLink->mp_NextLink=AP_NextLink;
            AP_NextLink->mp_PrevLink=AP_PrevLink;
        }/*
        void JoinLink(ZtCLink* AP_PrevLink, ZtCLink* AP_NextLink)*/

        void MakeRing(ZtCLink* AP_HeadLink, ZtCLink* AP_TailLink)
        {
            AP_HeadLink->mp_PrevLink=AP_TailLink;
            AP_TailLink->mp_NextLink=AP_HeadLink;
        }/*
        void MakeRing(ZtCLink* AP_HeadLink, ZtCLink* AP_TailLink)*/

  /*protected:*/
    public   :

        ZtCLink<TTypBase, ZCEmpty>()
        {
            mp_NextLink=0;
            mp_PrevLink=0;
        }/*
        ZtCLink<TTypBase, ZCEmpty>()*/

        ZtCLink<TTypBase, ZCEmpty>(const TypeThis& rhs)
        {
            mp_NextLink=0;
            mp_PrevLink=0;

            *(TypeBase*)(this) = rhs ;
        }/*
        ZtCLink<TTypBase, ZCEmpty>(const TypeThis& rhs)*/

        TypeThis& operator=(const TypeThis& rhs)
        {
            static_cast<TypeBase&>(*this) =
            static_cast<TypeBase&>( rhs ) ;

            return *this;
        }/*
        TypeThis& operator=(const TypeThis& rhs)*/

    public   :
    };/*
    template<typename TTypBase>
        class ZtCLink<TTypBase, ZCEmpty> : public TTypBase*/


    template<typename TChild> class ZtCLink<ZCEmpty, TChild>
    {
    public   :
        template
            <typename TCLink, typename TTypSize>
        friend class ZtCLinkList;
    public   :
        typedef ZtCLink<ZCEmpty, TChild>  TypeThis ;
        typedef ZCEmpty /*++++++++++++*/  TypeBase ;
        typedef TChild  /*++++++++++++*/  TypeChild;
    protected:
        ZtCLink* mp_NextLink;
        ZtCLink* mp_PrevLink;
    protected:

        ZtCLink* GetNextPtr(){return mp_NextLink;}
        ZtCLink* GetPrevPtr(){return mp_PrevLink;}

        void JoinLink(ZtCLink* AP_PrevLink, ZtCLink* AP_NextLink)
        {
            AP_PrevLink->mp_NextLink=AP_NextLink;
            AP_NextLink->mp_PrevLink=AP_PrevLink;
        }/*
        void JoinLink(ZtCLink* AP_PrevLink, ZtCLink* AP_NextLink)*/

        void MakeRing(ZtCLink* AP_HeadLink, ZtCLink* AP_TailLink)
        {
            AP_HeadLink->mp_PrevLink=AP_TailLink;
            AP_TailLink->mp_NextLink=AP_HeadLink;
        }/*
        void MakeRing(ZtCLink* AP_HeadLink, ZtCLink* AP_TailLink)*/

  /*protected:*/
    public   :

        ZtCLink<ZCEmpty, TChild>()
        {
            mp_NextLink=0;
            mp_PrevLink=0;
        }/*
        ZtCLink<ZCEmpty, TChild>()*/

        ZtCLink<ZCEmpty, TChild>(const TypeThis& rhs)
        {
            mp_NextLink=0;
            mp_PrevLink=0;
        }/*
        ZtCLink<ZCEmpty, TChild>(const TypeThis& rhs)*/

        TypeThis& operator=(const TypeThis& rhs)
        {
            return *this;
        }/*
        TypeThis& operator=(const TypeThis& rhs)*/

    public   :
    };/*
    template<typename TChild> class ZtCLink<ZCEmpty, TChild>*/


    template<> class ZtCLink<ZCEmpty, ZCEmpty>
    {
    public   :
        template
            <typename TCLink, typename TTypSize>
        friend class ZtCLinkList;
    public   :
        typedef ZtCLink<ZCEmpty, ZCEmpty> TypeThis ;
        typedef ZCEmpty /*++++++++++++*/  TypeBase ;
        typedef ZCEmpty /*++++++++++++*/  TypeChild;
    protected:
        ZtCLink* mp_NextLink;
        ZtCLink* mp_PrevLink;
    protected:

        ZtCLink* GetNextPtr(){return mp_NextLink;}
        ZtCLink* GetPrevPtr(){return mp_PrevLink;}

        void JoinLink(ZtCLink* AP_PrevLink, ZtCLink* AP_NextLink)
        {
            AP_PrevLink->mp_NextLink=AP_NextLink;
            AP_NextLink->mp_PrevLink=AP_PrevLink;
        }/*
        void JoinLink(ZtCLink* AP_PrevLink, ZtCLink* AP_NextLink)*/

        void MakeRing(ZtCLink* AP_HeadLink, ZtCLink* AP_TailLink)
        {
            AP_HeadLink->mp_PrevLink=AP_TailLink;
            AP_TailLink->mp_NextLink=AP_HeadLink;
        }/*
        void MakeRing(ZtCLink* AP_HeadLink, ZtCLink* AP_TailLink)*/

  /*protected:*/
    public   :

        ZtCLink<ZCEmpty, ZCEmpty>()
        {
            mp_NextLink=0;
            mp_PrevLink=0;
        }/*
        ZtCLink<ZCEmpty, ZCEmpty>()*/

        ZtCLink<ZCEmpty, ZCEmpty>(const TypeThis& rhs)
        {
            mp_NextLink=0;
            mp_PrevLink=0;
        }/*
        ZtCLink<ZCEmpty, ZCEmpty>(const TypeThis& rhs)*/

        TypeThis& operator=(const TypeThis& rhs)
        {
            return *this;
        }/*
        TypeThis& operator=(const TypeThis& rhs)*/

    public   :
    };/*
    template<> class ZtCLink<ZCEmpty, ZCEmpty>*/



    template //////////////////////////////////////////////////////////////////
        <
            typename TCLink
          , typename TTypSize  = ZTypLong
          , typename TTypeCRTP =
                ZNsType::ZtCTypeCRTP<ZCEmpty, false>
        >
    class ZtCLinkList /*#####################################################*/
    {
    public :

        typedef ZNsType::ZtCTypeNowCRTP ///////////////////////////////////////
            <
                ZtCLinkList, typename TTypeCRTP::TypeData, TTypeCRTP::ZEUseCRTP
            >
        ZCTypeNowCRTP ; ///////////////////////////////////////////////////////

        typedef typename ZCTypeNowCRTP::TypeData TypeChild;

    public :
        typedef TCLink   ZCLink  ;
        typedef TCLink   TypeData;
        typedef TTypSize TypeSize;
    private:
        ZCLink*  mp_HeadLink;
        ZCLink*  mp_TailLink;
        TypeSize ml_LinkSize;
    private:

        TypeChild& GetChildObj()
        {
            return *static_cast<TypeChild*>(this);
        }/*
        TypeChild& GetChildObj()*/

    private:

        _VT_ ZCLink* NewLink()
        {
            if(TTypeCRTP::ZEUseCRTP<1)
              { return new ZCLink; }

            return GetChildObj().NewLink();
        }/*
        _VT_ ZCLink* NewLink()*/

        _VT_ void DelLink(ZCLink* AP_DelLink)
        {
            if(TTypeCRTP::ZEUseCRTP<1)
                { return delete ZCLink; }

            return GetChildObj().DelLink(AP_DelLink);
        }/*
        _VT_ void DelLink(ZCLink* AP_DelLink)*/

    private:

        ZCLink& JoinAfter(ZCLink& AR_LinkNew, ZCLink* AP_LinkStd)
        {
            // AR_LinkNew 를 AP_LinkStd 뒤에 삽입한다.
            // AL_PosStd==0 이면 맨 앞에 삽입한다.

            if(AP_LinkStd==0)
            {
                // 맨 앞에 삽입.

                if(++ml_LinkSize==1)
                {
                    mp_HeadLink = &AR_LinkNew  ;
                    mp_TailLink = &AR_LinkNew  ;

                    ZCLink::MakeRing(mp_HeadLink, mp_TailLink);
                }
                else
                {
                    ZCLink::JoinLink(&AR_LinkNew, mp_HeadLink);
                    ZCLink::MakeRing(&AR_LinkNew, mp_TailLink);

                    mp_HeadLink=&AR_LinkNew;
                }/*
                else*/
            }
            else
            {
                ++ml_LinkSize;

                ZCLink* AP_NextStd = AP_LinkStd->mp_NextLink ;

                ZCLink::JoinLink(AP_LinkStd , &AR_LinkNew);
                ZCLink::JoinLink(&AR_LinkNew, AP_NextStd );
            }/*
            else*/

            return AR_LinkNew;
        }/*
        ZCLink& JoinAfter(ZCLink& AR_LinkNew, ZCLink* AP_LinkStd)*/


        ZCLink& JoinBefore(ZCLink& AR_LinkNew, ZCLink* AP_LinkStd)
        {
            // AR_LinkNew 를 AP_LinkStd 앞에 삽입한다.
            // AL_PosStd==0 이면 맨 뒤에 삽입한다.

            if(AP_LinkStd==0)
            {
                // 맨 뒤에 삽입.

                if(++ml_LinkSize==1)
                {
                    mp_HeadLink = &AR_LinkNew ;
                    mp_TailLink = &AR_LinkNew ;

                    ZCLink::MakeRing(mp_HeadLink, mp_TailLink);
                }
                else
                {
                    ZCLink::JoinLink(mp_TailLink, &AR_LinkNew);
                    ZCLink::MakeRing(mp_HeadLink, &AR_LinkNew);

                    mp_HeadLink=&AR_LinkNew;
                }/*
                else*/
            }
            else
            {
                ++ml_LinkSize;

                ZCLink* AP_PrevStd = AP_LinkStd->mp_PrevLink ;

                ZCLink::JoinLink( AP_PrevStd, &AR_LinkNew);
                ZCLink::JoinLink(&AR_LinkNew,  AP_LinkStd);
            }/*
            else*/

            return AR_LinkNew;
        }/*
        ZCLink& JoinBefore(ZCLink& AR_LinkNew, ZCLink* AP_LinkStd)*/


        ZCLink& CutLink(ZCLink& AR_CutLink)
        {
            if(&AR_CutLink==mp_HeadLink)
            {
                if(mp_HeadLink==mp_TailLink)
                    mp_HeadLink=0;
                else
                {
                    ZCLink::MakeRing ////////////////////////////
                        (
                            mp_HeadLink=mp_HeadLink->mp_NextLink,
                            AR_CutLink.mp_PrevLink
                        );
                    /////////////////////////////////////////////
                }/*
                else*/
            }
            else if(&AR_CutLink==mp_TailLink)
            {
                ZCLink* VP_NewTail=AR_CutLink.mp_PrevLink;

                ZCLink::MakeRing(mp_HeadLink, VP_NewTail);

                mp_TailLink = VP_NewTail ;
            }
            else ZCLink::JoinLink(AR_CutLink. mp_PrevLink, AR_CutLink.mp_NextLink);

            return (--ml_LinkSize, AR_CutLink);
        }/*
        ZCLink& CutLink(ZCLink& AR_CutLink)*/


    public :

        ZtCLinkList()
        {
            mp_HeadLink=0;
            mp_TailLink=0;
            ml_LinkSize=0;
        }/*
        ZtCLinkList()*/

        ZtCLinkList(const ZtCLinkList& rhs)
        {
            mp_HeadLink=0;
            mp_TailLink=0;
            ml_LinkSize=0;
        }/*
        ZtCLinkList(const ZtCLinkList& rhs)*/

        ~ZtCLinkList()
        {
            DeleteAll();
        }/*
        ~ZtCLinkList()*/


        ZtCLinkList& operator=(const ZtCLinkList& rhs)
        {
            return *this;
        }/*
        ZtCLinkList& operator=(const ZtCLinkList& rhs)*/


        void DeleteAll()
        {
            if(ml_LinkSize<1) return;

            ZCLink VP_DelLink = mp_HeadLink;

            __for0(TypeSize, i, ml_LinkSize)
            {
                mp_HeadLink = mp_HeadLink->mp_NextLink;

                DelLink(VP_DelLink); VP_DelLink = mp_HeadLink;
            }/*
            __for0(TypeSize, i, ml_LinkSize)*/

            mp_HeadLink=0;
            mp_TailLink=0;
            ml_LinkSize=0;
        }/*
        void DeleteAll()*/

        void clear(){DeleteAll();}


        ZCLink& AddHead(){ return JoinAfter (*NewLink(), 0); }
        ZCLink& AddTail(){ return JoinBefore(*NewLink(), 0); }

        void DelHead()
          { if(ml_LinkSize<1) return;  DelLink( CutLink(mp_HeadLink) ); }
        void DelTail()
          { if(ml_LinkSize<1) return;  DelLink( CutLink(mp_TailLink) ); }


        void Delete(ZCLink& AR_DelLink)
        {
            DelLink( &CutLink(AR_DelLink) );
        }/*
        void Delete(ZCLink& AR_DelLink)*/


        void SendOutAfter (ZCLink& AR_CutLink, ZtCObjList& rhs, ZCLink* AP_StdLink)
        {
            // AR_CutLink 를 잘라서 rhs 의 AP_StdLink 뒤에 연결한다.
            // AP_StdLink==0 이면,  rhs 의 앞에 삽입한다.

            CutLink(AR_CutLink); rhs.JoinAfter (AR_CutLink, AP_StdLink);
        }/*
        void SendOutAfter (ZCLink& AR_CutLink, ZtCObjList& rhs, ZCLink* AP_StdLink)*/

        void SendOutBefore(ZCLink& AR_CutLink, ZtCObjList& rhs, ZCLink* AP_StdLink)
        {
            // AR_CutLink 를 잘라서 rhs 의 AP_StdLink 앞에 연결한다.
            // AP_StdLink==0 이면,  rhs 의 뒤에 삽입한다.

            CutLink(AR_CutLink); rhs.JoinBefore(AR_CutLink, AP_StdLink);
        }/*
        void SendOutBefore(ZCLink& AR_CutLink, ZtCObjList& rhs, ZCLink* AP_StdLink)*/


        void SendOutHead(ZCLink& AR_CutLink, ZtCObjList& rhs)
        {
            // AR_CutLink 를 잘라서 rhs 의 앞에 연결한다.

            SendOutAfter (AR_CutLink, rhs, 0);
        }
        void SendOutTail(ZCLink& AR_CutLink, ZtCObjList& rhs)
        {
            // AR_CutLink 를 잘라서 rhs 의 뒤에 연결한다.

            SendOutBefore(AR_CutLink, rhs, 0);
        }/*
        void SendOutTail(ZCLink& AR_CutLink, ZtCObjList& rhs)*/


    public :
    };/*
    template //////////////////////////////////////////////////////////////////
        <
            typename TCLink
          , typename TTypSize  = ZTypLong
          , typename TTypeCRTP =
                ZNsType::ZtCTypeCRTP<ZCEmpty, false>
        >
    class ZtCLinkList #######################################################*/

}/*
namespace ZNsMain*/


#endif //__ZCPPMAIN__ZTCLINKLIST_H__