#ifndef __ZCPPMAIN__ZTCLINKLIST_H__
#define __ZCPPMAIN__ZTCLINKLIST_H__


#include "ZCppMain/ZMainHead.H"


/*//////////////////////////////////////////////////////////////////////////////////////

■  class ZtCLinkList 는 링크를 외부에서 미리 정의하고, 그 링크를 template parameter 로
    받는다. 이렇게 외부에서 어떤 자료를 (주로 상속으로) 가지는 링크를 정의하면, 링크 자
    체가 일종의 링크를 가진 자료이기 때문에, 자료를 다른 리스트로 이동하기가 쉽다.

    그러니까 ZtCLinkList 는 자료를 다른 리스트로 이동하는 것이 쉽도록 설계되었다.

    -- 2025-10-06 15:22

//////////////////////////////////////////////////////////////////////////////////////*/


namespace ZNsMain
{

    template //////////////////////////////////////////////////////////////////
        <
            typename TCLink
          , typename TTypSize
          , typename TTypeCRTP
        >
    class ZtCLinkList; /*####################################################*/


    namespace ZNsIFaceEx
    {

        template
            <typename TTypBase, typename TChild>
        class ZtCLink : public TTypBase
        {
        public   :

            template //////////////////////////////////////////////////////////////////
                <
                    typename TCLink
                  , typename TTypSize
                  , typename TTypeCRTP
                >
            friend class ZNsMain::ZtCLinkList; /*####################################*/

        public   :
            typedef ZtCLink  TypeThis ;
            typedef TTypBase TypeBase ;
            typedef TChild   TypeChild;
            typedef ZTypLong TypeSize ;
        protected:
            ZtCLink* mp_NextLink;
            ZtCLink* mp_PrevLink;
        protected:

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

            static void MakeRing(ZtCLink* AP_HeadLink, ZtCLink* AP_TailLink)
            {
                AP_HeadLink->mp_PrevLink=AP_TailLink;
                AP_TailLink->mp_NextLink=AP_HeadLink;
            }/*
            static 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 ;

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

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

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


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

            ZtCLink& operator=(const TypeBase& AR_CBase)
            {
                (*this)() = AR_CBase;  return *this;
            }/*
            ZtCLink& operator=(const TypeBase& AR_CBase)*/

            ZtCLink& operator=(TypeBase& AR_CBase)
            {
                (*this)() = AR_CBase;  return *this;
            }/*
            ZtCLink& operator=(TypeBase& AR_CBase)*/


            /***/ TypeBase& operator()()      { return *static_cast<      TypeBase*>(this); }
            const TypeBase& operator()() const{ return *static_cast<const TypeBase*>(this); }


            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* GetNextPrevPtr(TypeSize AL_Distance)
            {
                ZtCLink* VP_TmpLink=this;

                if(AL_Distance>=0)
                    { while(--AL_Distance>=0) VP_TmpLink=VP_TmpLink->mp_NextLink; }
                else{ while(++AL_Distance<=0) VP_TmpLink=VP_TmpLink->mp_PrevLink; }

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

            const ZtCLink* GetNextPrevPtr(TypeSize AL_Distance) const
            {
                ZtCLink* VP_TmpLink=const_cast<ZtCLink*>(this);

                if(AL_Distance>=0)
                    { while(--AL_Distance>=0) VP_TmpLink=VP_TmpLink->mp_NextLink; }
                else{ while(++AL_Distance<=0) VP_TmpLink=VP_TmpLink->mp_PrevLink; }

                return VP_TmpLink;
            }/*
            const ZtCLink* GetNextPrevPtr(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
                  , typename TTypeCRTP
                >
            friend class ZNsMain::ZtCLinkList; /*####################################*/
        public   :
            typedef ZtCLink<TTypBase, ZCEmpty> TypeThis ;
            typedef TTypBase /*+++++++++++++*/ TypeBase ;
            typedef ZCEmpty  /*+++++++++++++*/ TypeChild;
            typedef ZTypLong /*+++++++++++++*/ TypeSize ;
        protected:
            ZtCLink* mp_NextLink;
            ZtCLink* mp_PrevLink;
        public   :

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

            static void MakeRing(ZtCLink* AP_HeadLink, ZtCLink* AP_TailLink)
            {
                AP_HeadLink->mp_PrevLink=AP_TailLink;
                AP_TailLink->mp_NextLink=AP_HeadLink;
            }/*
            static 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 ;

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

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

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

            TypeThis& operator=(TypeBase& AR_CBase)
            {
                (*this)() = AR_CBase;  return *this;
            }/*
            TypeThis& operator=(TypeBase& AR_CBase)*/


            /***/ TypeBase& operator()()      { return *static_cast<      TypeBase*>(this); }
            const TypeBase& operator()() const{ return *static_cast<const TypeBase*>(this); }


            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* GetNextPrevPtr(TypeSize AL_Distance)
            {
                ZtCLink* VP_TmpLink=this;

                if(AL_Distance>=0)
                    { while(--AL_Distance>=0) VP_TmpLink=VP_TmpLink->mp_NextLink; }
                else{ while(++AL_Distance<=0) VP_TmpLink=VP_TmpLink->mp_PrevLink; }

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

            const ZtCLink* GetNextPrevPtr(TypeSize AL_Distance) const
            {
                ZtCLink* VP_TmpLink=const_cast<ZtCLink*>(this);

                if(AL_Distance>=0)
                    { while(--AL_Distance>=0) VP_TmpLink=VP_TmpLink->mp_NextLink; }
                else{ while(++AL_Distance<=0) VP_TmpLink=VP_TmpLink->mp_PrevLink; }

                return VP_TmpLink;
            }/*
            const ZtCLink* GetNextPrevPtr(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>
            class ZtCLink<TTypBase, ZCEmpty> : public TTypBase*/


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

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

            static void MakeRing(ZtCLink* AP_HeadLink, ZtCLink* AP_TailLink)
            {
                AP_HeadLink->mp_PrevLink=AP_TailLink;
                AP_TailLink->mp_NextLink=AP_HeadLink;
            }/*
            static 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)*/


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

            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* GetNextPrevPtr(TypeSize AL_Distance)
            {
                ZtCLink* VP_TmpLink=this;

                if(AL_Distance>=0)
                    { while(--AL_Distance>=0) VP_TmpLink=VP_TmpLink->mp_NextLink; }
                else{ while(++AL_Distance<=0) VP_TmpLink=VP_TmpLink->mp_PrevLink; }

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

            const ZtCLink* GetNextPrevPtr(TypeSize AL_Distance) const
            {
                ZtCLink* VP_TmpLink=const_cast<ZtCLink*>(this);

                if(AL_Distance>=0)
                    { while(--AL_Distance>=0) VP_TmpLink=VP_TmpLink->mp_NextLink; }
                else{ while(++AL_Distance<=0) VP_TmpLink=VP_TmpLink->mp_PrevLink; }

                return VP_TmpLink;
            }/*
            const ZtCLink* GetNextPrevPtr(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 TChild> class ZtCLink<ZCEmpty, TChild>*/


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

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

            static void MakeRing(ZtCLink* AP_HeadLink, ZtCLink* AP_TailLink)
            {
                AP_HeadLink->mp_PrevLink=AP_TailLink;
                AP_TailLink->mp_NextLink=AP_HeadLink;
            }/*
            static 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)*/


            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* GetNextPrevPtr(TypeSize AL_Distance)
            {
                ZtCLink* VP_TmpLink=this;

                if(AL_Distance>=0)
                    { while(--AL_Distance>=0) VP_TmpLink=VP_TmpLink->mp_NextLink; }
                else{ while(++AL_Distance<=0) VP_TmpLink=VP_TmpLink->mp_PrevLink; }

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

            const ZtCLink* GetNextPrevPtr(TypeSize AL_Distance) const
            {
                ZtCLink* VP_TmpLink=const_cast<ZtCLink*>(this);

                if(AL_Distance>=0)
                    { while(--AL_Distance>=0) VP_TmpLink=VP_TmpLink->mp_NextLink; }
                else{ while(++AL_Distance<=0) VP_TmpLink=VP_TmpLink->mp_PrevLink; }

                return VP_TmpLink;
            }/*
            const ZtCLink* GetNextPrevPtr(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<> class ZtCLink<ZCEmpty, ZCEmpty>*/

    }/*
    namespace ZNsIFaceEx*/



    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 ZtCObjOpt<TCLink> ZCDataOpt;
        typedef ZtCObjOpt<TCLink> ZCLinkOpt;
    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:

        ZCLink* NewLink()
        {
            return new ZCLink;
        }/*
        ZCLink* NewLink()*/

        ZCLink* NewLink(      ZCLink& AR_ArgData)
          { return new ZCLink(AR_ArgData); }

        ZCLink* NewLink(const ZCLink& AR_ArgData)
          { return new ZCLink(AR_ArgData); }

        void NewLink ////////////////////////////////////////
            (
                TypeSize AL_NeedCnt   ,
                ZCLink*& APR_HeadLink ,
                ZCLink*& APR_TailLink
            )
        /////////////////////////////////////////////////////
        {
            APR_HeadLink = new ZCLink;

            ZCLink* VP_MakeLink = 0           ;
            ZCLink* VP_TailLink = APR_HeadLink;

            while(--AL_NeedCnt>0) // AL_NeedCnt - 1 번 순환
            {
                // AL_NeedCnt - 1 번 순환

                VP_MakeLink = new ZCLink;

                ZCLink::JoinLink
                    (VP_TailLink, VP_MakeLink);
                VP_TailLink = VP_MakeLink ;
            }/*
            while(--AL_NeedCnt>0)*/

            APR_TailLink = VP_TailLink;
        }/*
        void NewLink ////////////////////////////////////////
            (
                TypeSize AL_NeedCnt   ,
                ZCLink*& APR_HeadLink ,
                ZCLink*& APR_TailLink
            )
        ///////////////////////////////////////////////////*/


        void NewLinkCopy   //////////////////////////////////
            (
                ZCLink*  AP_LinkOrgin, TypeSize AL_FarNum   ,
                ZCLink*& APR_HeadCopy, ZCLink*& APR_TailCopy
            )
        /////////////////////////////////////////////////////
        {
            // 총 AL_FarNum+1 개의 링크가 만들어짊

            ZCLink* VP_MakeLink  = 0  ;
            ZCLink* VP_TailLink  = 0  ;

            VP_TailLink  = VP_MakeLink =
                new ZCLink(**AP_LinkOrgin) ;

            APR_HeadCopy = VP_MakeLink;

            while(--AL_FarNum >= 0)
            {
                AP_LinkOrgin= AP_LinkOrgin->GetNextPtr();
                VP_MakeLink = new ZCLink(**AP_LinkOrgin);

                ZCLink::JoinLink
                    (VP_TailLink, VP_MakeLink);

                VP_TailLink = VP_MakeLink;
            }/*
            while(--AL_FarNum >= 0)*/

            APR_TailCopy=VP_TailLink;
        }/*
        void NewLinkCopy   //////////////////////////////////
            (
                ZCLink*  AP_LinkOrgin, TypeSize AL_FarNum   ,
                ZCLink*& APR_HeadCopy, ZCLink*& APR_TailCopy
            )
        ///////////////////////////////////////////////////*/


        void DelLink(ZCLink* AP_DelLink)
        {
            delete AP_DelLink;
        }/*
        void DelLink(ZCLink* AP_DelLink)*/

        void DelLink //////////////////////////////////////////
            (
                TypeSize  AL_CutCnt ,
                ZCLink*   AP_CutHead,
                ZCLink*   AP_CutTail
            )
        ///////////////////////////////////////////////////////
        {
            ZCLink* VP_DelLink = AP_CutHead;

            __for0(TypeSize, i, AL_CutCnt)
            {
                AP_CutHead = AP_CutHead->GetNextPtr() ;

                delete VP_DelLink;  VP_DelLink=AP_CutHead;
            }/*
            __for0(TypeSize, i, AL_CutCnt)*/
        }
        ///////////////////////////////////////////////////////

  /*private:*/
    private:

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

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

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

            return GetChildObj().SendFreeOut(AR_ArgData);
        }/*
        _VT_ ZCLink* SendFreeOut(ZCLink& AR_ArgData)*/

        _VT_ ZCLink* SendFreeOut(const ZCLink& AR_ArgData)
        {
            if(TTypeCRTP::ZEUseCRTP<1)
                { return NewLink(AR_ArgData); }

            return GetChildObj().SendFreeOut(AR_ArgData);
        }/*
        _VT_ ZCLink* SendFreeOut(const ZCLink& AR_ArgData)*/

        _VT_ void SendFreeOut
            (TypeSize AL_NeedCnt, ZCLink*& APR_HeadLink, ZCLink*& APR_TailLink)
        {
            if(TTypeCRTP::ZEUseCRTP<1)
            {
                NewLink(AL_NeedCnt, APR_HeadLink, APR_TailLink); return;
            }/*
            if(TTypeCRTP::ZEUseCRTP<1)*/

            return GetChildObj().SendFreeOut
                (AL_NeedCnt, RR(APR_HeadLink), RR(APR_TailLink));
        }/*
        _VT_ void SendFreeOut
            (TypeSize AL_NeedCnt, ZCLink*& APR_HeadLink, ZCLink*& APR_TailLink)
        */

        _VT_ void SendFreeOutCopy /*///////////////////////*/
            (
                ZCLink*  AP_LinkOrgin, TypeSize AL_FarNum   ,
                ZCLink*& APR_HeadCopy, ZCLink*& APR_TailCopy
            )
        /////////////////////////////////////////////////////
        {
            // 총 AL_FarNum+1 개의 링크가 만들어짊

            if(TTypeCRTP::ZEUseCRTP<1)
            {
                NewLinkCopy(AP_LinkOrgin, AL_FarNum, APR_HeadCopy, APR_TailCopy); return;
            }/*
            if(TTypeCRTP::ZEUseCRTP<1)*/

            return GetChildObj().SendFreeOutCopy
                (AP_LinkOrgin, AL_FarNum, RR(APR_HeadCopy), RR(APR_TailCopy));
        }/*
        _VT_ void SendFreeOutCopy   /////////////////////////
            (
                ZCLink*  AP_LinkOrgin, TypeSize AL_FarNum   ,
                ZCLink*& APR_HeadCopy, ZCLink*& APR_TailCopy
            )
        ///////////////////////////////////////////////////*/


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

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

        _VT_ void RecvFreeIn //////////////////////////////////
            (
                TypeSize  AL_CutCnt ,
                ZCLink*   AP_CutHead,
                ZCLink*   AP_CutTail
            )
        ///////////////////////////////////////////////////////
        {
            if(TTypeCRTP::ZEUseCRTP<1)
            {
                DelLink
                    (AL_CutCnt, AP_CutHead, AP_CutTail);
                return;
            }/*
            if(TTypeCRTP::ZEUseCRTP<1)*/

            GetChildObj().RecvFreeIn(AL_CutCnt, AP_CutHead, AP_CutTail);
        }/*
        _VT_ void RecvFreeIn //////////////////////////////////
            (
                TypeSize  AL_CutCnt ,
                ZCLink*   AP_CutHead,
                ZCLink*   AP_CutTail
            )
        /////////////////////////////////////////////////////*/

  /*private:*/
    private:

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

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

                if(ml_LinkSize==0)
                {
                    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 if(AP_LinkStd==mp_TailLink)
            {
                ZCLink::JoinLink(mp_TailLink, &AR_LinkNew) ;
                ZCLink::MakeRing(mp_HeadLink, &AR_LinkNew) ;

                mp_TailLink = &AR_LinkNew;
            }
            else
            {
                ZCLink* AP_NextStd = AP_LinkStd->mp_NextLink ;

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

            ++ml_LinkSize;  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==0)
                {
                    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_TailLink=&AR_LinkNew;
                }/*
                else*/
            }
            else if(AP_LinkStd==mp_HeadLink)
            {
                ZCLink::JoinLink(&AR_LinkNew, mp_HeadLink);
                ZCLink::MakeRing(&AR_LinkNew, mp_TailLink);

                mp_HeadLink = &AR_LinkNew;
            }
            else
            {
                ZCLink* AP_PrevStd = AP_LinkStd->mp_PrevLink ;

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

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


        ZtCLinkList& JoinAfter(ZtCLinkList& rhs, ZCLink* AP_StdLink)
        {
            // AP_StdLink 의 뒤에 rhs 를 삽입.

            if(this==&rhs  ) return *this;
            if(rhs.size()<1) return *this;

            if(AP_StdLink==0) // 맨 앞에 삽입
            {
                if(ml_LinkSize<1)
                {
                    mp_HeadLink = rhs.mp_HeadLink ;
                    mp_TailLink = rhs.mp_TailLink ;
                    ml_LinkSize = rhs.ml_LinkSize ;
                }
                else // ml_LinkSize>=1
                {
                    ZCLink::JoinLink( rhs.mp_TailLink, mp_HeadLink );
                    ZCLink::MakeRing( rhs.mp_HeadLink, mp_TailLink );

                    mp_HeadLink = rhs.mp_HeadLink ;
                    ml_LinkSize = rhs.ml_LinkSize ;
                }/*
                else // ml_LinkSize>=1*/

                ml_LinkSize += rhs.ml_LinkSize;

                rhs.mp_HeadLink = 0 ;
                rhs.mp_TailLink = 0 ;
                rhs.ml_LinkSize = 0 ;

                return *this;
            }/*
            if(AP_StdLink==0)*/


            ZCLink* VP_StdNext=AP_StdLink->mp_NextLink;

            ZCLink::JoinLink(AP_StdLink     , rhs.mp_HeadLink );
            ZCLink::JoinLink(rhs.mp_TailLink, VP_StdNext      );

            if(AP_StdLink==mp_TailLink)
                { mp_TailLink=rhs.mp_TailLink; }

            rhs.mp_HeadLink =0 ;
            rhs.mp_TailLink =0 ;
            rhs.ml_LinkSize =0 ;

            ml_LinkSize += rhs.ml_LinkSize;  return *this;
        }/*
        ZtCLinkList& JoinAfter(ZtCLinkList& rhs, ZCLink* AP_StdLink)*/


        ZtCLinkList& JoinBefore(ZtCLinkList& rhs, ZCLink* AP_StdLink)
        {
            // AP_StdLink 의 앞에 rhs 를 삽입.

            if(this==&rhs  ) return *this;
            if(rhs.size()<1) return *this;

            if(AP_StdLink==0) // 맨 뒤에 삽입
            {
                if(ml_LinkSize<1)
                {
                    mp_HeadLink = rhs.mp_HeadLink ;
                    mp_TailLink = rhs.mp_TailLink ;
                    ml_LinkSize = rhs.ml_LinkSize ;
                }
                else // ml_LinkSize>=1
                {
                    ZCLink::JoinLink(mp_TailLink, rhs.mp_HeadLink );
                    ZCLink::MakeRing(mp_HeadLink, rhs.mp_TailLink );

                    mp_TailLink  = rhs.mp_TailLink ;
                    ml_LinkSize += rhs.ml_LinkSize ;
                }/*
                else // ml_LinkSize>=1*/

                rhs.mp_HeadLink=0;
                rhs.mp_TailLink=0;
                rhs.ml_LinkSize=0;

                ml_LinkSize += rhs.ml_LinkSize;  return *this;
            }/*
            if(AP_StdLink==0)*/


            ZCLink* VP_StdPrev = AP_StdLink->mp_PrevLink;

            ZCLink::JoinLink(    VP_StdPrev , rhs.mp_HeadLink );
            ZCLink::JoinLink(rhs.mp_TailLink,     AP_StdLink  );

            if(AP_StdLink==mp_HeadLink)
              { mp_HeadLink = rhs.mp_HeadLink; }

            rhs.mp_HeadLink =0 ;
            rhs.mp_TailLink =0 ;
            rhs.ml_LinkSize =0 ;

            ml_LinkSize += rhs.ml_LinkSize;  return *this;
        }/*
        ZtCLinkList& JoinBefore(ZtCLinkList& rhs, ZCLink* AP_StdLink)*/


        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)*/


        ZtCLinkList& CutLinkRangeOut  /*#######################################*/
            (
                ZCLink&       AR_CutHead ,
                ZCLink&       AR_CutTail ,
                TypeSize      AL_CutSize ,
                ZtCLinkList&  rhs        ,
                ZCLink*       AP_RhsStd
            )
        /*#####################################################################*/
        {
            /*///////////////////////////////////////////////////////////

            ■  AR_CutHead 는 삭제하려는 링크의 범위의 앞의 링크.
                AR_CutTail 은 삭제하려는 링크의 범위의 뒤의 링크.

                AR_CutHead 의 앞과 AR_CutTail 의 뒤에서 연결 상태를 끊고,
                rhs 의 AP_RhsStd 의 뒤에 삽입한다. AP_RhsStd==0 이면
                맨 앞에 삽입한다.  -- 2025-10-06 09:16

            ///////////////////////////////////////////////////////////*/

            if(this==&rhs   ) return rhs;
            if(ml_LinkSize<1) return rhs;

            if(AL_CutSize>=ml_LinkSize) // 모든 링크를 삭제할 때.
            {
                mp_HeadLink=0;
            }
            else if(&AR_CutHead==mp_HeadLink) // 잘라내려는 링크가 처음 링크를 포함할 때.
            {
                ZCLink::MakeRing
                  (mp_HeadLink=AR_CutTail.mp_NextLink, mp_TailLink);
            }
            else if(&AR_CutTail==mp_TailLink) // 잘라내려는 링크가 끝 링크를 포함할 때.
            {
                ZCLink::MakeRing(mp_HeadLink, mp_TailLink=AR_CutHead.mp_PrevLink);
            }
            else // 잘라내려는 링크가 처음과 끝 링크를 포함하지 않을 때.
            {
                ZCLink::JoinLink(AR_CutHead.mp_PrevLink, AR_CutTail.mp_NextLink);
            }/*
            else*/

            ml_LinkSize -= AL_CutSize;


            if(rhs.size()<1)
            {
                // AP_CutHead 과 AP_CutTail 을 연결하여 이중 원형 연결리스트가 되도록 한다.

                ZCLink::MakeRing(&AR_CutHead, &AR_CutTail);

                rhs.mp_HeadLink = &AR_CutHead ;
                rhs.mp_TailLink = &AR_CutTail ;
            }
            else if(AP_RhsStd==0) // 맨 앞에 삽입.
            {
                ZCLink::JoinLink(&AR_CutTail, rhs.mp_HeadLink);
                ZCLink::MakeRing(&AR_CutHead, rhs.mp_TailLink);

                rhs.mp_HeadLink = &AR_CutHead;
            }
            else // AP_RhsStd 의 뒤에 삽입.
            {
                ZCLink* VP_RhsStdNext = AP_RhsStd->mp_NextLink ;

                ZCLink::JoinLink(AP_RhsStd  , &AR_CutHead  );
                ZCLink::JoinLink(&AR_CutTail, VP_RhsStdNext);

                if(AP_RhsStd==rhs.mp_TailLink)
                    { rhs.mp_TailLink = &AR_CutTail; }
            }/*
            else*/

            rhs.ml_LinkSize += AL_CutSize;  return rhs;
        }/*
        ZtCLinkList& CutLinkRangeOut  ###########################################
            (
                ZCLink&       AR_CutHead ,
                ZCLink&       AR_CutTail ,
                TypeSize      AL_CutSize ,
                ZtCLinkList&  rhs        ,
                ZCLink*       AP_RhsStd
            )
        #######################################################################*/


  /*private:*/
    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;

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

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


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

            if(rhs.size()<1)
                { this->DeleteAll(); return *this; }

            TypeSize VL_MinusSize = this->size() - rhs.size() ;

            if     (VL_MinusSize>0)
            {
                RecvFreeIn ////////////////////////////////////////
                    (
                        VL_MinusSize,
                        mp_HeadLink ,
                        mp_HeadLink->GetNextPrevPtr(VL_MinusSize-1)
                    );
                ///////////////////////////////////////////////////

                ml_LinkSize -= VL_MinusSize;
            }
            else if(VL_MinusSize<0)
            {
                ZCLink* VP_HeadLink=0;
                ZCLink* VP_TailLink=0;

                SendFreeOut ////////////////////////////////////////
                    (
                       -VL_MinusSize    ,
                        RR(VP_HeadLink) ,
                        RR(VP_TailLink)
                    );
                ///////////////////////////////////////////////////

                if(ml_LinkSize>0)
                {
                    ZCLink::JoinLink(mp_TailLink, VP_HeadLink);
                    ZCLink::MakeRing(mp_HeadLink, VP_TailLink);

                    mp_TailLink = VP_TailLink ;
                }
                else
                {
                    mp_HeadLink = VP_HeadLink ;
                    mp_TailLink = VP_TailLink ;

                    ZCLink::MakeRing(mp_HeadLink, VP_TailLink);
                }/*
                else*/

                ml_LinkSize += (-VL_MinusSize);
            }/*
            else if(VL_MinusSize<0)*/


            ZCLink* VP_RhsLink = rhs.mp_HeadLink ;
            ZCLink* VP_LhsLink =     mp_HeadLink ;

            __for0(TypeSize, i, rhs.size())
            {
                *VP_LhsLink = *VP_RhsLink ;

                VP_RhsLink = VP_RhsLink->mp_NextLink;
                VP_LhsLink = VP_LhsLink->mp_NextLink;
            }/*
            __for0(TypeSize, i, rhs.size())*/

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


        TypeSize GetSize() const{return ml_LinkSize  ;}
        TypeSize size   () const{return ml_LinkSize  ;}

        bool     IsEmpty() const{return ml_LinkSize<1;}


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

            RecvFreeIn
                (ml_LinkSize, mp_HeadLink, mp_TailLink);

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

        void clear(){DeleteAll();}


        ZCDataOpt GetHeadOpt(){ return ZCDataOpt(mp_HeadLink); }
        ZCDataOpt GetTailOpt(){ return ZCDataOpt(mp_TailLink); }

        ZCDataOpt GetObjOpt(TypeSize AI_Index)
        {
            if(ml_LinkSize<1) return ZCDataOpt(0);

            return ZCDataOpt( (*mp_HeadLink)+(AI_Index-1) );
        }/*
        ZCDataOpt GetObjOpt(TypeSize AI_Index)*/


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

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

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


        void DeleteHead()
          { if(ml_LinkSize<1) return;  RecvFreeIn( &CutLink(mp_HeadLink) ); }
        void DeleteTail()
          { if(ml_LinkSize<1) return;  RecvFreeIn( &CutLink(mp_TailLink) ); }


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


        ZtCLinkList& JoinAfter (ZtCLinkList& rhs, ZCLink& AR_StdLink)
            { return JoinAfter (rhs, &AR_StdLink); }
        ZtCLinkList& JoinBefore(ZtCLinkList& rhs, ZCLink& AR_StdLink)
            { return JoinBefore(rhs, &AR_StdLink); }

        ZtCLinkList& JoinHead(ZtCLinkList& rhs){ return JoinAfter (rhs, 0); }
        ZtCLinkList& JoinTail(ZtCLinkList& rhs){ return JoinBefore(rhs, 0); }


        void SendOutAfter (ZCLink& AR_CutLink, ZtCLinkList& rhs, ZCLink& AR_StdLink)
        {
            // AR_CutLink 를 잘라서 rhs 의 AR_StdLink 뒤에 연결한다.

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

        void SendOutBefore(ZCLink& AR_CutLink, ZtCLinkList& rhs, ZCLink& AR_StdLink)
        {
            // AR_CutLink 를 잘라서 rhs 의 AP_StdLink 앞에 연결한다.

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


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

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

            CutLink(AR_CutLink); rhs.JoinBefore(AR_CutLink, 0);
        }/*
        void SendOutTail(ZCLink& AR_CutLink, ZtCLinkList& rhs)*/


        ZtCLinkList& SendRangeOutAfter //////////////////////////////////////////
            (
                ZCLink&       AR_CutHead,
                ZCLink&       AR_CutTail,
                TypeSize      AI_CutSize,
                ZtCLinkList&  rhs       ,
                ZCLinkOpt     AO_LinkOpt
            )
        /*#####################################################################*/
        {
            // AR_CutHead 부터 AR_CutTail 까지를 잘라서 rhs 의 AR_StdLink 뒤에 연결한다.

            return CutLinkRangeOut
                (
                    AR_CutHead, AR_CutTail, AI_CutSize, rhs, AO_LinkOpt.Raw()
                );
            //////////////////////
        }/*
        ZtCLinkList& SendRangeOutAfter //////////////////////////////////////////
            (
                ZCLink&       AR_CutHead,
                ZCLink&       AR_CutTail,
                TypeSize      AI_CutSize,
                ZtCLinkList&  rhs       ,
                ZCLinkOpt     AO_LinkOpt
            )
        /*#####################################################################*/


        template<typename TFunctor> void IterElement(TFunctor AO_Functor)
        {
            ZCLink* VP_LoopLink=mp_HeadLink;

            __for0(TypeSize, i, ml_LinkSize)
            {
                ZtCTypeData<TFunctor>::
                    GetObjRef(AO_Functor)( *VP_LoopLink );

                VP_LoopLink = VP_LoopLink->mp_NextLink ;
            }/*
            __for0(TypeSize, i, ml_LinkSize)*/
        }/*
        template<typename TFunctor> void IterElement(TFunctor AO_Functor) */


        template<typename TFunctor, typename TTypeHelp>
            void IterElement(TFunctor AO_Functor, TTypeHelp AO_TypeHelp)
        {
            typedef ZNsMain::
                ZtCCheckRef<TTypeHelp> ZCCheckRef;

            ZCLink* VP_LoopLink=mp_HeadLink;

            __for0(TypeSize, i, ml_LinkSize)
            {
                ZtCTypeData<TFunctor>::GetObjRef(AO_Functor)
                    (
                        *VP_LoopLink, ZCCheckRef::PassData(AO_TypeHelp)
                    );
                VP_LoopLink = VP_LoopLink->mp_NextLink ;
            }/*
            __for0(TypeSize, i, ml_Size)*/
        }/*
        template<typename TFunctor, typename TTypeHelp>
            void IterElement(TFunctor AO_Functor, TTypeHelp AO_TypeHelp) */


        template
            < typename TFunctor  , typename   TTypeHelp1  , typename   TTypeHelp2   >
        void IterElement
            ( TFunctor AO_Functor, TTypeHelp1 AO_TypeHelp1, TTypeHelp2 AO_TypeHelp2 )
        /*#############################################################################*/
        {
            typedef ZNsMain::ZtCCheckRef<TTypeHelp1> ZCCheckRef1;
            typedef ZNsMain::ZtCCheckRef<TTypeHelp2> ZCCheckRef2;

            ZCLink* VP_LoopLink=mp_HeadLink;

            __for0(TypeSize, i, ml_LinkSize)
            {
                ZtCTypeData<TFunctor>::GetObjRef(AO_Functor)
                    (
                        *VP_LoopLink
                      , ZCCheckRef1::PassData(AO_TypeHelp1)
                      , ZCCheckRef2::PassData(AO_TypeHelp2)
                    );
                ////////////////////////////////////////////

                VP_LoopLink = VP_LoopLink->mp_NextLink ;
            }/*
            __for0(TypeSize, i, ml_Size)*/
        }/*
        template
            < typename TFunctor  , typename   TTypeHelp1  , typename   TTypeHelp2   >
        void IterElement
            ( TFunctor AO_Functor, TTypeHelp1 AO_TypeHelp1, TTypeHelp2 AO_TypeHelp2 )
        ###############################################################################*/


        template<typename TFunctor> void IterElemRev(TFunctor AO_Functor)
        {
            ZCLink* VP_LoopLink=mp_TailLink;

            __for0(TypeSize, i, ml_LinkSize)
            {
                ZtCTypeData<TFunctor>::
                    GetObjRef(AO_Functor)(*VP_LoopLink);

                VP_LoopLink = VP_LoopLink->mp_PrevLink ;
            }/*
            __for0(TypeSize, i, ml_Size)*/
        }/*
        template<typename TFunctor> void IterElemRev(TFunctor AO_Functor) */

        template<typename TFunctor, typename TTypeHelp>
            void IterElemRev(TFunctor AO_Functor, TTypeHelp AO_TypeHelp)
        {
            typedef ZNsMain::
                ZtCCheckRef<TTypeHelp> ZCCheckRef;

            ZCLink* VP_LoopLink = mp_TailLink;

            __for0(TypeSize, i, ml_LinkSize)
            {
                ZtCTypeData<TFunctor>::GetObjRef(AO_Functor)
                    (
                        *VP_LoopLink, ZCCheckRef::PassData(AO_TypeHelp)
                    );
                VP_LoopLink = VP_LoopLink->mp_PrevLink ;
            }/*
            __for0(TypeSize, i, ml_Size)*/
        }/*
        template<typename TFunctor, typename TTypeHelp>
            void IterElemRev(TFunctor AO_Functor, TTypeHelp AO_TypeHelp) */


        template
            < typename TFunctor  , typename   TTypeHelp1  , typename   TTypeHelp2   >
        void IterElemRev
            ( TFunctor AO_Functor, TTypeHelp1 AO_TypeHelp1, TTypeHelp2 AO_TypeHelp2 )
        /*#############################################################################*/
        {
            typedef ZNsMain::ZtCCheckRef<TTypeHelp1> ZCCheckRef1;
            typedef ZNsMain::ZtCCheckRef<TTypeHelp2> ZCCheckRef2;

            ZCLink* VP_LoopLink = mp_TailLink;

            __for0(TypeSize, i, ml_LinkSize)
            {
                ZtCTypeData<TFunctor>::GetObjRef(AO_Functor)
                    (
                        *VP_LoopLink
                      , ZCCheckRef1::PassData(AO_TypeHelp1)
                      , ZCCheckRef2::PassData(AO_TypeHelp2)
                    );
                VP_LoopLink = VP_LoopLink->mp_PrevLink ;
            }/*
            __for0(TypeSize, i, ml_Size)*/
        }/*
        template
            < typename TFunctor  , typename   TTypeHelp1  , typename   TTypeHelp2   >
        void IterElemRev
            ( TFunctor AO_Functor, TTypeHelp1 AO_TypeHelp1, TTypeHelp2 AO_TypeHelp2 )
        ###############################################################################*/

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

}/*
namespace ZNsMain*/


#endif //__ZCPPMAIN__ZTCLINKLIST_H__