#ifndef __ZCPPMAIN__ZTCLINKLIST_H__
#define __ZCPPMAIN__ZTCLINKLIST_H__


#include "ZCppMain/ZMainHead.H"


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

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

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

    -- 2025-10-06 15:22


    ZNsIFaceEx::ZtCLink 의 상속 클래스를 아래로 선언하고

        class ZCLinkData :
            public ZNsIFaceEx::ZtCLink<ZCEmpty, ZCLinkData>

        typedef ZNsIFaceEx::ZtCLink
            <ZCEmpty, ZCLinkData> ZCLinkBase;

    ZtCLinkList 의 template 인수에 기반 클래스 ZCLinkBase 를 지정한 예.


        class ZCLinkData : public ZNsIFaceEx::ZtCLink<ZCEmpty, ZCLinkData>
        {
        private:
            string mo_DataCStr;
        private:
            static int SI_CallCnt;
        public :
            typedef ZNsIFaceEx::ZtCLink<ZCEmpty, ZCLinkData> TypeBase;
        public :

            ZCLinkData() : ZNsIFaceEx::ZtCLink<ZCEmpty, ZCLinkData>()
            {
                cout<<"* ZCLinkData() : "<<++ZCLinkData::SI_CallCnt<<endl;
            }
            ZCLinkData(const ZCLinkData& rhs) :
                ZNsIFaceEx::
                    ZtCLink<ZCEmpty, ZCLinkData>(),
                mo_DataCStr(rhs.mo_DataCStr)
            {cout<<"* ZCLinkData(const ZCLinkData& rhs) : "<<++ZCLinkData::SI_CallCnt<<endl;}

            ZCLinkData(const TypeBase& rhs) :
                ZNsIFaceEx::
                    ZtCLink<ZCEmpty, ZCLinkData>(),
                mo_DataCStr
                    (
                        (*static_cast<const ZCLinkData*>(&rhs)).mo_DataCStr
                    )
            {cout<<"* ZCLinkData(const TypeBase& rhs) : "<<++ZCLinkData::SI_CallCnt<<endl;}


            ~ZCLinkData()
            {
                cout<<"* ~ZCLinkData() : "<<ZCLinkData::SI_CallCnt--<<endl;
            }

            ZCLinkData& operator=(const ZCLinkData& rhs)
            {
                mo_DataCStr = rhs.mo_DataCStr;  return *this;
            }

                  string& GetData()      {return mo_DataCStr;}
            const string& GetData() const{return mo_DataCStr;}

        public :
        };


        typedef ZNsIFaceEx::ZtCLink
            <ZCEmpty, ZCLinkData> ZCLinkBase;

        typedef ZCLinkData              ZCLinkCStr   ;
        typedef ZtCLinkList<ZCLinkBase> ZCLinkStrList;

    -- 2015-10-15 14:51

■  ZtCLinkList 의 링크를 주로 정의하는 ZNsIFaceEx::ZtCLink 은 operator() 을 가지는 것이
    좋다.

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

    그래서 ZtCLink 가 가지고 있는, 링크 포인터 이외의 데이타에 접근할 수 있는 장치를 제공
    하는 것이 좋다.

    -- 2025-10-07 12:23


    ZNsIFaceEx::ZtCLink 는 TypeData 라는 자료형을 갖는데, ZtCLink 이

        상속 클래스가 있다면, 그 상속 클래스
        기반 클래스만 있다면, 그 기반 클래스

    를 나타낸다. 상속 클래스도 기반 클래스도 없다면, 자기 자신을 나타낸다.

    -- 2025-10-07 17:18


    ZNsIFaceEx::ZtCLink 는 TypeMain 이라는 자료형을 갖는데, ZtCLink 이

        상속 클래스가 있다면, 그 상속 클래스
        상속 클래스가 없다면, 클래스 자기 자신

    를 나타낸다. 그래서 ZtCLinkList 에서 new 로 객체를 만들 때,

        ZtCLink* my=new TypeMain;

    처럼 쓸 수 있게 한다.

    -- 2025-10-07 17:49

■  class ZtCLinkMoveList 은 고정적으로 맨 앞과 맨 뒤를 가상으로 표시하는 링크 객체를 멤
    버로 가지고 있다. 그래서 중간에서 링크 자료를 떼어 내어 다른 리스트로 옮길 때, 그 링
    크가 리스트의 앞이나 뒤가 아닌, 무조건 중간에 존재한다고 가정하고 빠르게 떼어낼 수 있
    도록 했다. 이렇지 않다면 떼어 내려는 링크가 처음 링크인지 마지막 링크인지를 판단하는
    코드를 집어 넣어야 한다. 그러니까 ZtCLinkList 보다 좀 더 빠르게 리스트간 자료 이동이
    가능하게 설계한 것이다.

        ZCLink mo_HeadFake; // 고정된 가상의 맨 앞 링크 객체
        ZCLink mo_TailFake; // 고정된 가상의 맨 뒤 링크 객체

    실제 사용되는 링크의 머리는 mo_HeadFake.mp_NextLink 이고
    실제 사용되는 링크의 꼬리는 mo_TailFake.mp_PrevLink 이다.

    물론 이동하려는 링크가 mo_HeadFake 이나 mo_TailFake 을 가리키지 않도록 조심할 필요는
    있다.

    -- 2025-10-06 22:18

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


namespace ZNsMain
{

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


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


    namespace ZNsIFaceEx
    {

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

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

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

        public   :
            typedef ZtCLink  TypeThis ;
            typedef TTypBase TypeBase ;
            typedef TChild   TypeChild;
            typedef TChild   TypeData ;
            typedef TChild   TypeMain ;
            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)*/

            virtual ~ZtCLink()
            {
            }/*
            virtual ~ZtCLink()*/


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


            TypeData& operator* () { return *static_cast<TypeData*>(this); }
            TypeData& operator()() { return *static_cast<TypeData*>(this); }

            const TypeData& operator* () const
                { return *static_cast<const TypeData*>(this); }
            const TypeData& operator()() const
                { return *static_cast<const TypeData*>(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; /*####################################*/

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

        public   :
            typedef ZtCLink<TTypBase, ZCEmpty> TypeThis ;
            typedef TTypBase /*+++++++++++++*/ TypeBase ;
            typedef ZCEmpty  /*+++++++++++++*/ TypeChild;
            typedef TypeBase /*+++++++++++++*/ TypeData ;
            typedef TypeThis /*+++++++++++++*/ TypeMain ;
            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); }
            TypeBase& operator()(){ return *static_cast<TypeBase*>(this); }

            const TypeBase& operator* () const
                { return *static_cast<const 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; /*####################################*/

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

        public   :
            typedef ZtCLink<ZCEmpty, TChild>  TypeThis ;
            typedef ZCEmpty   /*++++++++++*/  TypeBase ;
            typedef TChild    /*++++++++++*/  TypeChild;
            typedef TypeChild /*++++++++++*/  TypeData ;
            typedef TypeChild /*++++++++++*/  TypeMain ;
            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: /////////////////////////////////////////////

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

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

        protected: /////////////////////////////////////////////

            // 생성자와 복사 생성자를 protected 영역에 두어서,
            // 사용할 때에, 상속 클래스를 만드는 것을 강제한다.

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

        public   : /////////////////////////////////////////////

            virtual ~ZtCLink<ZCEmpty, TChild>()
            {
                /*/////////////////////////////////////////////

                ■  ZtCLink<ZCEmpty, TChild> 는 상속을 하려고
                    설계한 것이라, 소멸자를 virtual 로 만든다.
                    그러니까 아래 코드처럼 작성해야 할 때가 있
                    을 것이다.

                        TypeThis* myp = new TypeChild;

                        // some code

                        delete myp;

                      -- 2025-10-07 16:31

                /////////////////////////////////////////////*/
            }/*
            virtual ~ZtCLink<ZCEmpty, TChild>()*/


            TypeThis& operator=(const TypeThis& rhs)
            {
                this->GetChildObj() = rhs.GetChildObj();  return *this;
            }/*
            TypeThis& operator=(const TypeThis& rhs)*/


            TypeData& operator* ()      { return GetChildObj(); }
            TypeData& operator()()      { return GetChildObj(); }

            const TypeData& operator* () const{ return GetChildObj(); }
            const TypeData& operator()() const{ return GetChildObj(); }


            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   :

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

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

        public   :
            typedef ZtCLink<ZCEmpty, ZCEmpty> TypeThis ;
            typedef ZCEmpty  /*++++++++++++*/ TypeBase ;
            typedef ZCEmpty  /*++++++++++++*/ TypeChild;
            typedef TypeThis /*++++++++++++*/ TypeData ;
            typedef TypeThis /*++++++++++++*/ TypeMain ;
            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)*/


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

            const TypeThis& operator* () const{ 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<> class ZtCLink<ZCEmpty, ZCEmpty>*/

    }/*
    namespace ZNsIFaceEx*/



    template //////////////////////////////////////////////////////////////////
        <
            typename TCLink
          , typename TTypSize  = ZTypLong
          , typename TTypeCRTP =
                ZNsType::ZtCTypeCRTP<ZCEmpty, false>
        >
    class ZtCLinkList /*#####################################################*/
    {
    public :
        class ZCNodePoint; class ZCNodePointN;
    public :
        typedef ZtCLinkList     TypeThis  ;
        typedef ZtCLinkList     TypeList  ;
    public :
        typedef ZNsType::ZtCTypeNowCRTP ///////////////////////////////////////
            <
                TypeThis, typename TTypeCRTP::TypeData, TTypeCRTP::ZEUseCRTP
            >
        ZCTypeNowCRTP ; ///////////////////////////////////////////////////////

        typedef typename ZCTypeNowCRTP::TypeData TypeChild;
    /*************************************************************************/
        typedef typename TCLink::TypeData TypeDataCore ;
        typedef const TypeDataCore        TypeDataCoreC;
    /*/////////////////////////////////////////////////////////////////////////

    ■  TCLink::TypeData (TypeDataCore)

        TCLink 에 상속 클래스 자료형이 지정되어 있다면 그 상속 클래스.
        TCLink 에 기반 클래스 자료형만 지정되어 있다면 그 기반 클래스.

        ItD()  에서 TypeDataCore 을 사용한다. -- 2025-10-15 13:16

    /////////////////////////////////////////////////////////////////////////*/
    public :
        typedef ZtCObjOpt<TCLink> ZCDataOpt;
        typedef ZtCObjOpt<TCLink> ZCLinkOpt;

        typedef TCLink          ZCLink    ;
        typedef TCLink          TypeData  ;
        typedef TCLink          TypeLink  ;
        typedef TCLink          TypeNode  ;
        typedef TTypSize        TypeSize  ;

        typedef ZCNodePoint     TypeIter  ;
        typedef ZCNodePointN    TypeIterN ;

        typedef const TCLink    ZCLinkC   ;
        typedef const TCLink    TypeDataC ;
        typedef const TCLink    TypeLinkC ;
        typedef const TypeThis  TypeThisC ;
        typedef const TypeThis  TypeListC ;
        typedef const TypeNode  TypeNodeC ;
        typedef const TypeIter  TypeIterC ;
        typedef const ZCLinkOpt ZCLinkOptC;
    /*************************************************************************/
        typedef TypeIter    iterator      ;
        typedef TypeIterN   const_iterator;

        typedef TypeIterN   iteratorN     ;
    /*************************************************************************/

    /*************************************************************************/
        typedef typename TCLink::TypeMain TypeMain;
    /**************************************************************************

    ZNsIFaceEx::ZtCLink 는 TypeMain 이라는 자료형을 갖는데, ZtCLink 이

        상속 클래스가 있다면, 그 상속 클래스
        상속 클래스가 없다면, 클래스 자기 자신

    를 나타낸다. 그래서 ZtCLinkList 에서 new 로 객체를 만들 때,

        ZtCLink* my = new TypeMain;

    처럼 쓸 수 있게 한다. -- 2025-10-07 17:49

    /////////////////////////////////////////////////////////////////////////*/
    private:
        ZCLink*  mp_HeadLink;
        ZCLink*  mp_TailLink;
        TypeSize ml_LinkSize;
    private:

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

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

    public:


        class ZCNodePoint
        {
        protected:
            /*****/ TypeList& mr_CurrList;
            mutable TypeLink* mp_CurrLink; // 사실상 mp_CurrLink!=0
            mutable TypeSize  ml_CurrPos ;
        public   :
            ZCNodePoint(TypeList& AR_TypeList) :
                mr_CurrList(AR_TypeList)
            {
                mp_CurrLink = AR_TypeList.HeadPtr();
                ml_CurrPos  = 1 ;
            }
            ZCNodePoint(const ZCNodePoint& rhs) :
                mr_CurrList(rhs.mr_CurrList),
                mp_CurrLink(rhs.mp_CurrLink),
                ml_CurrPos (rhs.ml_CurrPos )
            {}
        public   :

            static ZCNodePoint MakeTailPoint(TypeList&  AR_TypeList)
            {
                ZCNodePoint VO_ZCLinkPoint(AR_TypeList);

                VO_ZCLinkPoint.mp_CurrLink = AR_TypeList.mp_TailLink;
                VO_ZCLinkPoint.ml_CurrPos  = AR_TypeList.ml_LinkSize;

                return VO_ZCLinkPoint; /****************************/
            }/*
            static ZCNodePoint MakeTailPoint(TypeList&  AR_TypeList)*/
            static ZCNodePoint MakeTailPoint(const TypeIter& AR_TypeIter)
            {
                ZCNodePoint VO_ZCLinkPoint(AR_TypeIter);

                VO_ZCLinkPoint.mp_CurrLink = VO_ZCLinkPoint.mr_TypeList.mp_TailLink;
                VO_ZCLinkPoint.ml_CurrPos  = VO_ZCLinkPoint.mr_TypeList.ml_LinkSize;

                return VO_ZCLinkPoint; /****************************/
            }/*
            static ZCNodePoint MakeTailPoint(const TypeIter& AR_TypeIter)*/

        public   :

            TypeThis & GetMain()      {return  mr_CurrList;}
            TypeNode & GetNode()      {return *mp_CurrLink;}

            TypeThisC& GetMain() const{return  mr_CurrList;}
            TypeNodeC& GetNode() const{return *mp_CurrLink;}
            /***************************************************/
            TypeSize   GetPos () const{return  ml_CurrPos ;}
            /***************************************************/


            bool IsValid() const{return mr_CurrList.size()>0;}
            bool IsEmpty() const{return mr_CurrList.size()<1;}


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


            TypeData & operator*()      {return **mp_CurrLink;}
            TypeDataC& operator*() const{return **mp_CurrLink;}

            operator TypeLink * ()      {return   mp_CurrLink;}
            operator TypeLinkC* () const{return   mp_CurrLink;}

            operator TypeLink & ()      {return  *mp_CurrLink;}
            operator TypeLinkC& () const{return  *mp_CurrLink;}


            bool operator == (const ZCNodePoint& rhs) const
              { return ml_CurrPos == rhs.ml_CurrPos; }
            bool operator != (const ZCNodePoint& rhs) const
              { return ml_CurrPos != rhs.ml_CurrPos; }
            bool operator >  (const ZCNodePoint& rhs) const
              { return ml_CurrPos >  rhs.ml_CurrPos; }
            bool operator >= (const ZCNodePoint& rhs) const
              { return ml_CurrPos >= rhs.ml_CurrPos; }
            bool operator <  (const ZCNodePoint& rhs) const
              { return ml_CurrPos <  rhs.ml_CurrPos; }
            bool operator <= (const ZCNodePoint& rhs) const
              { return ml_CurrPos <= rhs.ml_CurrPos; }

            bool operator == (TypeSize AL_Size) const
              { return ml_CurrPos == AL_Size; }
            bool operator != (TypeSize AL_Size) const
              { return ml_CurrPos != AL_Size; }
            bool operator >  (TypeSize AL_Size) const
              { return ml_CurrPos >  AL_Size; }
            bool operator >= (TypeSize AL_Size) const
              { return ml_CurrPos >= AL_Size; }
            bool operator <  (TypeSize AL_Size) const
              { return ml_CurrPos <  AL_Size; }
            bool operator <= (TypeSize AL_Size) const
              { return ml_CurrPos <= AL_Size; }


            const ZCNodePoint& operator++() const
            {
                mp_CurrLink = mp_CurrLink->mp_NextLink;

                ++ml_CurrPos;  return *this           ;
            }/*
            const ZCNodePoint& operator++() const*/

            const ZCNodePoint& operator--() const
            {
                mp_CurrLink = mp_CurrLink->mp_PrevLink;

                --ml_CurrPos;  return *this           ;
            }/*
            const ZCNodePoint& operator--() const*/

            ZCNodePoint  operator++(int) const
            {
                ZCNodePoint VO_NowPoint(*this);

                mp_CurrLink = mp_CurrLink->mp_NextLink;

                ++ml_CurrPos ;  return VO_NowPoint    ;
            }/*
            ZCNodePoint  operator++(int) const*/

            ZCNodePoint  operator--(int) const
            {
                ZCNodePoint VO_NowPoint(*this);

                mp_CurrLink = mp_CurrLink->mp_PrevLink;

                --ml_CurrPos;  return VO_NowPoint     ;
            }/*
            ZCNodePoint  operator--(int) const*/


            const ZCNodePoint& operator+=(TypeSize AL_Distance) const
            {
                if(IsEmpty()){return *this;}

                mp_CurrLink = &((*mp_CurrLink)+AL_Distance) ;
                ml_CurrPos += AL_Distance                   ;

                return *this; /*:::::::::::::::::::::::::::*/
            }/*
            const ZCNodePoint& operator+=(TypeSize AL_Distance) const*/

            const ZCNodePoint& operator-=(TypeSize AL_Distance) const
            {
                mp_CurrLink = &((*mp_CurrLink)-AL_Distance);
                ml_CurrPos -= AL_Distance                  ;

                return *this; /*::::::::::::::::::::::::::*/
            }/*
            const ZCNodePoint& operator-=(TypeSize AL_Distance) const*/

        public:
        };/*
        class ZCNodePoint*/


        class ZCNodePointN
        {
        protected:
            const   TypeList&  mr_CurrList;
            mutable TypeLinkC* mp_CurrLink; // 사실상 mp_CurrLink!=0
            mutable TypeSize   ml_CurrPos ;
        public   :
            ZCNodePointN(const TypeList& AR_TypeList) :
                mr_CurrList(AR_TypeList)
            {
                mp_CurrLink = AR_TypeList.HeadPtr();
                ml_CurrPos  = 1 ;
            }
            ZCNodePointN(const ZCNodePoint & rhs) :
                mr_CurrList( rhs.GetMain()),
                mp_CurrLink(&rhs.GetNode()),
                ml_CurrPos ( rhs.GetPos ())
            {}
            ZCNodePointN(const ZCNodePointN& rhs) :
                mr_CurrList(rhs.mr_CurrList),
                mp_CurrLink(rhs.mp_CurrLink),
                ml_CurrPos (rhs.ml_CurrPos )
            {}
        public   :

            static ZCNodePointN MakeTailPoint(const TypeList& AR_TypeList)
            {
                ZCNodePointN VO_ZCLinkPoint(AR_TypeList);

                VO_ZCLinkPoint.mp_CurrLink = AR_TypeList.mp_TailLink;
                VO_ZCLinkPoint.ml_CurrPos  = AR_TypeList.ml_LinkSize;

                return VO_ZCLinkPoint; /****************/
            }/*
            static ZCNodePointN MakeTailPoint(const TypeList&  AR_TypeList)*/
            static ZCNodePointN MakeTailPoint(const ZCNodePoint& AR_TypeIter)
            {
                ZCNodePointN VO_ZCLinkPoint(AR_TypeIter);

                VO_ZCLinkPoint.mp_CurrLink = VO_ZCLinkPoint.mr_TypeList.mp_TailLink;
                VO_ZCLinkPoint.ml_CurrPos  = VO_ZCLinkPoint.mr_TypeList.ml_LinkSize;

                return VO_ZCLinkPoint; /****************/
            }/*
            static ZCNodePointN MakeTailPoint(const ZCNodePoint& AR_TypeIter)*/
            static ZCNodePointN MakeTailPoint(const ZCNodePointN& AR_TypeIter)
            {
                ZCNodePointN VO_ZCLinkPoint(AR_TypeIter);

                VO_ZCLinkPoint.mp_CurrLink = VO_ZCLinkPoint.mr_TypeList.mp_TailLink;
                VO_ZCLinkPoint.ml_CurrPos  = VO_ZCLinkPoint.mr_TypeList.ml_LinkSize;

                return VO_ZCLinkPoint; /****************/
            }/*
            static ZCNodePointN MakeTailPoint(const ZCNodePointN& AR_TypeIter)*/

        public   :

            TypeThisC& GetMain() const{return  mr_CurrList;}
            TypeNodeC& GetNode() const{return *mp_CurrLink;}
            /***************************************************/
            TypeSize   GetPos () const{return  ml_CurrPos ;}
            /***************************************************/


            bool IsValid() const{return mr_CurrList.size()>0;}
            bool IsEmpty() const{return mr_CurrList.size()<1;}


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

            TypeDataC& operator*() const{return **mp_CurrLink;}
            operator TypeNodeC* () const{return   mp_CurrLink;}
            operator TypeNodeC& () const{return  *mp_CurrLink;}
            operator TypeNode * () const{return  0           ;}


            bool operator == (const ZCNodePointN& rhs) const
              { return ml_CurrPos == rhs.ml_CurrPos; }
            bool operator != (const ZCNodePointN& rhs) const
              { return ml_CurrPos != rhs.ml_CurrPos; }
            bool operator >  (const ZCNodePointN& rhs) const
              { return ml_CurrPos >  rhs.ml_CurrPos; }
            bool operator >= (const ZCNodePointN& rhs) const
              { return ml_CurrPos >= rhs.ml_CurrPos; }
            bool operator <  (const ZCNodePointN& rhs) const
              { return ml_CurrPos <  rhs.ml_CurrPos; }
            bool operator <= (const ZCNodePointN& rhs) const
              { return ml_CurrPos <= rhs.ml_CurrPos; }

            bool operator == (TypeSize AL_Size) const
              { return ml_CurrPos == AL_Size; }
            bool operator != (TypeSize AL_Size) const
              { return ml_CurrPos != AL_Size; }
            bool operator >  (TypeSize AL_Size) const
              { return ml_CurrPos >  AL_Size; }
            bool operator >= (TypeSize AL_Size) const
              { return ml_CurrPos >= AL_Size; }
            bool operator <  (TypeSize AL_Size) const
              { return ml_CurrPos <  AL_Size; }
            bool operator <= (TypeSize AL_Size) const
              { return ml_CurrPos <= AL_Size; }


            const ZCNodePointN& operator++() const
            {
                mp_CurrLink = mp_CurrLink->mp_NextLink;

                ++ml_CurrPos;  return *this           ;
            }/*
            const ZCNodePointN& operator++() const*/

            const ZCNodePointN& operator--() const
            {
                mp_CurrLink = mp_CurrLink->mp_PrevLink;

                --ml_CurrPos;  return *this           ;
            }/*
            const ZCNodePointN& operator--() const*/

            ZCNodePointN  operator++(int) const
            {
                ZCNodePointN VO_NowPoint(*this);

                mp_CurrLink = mp_CurrLink->mp_NextLink;

                ++ml_CurrPos ;  return VO_NowPoint    ;
            }/*
            ZCNodePointN  operator++(int) const*/

            ZCNodePointN  operator--(int) const
            {
                ZCNodePointN VO_NowPoint(*this);

                mp_CurrLink = mp_CurrLink->mp_PrevLink;

                --ml_CurrPos;  return VO_NowPoint     ;
            }/*
            ZCNodePointN  operator--(int) const*/


            const ZCNodePointN& operator+=(TypeSize AL_Distance) const
            {
                if(IsEmpty()){return *this;}

                mp_CurrLink = &((*mp_CurrLink)+AL_Distance) ;
                ml_CurrPos += AL_Distance                   ;

                return *this; /*:::::::::::::::::::::::::::*/
            }/*
            const ZCNodePointN& operator+=(TypeSize AL_Distance) const*/

            const ZCNodePointN& operator-=(TypeSize AL_Distance) const
            {
                mp_CurrLink = &((*mp_CurrLink)-AL_Distance);
                ml_CurrPos -= AL_Distance                  ;

                return *this; /*::::::::::::::::::::::::::*/
            }/*
            const ZCNodePointN& operator-=(TypeSize AL_Distance) const*/

        public:
        };/*
        class ZCNodePointN*/


    public:
        /*############################################################*/
    private:

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

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

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

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

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

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

                VP_MakeLink = new TypeMain;

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


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

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

            VP_TailLink  = VP_MakeLink =
                new TypeMain(*AP_LinkOrgin) ;

            APR_HeadCopy = VP_MakeLink;

            while(--AL_FarNum >= 0)
            {
                AP_LinkOrgin= AP_LinkOrgin->GetNextPtr() ;
                VP_MakeLink = new TypeMain(*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
            )   const
        ///////////////////////////////////////////////////*/


        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() const
        {
            if(TTypeCRTP::ZEUseCRTP<1) return NewLink();

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

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

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

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

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

        _VT_ void SendFreeOut
            (TypeSize AL_NeedCnt, ZCLink*& APR_HeadLink, ZCLink*& APR_TailLink) const
        {
            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) const
        */

        _VT_ void SendFreeOutCopy /*///////////////////////*/
            (
                ZCLink*  AP_LinkOrgin, TypeSize AL_FarNum   ,
                ZCLink*& APR_HeadCopy, ZCLink*& APR_TailCopy
            )   const
        /////////////////////////////////////////////////////
        {
            // 총 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
            )   const
        ///////////////////////////////////////////////////*/


        _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_StdLink)
        {
            // AR_LinkNew 를 AP_StdLink 뒤에 삽입한다.
            // AL_PosStd==0 이면 맨 앞에 삽입한다.

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

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

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

            ++ml_LinkSize;  return AR_LinkNew;
        }/*
        ZCLink& JoinAfter(ZCLink& AR_LinkNew, ZCLink* AP_StdLink)*/


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

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

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

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

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


        TypeThis& JoinAfter(TypeThis& 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 ;
                }
                else // ml_LinkSize>=1
                {
                    ZCLink::JoinLink( rhs.mp_TailLink, mp_HeadLink );
                    ZCLink::MakeRing( rhs.mp_HeadLink, mp_TailLink );

                    mp_HeadLink = rhs.mp_HeadLink ;
                }/*
                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;
        }/*
        TypeThis& JoinAfter(TypeThis& rhs, ZCLink* AP_StdLink)*/


        TypeThis& JoinBefore(TypeThis& 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 ;
                }
                else // ml_LinkSize>=1
                {
                    ZCLink::JoinLink(mp_TailLink, rhs.mp_HeadLink);
                    ZCLink::MakeRing(mp_HeadLink, rhs.mp_TailLink);

                    mp_TailLink  = rhs.mp_TailLink ;
                }/*
                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_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;
        }/*
        TypeThis& JoinBefore(TypeThis& rhs, ZCLink* AP_StdLink)*/


        ZCLink* AddLinkAfter(ZCLink* AP_StdLink, ZCLink* AP_NewLink)
          { return &JoinAfter(*AP_NewLink, AP_StdLink); }

        ZCLink* AddLinkBefore(ZCLink* AP_StdLink, ZCLink* AP_NewLink)
          { return &JoinBefore(*AP_NewLink, 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)*/

        ZCLink* CutLink(ZCLink* AP_CutLink){return &CutLink(*AP_CutLink);}


        TypeThis& CutLinkRangeOut  /*##########################################*/
            (
                ZCLink&  AR_CutHead , ZCLink&   AR_CutTail ,
                TypeSize AL_CutSize , TypeThis& rhs        ,
                ZCLink*  AP_RhsStd  , bool      AB_After=true
            )
        /*#####################################################################*/
        {
            /*///////////////////////////////////////////////////////////

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

                AR_CutHead 의 앞과 AR_CutTail 의 뒤에서 연결 상태를 끊고,
                rhs 의 AP_RhsStd 의 뒤에 삽입한다.

                AP_RhsStd==0 이면 맨 앞에 삽입한다.  -- 2025-10-06 09:16

            ■  bool AB_After=true 추가 -- 2025-10-07 09:37

                AB_After==true  이면, AP_RhsStd 의 뒤에 연결.
                AB_After==false 이면, AP_RhsStd 의 앞에 연결.

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

            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)
            {
                ZCLink::MakeRing(&AR_CutHead, &AR_CutTail);

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

                    rhs.mp_HeadLink = &AR_CutHead;
                }
                else
                {
                    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 // !AB_After : AP_RhsStd 앞에 삽입.
            {
                if(AP_RhsStd==0) // 맨 뒤에 삽입.
                {
                    ZCLink::JoinLink(rhs.mp_TailLink, &AR_CutHead);
                    ZCLink::MakeRing(rhs.mp_HeadLink, &AR_CutTail);

                    rhs.mp_TailLink = &AR_CutTail;
                }
                else
                {
                    ZCLink* VP_RhsStdPrev = AP_RhsStd->mp_PrevLink ;

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

                    if(AP_RhsStd==rhs.mp_HeadLink)
                        { rhs.mp_HeadLink = &AR_CutHead; }
                }
            }/*
            else // !AB_After : AP_RhsStd 앞에 삽입.*/

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


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


        TypeThis& operator=(const TypeThis& 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)
            {
                ZCLink* VP_CutTail =
                    mp_HeadLink->GetNextPrevPtr(VL_MinusSize-1);
                ZCLink* VP_CutTailNext = VP_CutTail->mp_NextLink ;

                RecvFreeIn ////////////////////////////////////////
                    (
                        VL_MinusSize, mp_HeadLink, VP_CutTail
                    );
                ///////////////////////////////////////////////////

                mp_HeadLink  = VP_CutTailNext;
                ml_LinkSize -= VL_MinusSize  ;

                ZCLink::MakeRing(mp_HeadLink, mp_TailLink);
            }
            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, mp_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;
        }/*
        TypeThis& operator=(const TypeThis& rhs)*/


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

        bool     IsEmpty() const{return ml_LinkSize<1;}
        bool     empty  () 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();}


        ZCLink * GetHeadLinkPtr()      {return mp_HeadLink;}
        ZCLink * GetTailLinkPtr()      {return mp_TailLink;}

        ZCLinkC* GetHeadLinkPtr() const{return mp_HeadLink;}
        ZCLinkC* GetTailLinkPtr() const{return mp_TailLink;}

        ZCLink * GetLinkPtr(TypeSize AI_Index)      {return mp_HeadLink->GetNextPrevPtr(AI_Index-1);}
        ZCLinkC* GetLinkPtr(TypeSize AI_Index) const{return mp_HeadLink->GetNextPrevPtr(AI_Index-1);}


        ZCLink & GetHeadLink(TypeSize AI_Distance)      {return (*mp_HeadLink)+AI_Distance;}
        ZCLink & GetTailLink(TypeSize AI_Distance)      {return (*mp_TailLink)-AI_Distance;}

        ZCLinkC& GetHeadLink(TypeSize AI_Distance) const{return (*mp_HeadLink)+AI_Distance;}
        ZCLinkC& GetTailLink(TypeSize AI_Distance) const{return (*mp_TailLink)-AI_Distance;}


        ZCLink & GetNode(TypeSize AI_Index)      {return (*mp_HeadLink)+(AI_Index-1);}
        ZCLinkC& GetNode(TypeSize AI_Index) const{return (*mp_HeadLink)+(AI_Index-1);}


        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 & HeadRef()      {return *mp_HeadLink;}
        ZCLink & TailRef()      {return *mp_TailLink;}
        ZCLinkC& HeadRef() const{return *mp_HeadLink;}
        ZCLinkC& TailRef() const{return *mp_TailLink;}

        ZCLink & HeadRef(TypeSize AI_Distance)      {return (*mp_HeadLink)+AI_Distance;}
        ZCLink & TailRef(TypeSize AI_Distance)      {return (*mp_TailLink)-AI_Distance;}
        ZCLinkC& HeadRef(TypeSize AI_Distance) const{return (*mp_HeadLink)+AI_Distance;}
        ZCLinkC& TailRef(TypeSize AI_Distance) const{return (*mp_TailLink)-AI_Distance;}


        ZCLinkOpt  HeadOpt()      {return ZCLinkOpt(mp_HeadLink);}
        ZCLinkOpt  TailOpt()      {return ZCLinkOpt(mp_TailLink);}

        ZCLinkOptC HeadOpt() const{return ZCLinkOpt(mp_HeadLink);}
        ZCLinkOptC TailOpt() const{return ZCLinkOpt(mp_TailLink);}

        ZCLinkOpt  HeadOpt(TypeSize AI_Distance)
            {if(mp_HeadLink==0){return ZCLinkOpt(0);} return ZCLinkOpt((*mp_HeadLink)+AI_Distance);}
        ZCLinkOpt  TailOpt(TypeSize AI_Distance)
            {if(mp_TailLink==0){return ZCLinkOpt(0);} return ZCLinkOpt((*mp_TailLink)-AI_Distance);}

        ZCLinkOptC HeadOpt(TypeSize AI_Distance) const
            {if(mp_HeadLink==0){return ZCLinkOpt(0);} return ZCLinkOpt((*mp_HeadLink)+AI_Distance);}
        ZCLinkOptC TailOpt(TypeSize AI_Distance) const
            {if(mp_TailLink==0){return ZCLinkOpt(0);} return ZCLinkOpt((*mp_TailLink)-AI_Distance);}



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


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

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


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

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

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

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


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

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

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


        TypeThis& SendRangeOut //////////////////////////////////////////////////
            (
                ZCLink&   AR_CutHead, ZCLink&   AR_CutTail,
                TypeSize  AI_CutSize, TypeThis& rhs       ,
                ZCLinkOpt AO_LinkOpt, bool      AB_After
            )
        /*#####################################################################*/
        {
            return CutLinkRangeOut
                (
                    AR_CutHead, AR_CutTail      , AI_CutSize,
                    rhs       , AO_LinkOpt.Raw(), AB_After
                );
            //////////////////////
        }/*
        TypeThis& SendRangeOutAfter /////////////////////////////////////////////
            (
                ZCLink&   AR_CutHead, ZCLink&   AR_CutTail,
                TypeSize  AI_CutSize, TypeThis& rhs       ,
                ZCLinkOpt AO_LinkOpt, bool      AB_After
            )
        #######################################################################*/


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

            return CutLinkRangeOut
                (
                    AR_CutHead, AR_CutTail      , AI_CutSize,
                    rhs       , AO_LinkOpt.Raw(), true
                );
            //////////////////////
        }
        TypeThis& SendRangeOutBefore ////////////////////////////////////////////
            (
                ZCLink&  AR_CutHead, ZCLink&   AR_CutTail,
                TypeSize AI_CutSize, TypeThis& rhs       , ZCLinkOpt AO_LinkOpt
            )
        /*#####################################################################*/
        {
            // AR_CutHead 부터 AR_CutTail 까지를 잘라서 rhs 의 AR_StdLink 앞에 연결한다.

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


        TypeThis& SwapLinkNext(ZCLink& AR_LinkPrev)
        {
            // 다음 링크와 위치를 맞바꾼다.

            if(size()<=1){return *this;}


            ZCLink* VP_LinkNext = AR_LinkPrev.mp_NextLink;

            if(&AR_LinkPrev == VP_LinkNext){ return *this; }

            if(size()==2)
            {
                if(&AR_LinkPrev==mp_HeadLink) /*************************/
                {
                    // VP_LinkNext==mp_TailLink

                    mp_HeadLink = VP_LinkNext ;
                    mp_TailLink = &AR_LinkPrev;
                }
                /*:::::::::::::::::::::::::::::::::::::::::::::::::::::*/

                else // VP_LinkNext==mp_HeadLink
                {
                    mp_HeadLink = &AR_LinkPrev ;
                    mp_TailLink =  VP_LinkNext ;
                }
                /*:::::::::::::::::::::::::::::::::::::::::::::::::::::*/
            }
            else if(&AR_LinkPrev==mp_HeadLink)
            {
                // VP_LinkNext == mp_HeadLink.mp_NextLink;

                ZCLink* VP_HeadNext2 =
                    VP_LinkNext->mp_NextLink ;

                ZCLink::JoinLink(VP_LinkNext , &AR_LinkPrev);
                ZCLink::JoinLink(&AR_LinkPrev, VP_HeadNext2);
                ZCLink::MakeRing(VP_LinkNext , mp_TailLink );

                mp_HeadLink = VP_LinkNext ;
            }
            else if(&AR_LinkPrev==mp_TailLink)
            {
                // VP_LinkNext==mp_HeadLink

                ZCLink* VP_HeadNext =
                    mp_HeadLink->mp_NextLink ;
                ZCLink* VP_TailPrev =
                    mp_TailLink->mp_PrevLink ;

                ZCLink::JoinLink(mp_TailLink, VP_HeadNext);
                ZCLink::JoinLink(VP_TailPrev, mp_HeadLink);
                ZCLink::MakeRing(mp_TailLink, mp_HeadLink);

                mp_HeadLink = &AR_LinkPrev ;
                mp_TailLink =  VP_LinkNext ;
            }
            else if(VP_LinkNext==mp_TailLink)
            {
                ZCLink* VP_TailPrev2 =
                    AR_LinkPrev.mp_PrevLink ;

                ZCLink::JoinLink(VP_TailPrev2,  VP_LinkNext );
                ZCLink::JoinLink(VP_LinkNext , &AR_LinkPrev );
                ZCLink::MakeRing(mp_HeadLink , &AR_LinkPrev );

                mp_TailLink = &AR_LinkPrev ;
            }
            else
            {
                ZCLink* VP_SwapPrev = AR_LinkPrev. mp_PrevLink;
                ZCLink* VP_SwapNext = VP_LinkNext->mp_NextLink;

                ZCLink::JoinLink(VP_SwapPrev ,  VP_LinkNext ) ;
                ZCLink::JoinLink(VP_LinkNext , &AR_LinkPrev ) ;
                ZCLink::JoinLink(&AR_LinkPrev,  VP_SwapNext ) ;
            }
            return *this; /***********************************/
        }/*
        TypeThis& SwapLinkNext(ZCLink& AR_LinkPrev)*/

        TypeThis& SwapLinkPrev(ZCLink& AR_LinkNext)
        {
            // 이전 링크와 위치를 맞바꾼다.

            return SwapLinkNext(*AR_LinkNext.mp_PrevLink);
        }/*
        TypeThis& SwapLinkPrev(ZCLink& AR_LinkNext)*/


        TypeThis& SwapLink(ZCLink& AR_LinkOne, ZCLink& AR_LinkTwo)
        {
            // AR_LinkOne 와 AR_LinkTwo 의 위치를 바꾼다.

            if(size()<=1){return *this;}

            if(&AR_LinkOne==&AR_LinkTwo){return *this;}

            if(&AR_LinkOne==mp_HeadLink && &AR_LinkTwo==mp_TailLink)
                { return SwapLinkNext(AR_LinkTwo); }
            if(&AR_LinkOne==mp_TailLink && &AR_LinkTwo==mp_HeadLink)
                { return SwapLinkNext(AR_LinkOne); }
            /******************************************************/
            if(&AR_LinkTwo==AR_LinkOne.mp_NextLink)
                { return SwapLinkNext(AR_LinkOne); }
            if(&AR_LinkOne==AR_LinkTwo.mp_NextLink)
                { return SwapLinkNext(AR_LinkTwo); }
            /******************************************************/

            if(&AR_LinkOne==mp_HeadLink)
            {
                ZCLink* VP_HeadNext=mp_HeadLink->mp_NextLink;
                ZCLink* VP_TwoNext =AR_LinkTwo.  mp_NextLink;
                ZCLink* VP_TwoPrev =AR_LinkTwo.  mp_PrevLink;

                ZCLink::JoinLink(&AR_LinkTwo,  VP_HeadNext) ;
                ZCLink::JoinLink( VP_TwoPrev, &AR_LinkOne ) ;
                ZCLink::JoinLink(&AR_LinkOne,  VP_TwoNext ) ;
                ZCLink::MakeRing(&AR_LinkTwo,  mp_TailLink) ;

                mp_HeadLink = &AR_LinkTwo ; return *this;
            }
            if(&AR_LinkOne==mp_TailLink)
            {
                ZCLink* VP_TailPrev= mp_TailLink->mp_PrevLink;
                ZCLink* VP_TwoNext = AR_LinkTwo.  mp_NextLink;
                ZCLink* VP_TwoPrev = AR_LinkTwo.  mp_PrevLink;

                ZCLink::JoinLink( VP_TwoPrev , &AR_LinkOne ) ;
                ZCLink::JoinLink(&AR_LinkOne ,  VP_TwoNext ) ;
                ZCLink::JoinLink( VP_TailPrev, &AR_LinkTwo ) ;
                ZCLink::MakeRing( mp_HeadLink, &AR_LinkTwo ) ;

                mp_TailLink = &AR_LinkTwo ; return *this;
            }
            /******************************************************/
            if(&AR_LinkTwo==mp_HeadLink)
            {
                ZCLink* VP_HeadNext=mp_HeadLink->mp_NextLink;
                ZCLink* VP_OneNext =AR_LinkOne.  mp_NextLink;
                ZCLink* VP_OnePrev =AR_LinkOne.  mp_PrevLink;

                ZCLink::JoinLink(&AR_LinkTwo,  VP_HeadNext) ;
                ZCLink::JoinLink( VP_OnePrev, &AR_LinkOne ) ;
                ZCLink::JoinLink(&AR_LinkOne,  VP_OneNext ) ;
                ZCLink::MakeRing(&AR_LinkTwo,  mp_TailLink) ;

                mp_HeadLink = &AR_LinkTwo ; return *this;
            }
            if(&AR_LinkTwo==mp_TailLink)
            {
                ZCLink* VP_TailPrev=mp_TailLink->mp_PrevLink;
                ZCLink* VP_OneNext =AR_LinkOne.  mp_NextLink;
                ZCLink* VP_OnePrev =AR_LinkOne.  mp_PrevLink;

                ZCLink::JoinLink( VP_OnePrev , &AR_LinkTwo ) ;
                ZCLink::JoinLink(&AR_LinkTwo,   VP_OneNext ) ;
                ZCLink::JoinLink( VP_TailPrev, &AR_LinkTwo ) ;
                ZCLink::MakeRing( mp_HeadLink, &AR_LinkTwo ) ;

                mp_TailLink = &AR_LinkTwo ; return *this;
            }
            /********************************************************/

            ZCLink* VP_OnePrev= AR_LinkOne.mp_PrevLink ;
            ZCLink* VP_OneNext= AR_LinkOne.mp_NextLink ;
            ZCLink* VP_TwoPrev= AR_LinkTwo.mp_PrevLink ;
            ZCLink* VP_TwoNext= AR_LinkTwo.mp_NextLink ;

            ZCLink::JoinLink( VP_OnePrev, &AR_LinkTwo) ;
            ZCLink::JoinLink(&AR_LinkTwo,  VP_OneNext) ;
            ZCLink::JoinLink( VP_TwoPrev, &AR_LinkOne) ;
            ZCLink::JoinLink(&AR_LinkOne,  VP_TwoNext) ; return *this;
        }/*
        TypeThis& SwapLink(ZCLink& AR_LinkOne, ZCLink& AR_LinkTwo)*/


        TypeThis& MoveLinkAfter (ZCLink& AR_MoveLink, ZCLinkOpt AO_StdOpt)
        {
            if(&AR_MoveLink==AO_StdOpt.Raw()){return *this;}

            if(size()<=1){return *this;}  AddLinkAfter
                ( AO_StdOpt.Raw(), CutLink(&AR_MoveLink) ) ;

            return *this; /**************************/
        }/*
        TypeThis& MoveLinkAfter (ZCLink& AR_MoveLink, ZCLinkOpt AO_StdOpt)*/
        TypeThis& MoveLinkBefore(ZCLink& AR_MoveLink, ZCLinkOpt AO_StdOpt)
        {
            if(&AR_MoveLink==AO_StdOpt.Raw()){return *this;}

            if(size()<=1){return *this;} AddLinkBefore
                ( AO_StdOpt.Raw(), CutLink(&AR_MoveLink) ) ;

            return *this; /**************************/
        }/*
        TypeThis& MoveLinkBefore(ZCLink& AR_MoveLink, ZCLinkOpt AO_StdOpt)*/

        TypeThis& MoveLinkHead(ZCLink& AR_MoveLink) /*::::::::::::::::::::*/
        {
            if(&AR_MoveLink==mp_HeadLink){return *this;}

            if(size()<=1){return *this;}  AddLinkAfter
                ( 0, CutLink(&AR_MoveLink) ) ;
            return *this; /**************************/
        }/*
        TypeThis& MoveLinkHead(ZCLink& AR_MoveLink) ::::::::::::::::::::::*/
        TypeThis& MoveLinkTail(ZCLink& AR_MoveLink) /*::::::::::::::::::::*/
        {
            if(&AR_MoveLink==mp_TailLink){return *this;}

            if(size()<=1){return *this;} AddLinkBefore
                ( 0, CutLink(&AR_MoveLink) ) ;
            return *this; /**************************/
        }/*
        TypeThis& MoveLinkTail(ZCLink& AR_MoveLink) ::::::::::::::::::::::*/


        TypeThis& SendRangeIn ///////////////////////////////////////////////////
            (
                ZCLink&   AR_CutHead, ZCLink&   AR_CutTail,
                TypeSize  AI_CutSize, ZCLinkOpt AO_LinkOpt, bool AB_After
            )
        /*#####################################################################*/
        {
            // AR_CutHead 부터 AR_CutTail 까지를 잘라서 AR_StdLink 뒤에 연결한다.

            if(AI_CutSize <  1     ){return *this;}
            if(AI_CutSize >= size()){return *this;}

            TypeThis VO_Saver; CutLinkRangeOut /**************/
                (
                    AR_CutHead  , AR_CutTail      , AI_CutSize,
                    RR(VO_Saver), AO_LinkOpt.Raw(), AB_After
                );
            /*************************************************/

            if(AB_After)
                  return JoinAfter (VO_Saver, AO_LinkOpt);
            else  return JoinBefore(VO_Saver, AO_LinkOpt);
        }
        /*#####################################################################*/

        TypeThis& SendRangeInAfter //////////////////////////////////////////////
            (
                ZCLink&   AR_CutHead, ZCLink&   AR_CutTail,
                TypeSize  AI_CutSize, ZCLinkOpt AO_LinkOpt
            )
        /*#####################################################################*/
        {
            return SendRangeIn
                ( AR_CutHead, AR_CutTail, AI_CutSize, AO_LinkOpt, true );
        }
        /*#####################################################################*/
        TypeThis& SendRangeInBefore /////////////////////////////////////////////
            (
                ZCLink&   AR_CutHead, ZCLink&   AR_CutTail,
                TypeSize  AI_CutSize, ZCLinkOpt AO_LinkOpt
            )
        /*#####################################################################*/
        {
            return SendRangeIn
                ( AR_CutHead, AR_CutTail, AI_CutSize, AO_LinkOpt, false);
        }
        /*#####################################################################*/

        TypeThis& SendRangeInHead ///////////////////////////////////////////////
            (
                ZCLink&   AR_CutHead, ZCLink&   AR_CutTail,
                TypeSize  AI_CutSize, ZCLinkOpt AO_LinkOpt
            )
        /*#####################################################################*/
        {
            return SendRangeIn
                ( AR_CutHead, AR_CutTail, AI_CutSize, ZCLinkOpt(0), true );
        }
        /*#####################################################################*/
        TypeThis& SendRangeInTail ///////////////////////////////////////////////
            (
                ZCLink&   AR_CutHead, ZCLink&   AR_CutTail,
                TypeSize  AI_CutSize, ZCLinkOpt AO_LinkOpt
            )
        /*#####################################################################*/
        {
            return SendRangeIn
                ( AR_CutHead, AR_CutTail, AI_CutSize, ZCLinkOpt(0), false);
        }
        /*#####################################################################*/


        TypeThis& CopyThis(TypeThis& ARR_Rhs) const
        {
            // *this 를 복사해서, ARR_Rhs 의 끝에 연결한다.

            if(size()<1) return ARR_Rhs;

            ZCLink* VP_HeadCopy=0;
            ZCLink* VP_TailCopy=0;

            SendFreeOutCopy ////////////////////////
                (
                    mp_HeadLink    , size()-1,
                    RR(VP_HeadCopy), RR(VP_TailCopy)
                );
            ////////////////////////////////////////

            TypeThis VO_TempList;

            VO_TempList.mp_HeadLink= VP_HeadCopy;
            VO_TempList.mp_TailLink= VP_TailCopy;
            VO_TempList.ml_LinkSize= size()     ;

            return ARR_Rhs.JoinTail(VO_TempList);
        }/*
        TypeThis& CopyThis(TypeThis& ARR_Rhs) const*/


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


        IterEasyID  GetHeadIterEasyID ()      {return (IterEasyID) GetHeadLinkPtr();}
        IterEasyID  GetTailIterEasyID ()      {return (IterEasyID) GetTailLinkPtr();}

        IterEasyIDc GetHeadIterEasyID () const{return (IterEasyIDc)GetHeadLinkPtr();}
        IterEasyIDc GetTailIterEasyID () const{return (IterEasyIDc)GetTailLinkPtr();}

        IterEasyIDc GetHeadIterEasyIDc() const{return (IterEasyIDc)GetHeadLinkPtr();}
        IterEasyIDc GetTailIterEasyIDc() const{return (IterEasyIDc)GetTailLinkPtr();}


        iterator    begin  ()      { return ZCNodePoint (*this); }
        iteratorN   begin  () const{ return ZCNodePointN(*this); }
        iterator    end    ()      { return ZCNodePoint ::MakeTailPoint(*this); }
        iteratorN   end    () const{ return ZCNodePointN::MakeTailPoint(*this); }

        iteratorN   cbegin () const{ return ZCNodePointN(*this); }
        iteratorN   cend   () const{ return ZCNodePointN::MakeTailPoint(*this); }


        IterEasyID  ItHID  ()      {return GetHeadIterEasyID ();}
        IterEasyID  ItTID  ()      {return GetTailIterEasyID ();}

        IterEasyIDc ItHID  () const{return GetHeadIterEasyIDc();}
        IterEasyIDc ItTID  () const{return GetTailIterEasyIDc();}

        IterEasyIDc ItHIDc () const{return GetHeadIterEasyIDc();}
        IterEasyIDc ItTIDc () const{return GetTailIterEasyIDc();}


        void ItNext(TypeLink * &  APR_CLink       ) const
            { APR_CLink=APR_CLink->GetNextPtr(); }
        void ItNext(IterEasyID &  ARRI_IterEasyID ) const
            { ItNext((ZCLink*&)(ARRI_IterEasyID)); }
        void ItNext(TypeLinkC* &  APR_CLink       ) const
            { APR_CLink=APR_CLink->GetNextPtr(); }
        void ItNext(IterEasyIDc&  ARRI_IterEasyID ) const
            { ItNext((TypeLinkC*&)(ARRI_IterEasyID)); }
        void ItNext(iterator   &  ARR_Iterator    ) const{++ARR_Iterator;}
        void ItNext(iteratorN  &  ARR_Iterator    ) const{++ARR_Iterator;}

        void ItPrev(TypeLink * &  APR_CLink       ) const
            { APR_CLink=APR_CLink->GetPrevPtr(); }
        void ItPrev(IterEasyID &  ARRI_IterEasyID ) const
            { ItPrev((ZCLink*&)(ARRI_IterEasyID)); }
        void ItPrev(TypeLinkC* &  APR_CLink       ) const
            { APR_CLink=APR_CLink->GetPrevPtr(); }
        void ItPrev(IterEasyIDc&  ARRI_IterEasyID ) const
            { ItPrev((TypeLinkC*&)(ARRI_IterEasyID)); }
        void ItPrev(iterator   &  ARR_Iterator    ) const{--ARR_Iterator;}
        void ItPrev(iteratorN  &  ARR_Iterator    ) const{--ARR_Iterator;}


        TypeDataCore & ItD(TypeLink  * AP_Link       )      {return **AP_Link;}
        TypeDataCore & ItD(IterEasyID  AH_IterEasyID )      {return **(TypeLink *)(AH_IterEasyID);}
        TypeDataCore & ItD(iterator  & ARR_Iterator  )      {return **ARR_Iterator;}

        TypeDataCoreC& ItD(TypeLinkC * AP_Link       ) const{return **AP_Link;}
        TypeDataCoreC& ItD(IterEasyIDc AH_IterEasyID ) const{return **(TypeLinkC*)(AH_IterEasyID);}
        TypeDataCoreC& ItD(iteratorN & ARR_Iterator  ) const{return **ARR_Iterator;}

        TypeDataCore & ItD(TypeLink  * AP_Link      , TypeSize AI_FarNum)      {return *((*AP_Link)+AI_FarNum);}
        TypeDataCore & ItD(IterEasyID  AH_IterEasyID, TypeSize AI_FarNum)      {return *(((TypeLink *)(AH_IterEasyID))+AI_FarNum);}
        TypeDataCore & ItD(iterator  & ARR_Iterator , TypeSize AI_FarNum)      {return *(ARR_Iterator.GetNode()+AI_FarNum);}

        TypeDataCoreC& ItD(TypeLinkC * AP_Link      , TypeSize AI_FarNum) const{return *((*AP_Link)+AI_FarNum);}
        TypeDataCoreC& ItD(IterEasyIDc AH_IterEasyID, TypeSize AI_FarNum) const{return *(((TypeLinkC*)(AH_IterEasyID))+AI_FarNum);}
        TypeDataCoreC& ItD(iteratorN & ARR_Iterator , TypeSize AI_FarNum) const{return *(ARR_Iterator.GetNode()+AI_FarNum);}


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



    template //////////////////////////////////////////////////////////////////
        <
            typename TCLink
          , typename TTypSize  = ZTypLong
          , typename TTypeCRTP =
                ZNsType::ZtCTypeCRTP<ZCEmpty, false>
        >
    class ZtCLinkMoveList /*#################################################*/
    {
    public :
        typedef ZtCLinkMoveList TypeThis;
    public :
        typedef ZNsType::ZtCTypeNowCRTP ///////////////////////////////////////
            <
                TypeThis, 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 TCLink   TypeLink;
        typedef TTypSize TypeSize;
    public :
        typedef typename TCLink::TypeMain TypeMain;
    private:
        ZCLink   mo_HeadFake; // 고정된 가상의 맨 앞 링크 객체
        ZCLink   mo_TailFake; // 고정된 가상의 맨 뒤 링크 객체
        TypeSize ml_LinkSize;
    //////////////////////////////////////////////////////////
        // 실제 맨 앞 링크는 mo_HeadFake.mp_NextLink
        // 실제 맨 뒤 링크는 mo_TailFake.mp_PrevLink
    private:

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

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

    private:

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

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

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

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

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

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

                VP_MakeLink = new TypeMain;

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


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

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

            VP_TailLink  = VP_MakeLink =
                new TypeMain(*AP_LinkOrgin) ;

            APR_HeadCopy = VP_MakeLink;

            while(--AL_FarNum >= 0)
            {
                AP_LinkOrgin= AP_LinkOrgin->GetNextPtr() ;
                VP_MakeLink = new TypeMain(*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
            )   const
        ///////////////////////////////////////////////////*/


        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() const
        {
            if(TTypeCRTP::ZEUseCRTP<1) return NewLink();

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

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

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

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

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

        _VT_ void SendFreeOut
            (TypeSize AL_NeedCnt, ZCLink*& APR_HeadLink, ZCLink*& APR_TailLink) const
        {
            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) const
        */

        _VT_ void SendFreeOutCopy /*///////////////////////*/
            (
                ZCLink*  AP_LinkOrgin, TypeSize AL_FarNum   ,
                ZCLink*& APR_HeadCopy, ZCLink*& APR_TailCopy
            )   const
        /////////////////////////////////////////////////////
        {
            // 총 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
            )   const
        ///////////////////////////////////////////////////*/


        _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_StdLink)
        {
            // AR_LinkNew 를 AP_StdLink 뒤에 삽입한다.
            // AL_PosStd==0 이면 맨 앞에 삽입한다.

            if(AP_StdLink==0) AP_StdLink=&mo_HeadFake ;

            ZCLink* AP_NextStd = AP_StdLink->mp_NextLink;

            ZCLink::JoinLink(AP_StdLink , &AR_LinkNew);
            ZCLink::JoinLink(&AR_LinkNew, AP_NextStd );

            ++ml_LinkSize;  return AR_LinkNew;
        }/*
        ZCLink& JoinAfter(ZCLink& AR_LinkNew, ZCLink* AP_StdLink)*/


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

            if(AP_StdLink==0) AP_StdLink= &mo_TailFake;

            ZCLink* AP_PrevStd = AP_StdLink->mp_PrevLink ;

            ZCLink::JoinLink( AP_PrevStd, &AR_LinkNew);
            ZCLink::JoinLink(&AR_LinkNew,  AP_StdLink);

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


        TypeThis& JoinAfter (TypeThis& rhs, ZCLink* AP_StdLink)
        {
            // AP_StdLink 의 뒤에 rhs 를 삽입.
            // AP_StdLink==0 이면 맨 앞에 삽입.

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

            if(AP_StdLink==0) AP_StdLink=&mo_HeadFake ;

            ZCLink* VP_RhsHead = rhs.mo_HeadFake.mp_NextLink;
            ZCLink* VP_RhsTail = rhs.mo_TailFake.mp_PrevLink;
            ZCLink* VP_StdNext = AP_StdLink->    mp_NextLink;

            ZCLink::JoinLink(AP_StdLink, VP_RhsHead);
            ZCLink::JoinLink(VP_RhsTail, VP_StdNext);

            this->ml_LinkSize += rhs.ml_LinkSize;
            rhs.  ml_LinkSize  = 0              ;

            ZCLink::JoinLink
                (&rhs.mo_HeadFake, &rhs.mo_TailFake);

            return *this;
        }/*
        TypeThis& JoinAfter (TypeThis& rhs, ZCLink* AP_StdLink)*/


        TypeThis& JoinBefore(TypeThis& rhs, ZCLink* AP_StdLink)
        {
            // AP_StdLink 의 앞에 rhs 를 삽입.
            // AP_StdLink==0 이면 맨 뒤에 삽입.

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

            if(AP_StdLink==0) AP_StdLink=&mo_TailFake ;

            ZCLink* VP_RhsHead = rhs.mo_HeadFake.mp_NextLink;
            ZCLink* VP_RhsTail = rhs.mo_TailFake.mp_PrevLink;
            ZCLink* VP_StdPrev = AP_StdLink->    mp_PrevLink;

            ZCLink::JoinLink(VP_StdPrev, VP_RhsHead);
            ZCLink::JoinLink(VP_RhsTail, AP_StdLink);

            this->ml_LinkSize += rhs.ml_LinkSize;
            rhs.  ml_LinkSize  = 0              ;

            ZCLink::JoinLink
                (&rhs.mo_HeadFake, &rhs.mo_TailFake);

            return *this;
        }/*
        TypeThis& JoinBefore(TypeThis& rhs, ZCLink* AP_StdLink)*/


        ZCLink& CutLink(ZCLink& AR_CutLink)
        {
            ZCLink::JoinLink
              (AR_CutLink->mp_PrevLink, AR_CutLink->mp_NextLink);

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


        TypeThis& CutLinkRangeOut  /*##########################################*/
            (
                ZCLink&   AR_CutHead ,
                ZCLink&   AR_CutTail ,
                TypeSize  AL_CutSize ,
                TypeThis& rhs        ,
                ZCLink*   AP_RhsStd  ,
                bool      AB_After=true
            )
        /*#####################################################################*/
        {
            /*///////////////////////////////////////////////////////////

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

                AR_CutHead 의 앞과 AR_CutTail 의 뒤에서 연결 상태를 끊고,
                rhs 의 AP_RhsStd 의 뒤에 삽입한다.

                AP_RhsStd==0 이면 맨 앞에 삽입한다.  -- 2025-10-06 09:16

            ■  bool AB_After=true 추가. -- 2025-10-07 09:26

                AB_After==true  이면 AP_RhsStd 의 뒤에 삽입.
                AB_After==false 이면 AP_RhsStd 의 앞에 삽입.

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

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

            ZCLink* VP_CutHeadPrev = AR_CutHead.mp_PrevLink ;
            ZCLink* VP_CutTailNext = AR_CutTail.mp_NextLink ;

            ZCLink::JoinLink(VP_CutHeadPrev, VP_CutTailNext);

            ml_LinkSize -= AL_CutSize;


            if(AB_After)
            {
                // rhs 의 AP_RhsStd 의 뒤에 삽입.
                // AP_RhsStd==0 이면 rhs 의 맨 앞에 삽입.

                if(AP_RhsStd==0) AP_RhsStd=&rhs.mo_HeadFake ;

                ZCLink* VP_RhsStdNext=AP_RhsStd->mp_NextLink;

                ZCLink::JoinLink(AP_RhsStd  , &AR_CutHead  );
                ZCLink::JoinLink(&AR_CutTail, VP_RhsStdNext);
            }
            else
            {
                // rhs 의 AP_RhsStd 의 앞에 삽입.
                // AP_RhsStd==0 이면 rhs 의 맨 뒤에 삽입.

                if(AP_RhsStd==0) AP_RhsStd=&rhs.mo_TailFake ;

                ZCLink* VP_RhsStdPrev=AP_RhsStd->mp_PrevLink;

                ZCLink::JoinLink(VP_RhsStdPrev, &AR_CutHead);
                ZCLink::JoinLink(&AR_CutTail  , AP_RhsStd  );
            }

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


  /*private:*/
    public :

        ZtCLinkMoveList()
        {
            ZCLink::JoinLink(&mo_HeadFake, &mo_TailFake);
            ZCLink::MakeRing(&mo_HeadFake, &mo_TailFake);

            ml_LinkSize=0;
        }/*
        ZtCLinkMoveList()*/

        ZtCLinkMoveList(const ZtCLinkMoveList& rhs)
        {
            ZCLink::JoinLink(&mo_HeadFake, &mo_TailFake);
            ZCLink::MakeRing(&mo_HeadFake, &mo_TailFake);

            ml_LinkSize=0;  *this = rhs ;
        }/*
        ZtCLinkMoveList(const ZtCLinkMoveList& rhs)*/

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


        TypeThis& operator=(const TypeThis& 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)
            {
                ZCLink* VP_CutHead     = mo_HeadFake.mp_NextLink ;
                ZCLink* VP_CutTail     =
                    VP_CutHead->GetNextPrevPtr( VL_MinusSize-1 ) ;
                ZCLink* VP_CutTailNext = VP_CutTail->mp_NextLink ;

                RecvFreeIn ///////////////////////////////////////
                    (
                        VL_MinusSize, VP_CutHead, VP_CutTail
                    );
                //////////////////////////////////////////////////

                ml_LinkSize -= VL_MinusSize ;

                ZCLink::JoinLink(&mo_HeadFake, VP_CutTailNext);
            }
            else if(VL_MinusSize<0)
            {
                ZCLink* VP_HeadLink=0;
                ZCLink* VP_TailLink=0;

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

                ZCLink* VP_CurrTail = mo_TailFake.mp_PrevLink ;

                ZCLink::JoinLink(VP_CurrTail,  VP_HeadLink);
                ZCLink::JoinLink(VP_TailLink, &mo_TailFake);

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


            ZCLink* VP_RhsLink = rhs.mo_HeadFake.mp_NextLink ;
            ZCLink* VP_LhsLink =     mo_HeadFake.mp_NextLink ;

            __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;
        }/*
        TypeThis& operator=(const TypeThis& rhs)*/


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

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


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

            RecvFreeIn /////////////////////////
                (
                    ml_LinkSize             ,
                    mo_HeadFake.mp_NextLink ,
                    mo_TailFake.mp_PrevLink
                );
            ////////////////////////////////////

            ZCLink::JoinLink
                (&mo_HeadFake, &mo_TailFake);

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

        void clear(){DeleteAll();}


        ZCDataOpt GetHeadOpt()
            {
                return size()<1 ? ZCDataOpt(0) :
                    ZCDataOpt(mo_HeadFake.mp_NextLink);
            }
        ZCDataOpt GetTailOpt()
            {
                return size()<1 ? ZCDataOpt(0) :
                    ZCDataOpt(mo_TailFake.mp_PrevLink);
            }

        ZCDataOpt GetObjOpt(TypeSize AI_Index)
        {
            if(ml_LinkSize<1 || AI_Index<1 || AI_Index>ml_LinkSize)
                return ZCDataOpt(0);
            /*+++++++++++++++++++++++++++++++++++++++++++++++++++*/

            return ZCDataOpt( mo_HeadFake+AI_Index );
        }/*
        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(mo_HeadFake.mp_NextLink) );
            }
        void DeleteTail()
            {
                if(ml_LinkSize<1) return;  RecvFreeIn
                    ( &CutLink(mo_TailFake.mp_PrevLink) );
            }


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


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

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


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

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

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

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


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

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

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


        TypeThis& SendRangeOut //////////////////////////////////////////////////
            (
                ZCLink&   AR_CutHead, ZCLink&   AR_CutTail,
                TypeSize  AI_CutSize, TypeThis& rhs       ,
                ZCLinkOpt AO_LinkOpt, bool      AB_After
            )
        /*#####################################################################*/
        {
            return CutLinkRangeOut
                (
                    AR_CutHead, AR_CutTail      , AI_CutSize,
                    rhs       , AO_LinkOpt.Raw(), AB_After
                );
            //////////////////////
        }/*
        TypeThis& SendRangeOut //////////////////////////////////////////////////
            (
                ZCLink&   AR_CutHead, ZCLink&   AR_CutTail,
                TypeSize  AI_CutSize, TypeThis& rhs       ,
                ZCLinkOpt AO_LinkOpt, bool      AB_After
            )
        #######################################################################*/


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

            return CutLinkRangeOut
                (
                    AR_CutHead, AR_CutTail      , AI_CutSize,
                    rhs       , AO_LinkOpt.Raw(), true
                );
            //////////////////////
        }
        TypeThis& SendRangeOutBefore ////////////////////////////////////////////
            (
                ZCLink&  AR_CutHead, ZCLink&   AR_CutTail,
                TypeSize AI_CutSize, TypeThis& rhs       , ZCLinkOpt AO_LinkOpt
            )
        /*#####################################################################*/
        {
            // AR_CutHead 부터 AR_CutTail 까지를 잘라서 rhs 의 AR_StdLink 앞에 연결한다.

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


        TypeThis& CopyThis(TypeThis& ARR_Rhs) const
        {
            // *this 를 복사해서, ARR_Rhs 의 끝에 연결한다.

            if(size()<1) return ARR_Rhs;

            ZCLink* VP_HeadCopy=0;
            ZCLink* VP_TailCopy=0;

            SendFreeOutCopy ////////////////////////////////
                (
                    mo_HeadFake.mp_NextLink, size()-1,
                    RR(VP_HeadCopy)        , RR(VP_TailCopy)
                );
            ////////////////////////////////////////////////

            TypeThis VO_TempList;

            ZCLink::JoinLink
                ( &VO_TempList.mo_HeadFake, VP_HeadCopy );
            ZCLink::JoinLink
                ( VP_TailCopy, &VO_TempList.mo_TailFake );

            VO_TempList.ml_LinkSize = size() ;

            return ARR_Rhs.JoinTail(VO_TempList);
        }/*
        TypeThis& CopyThis(TypeThis& ARR_Rhs) const*/



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

            __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=mo_HeadFake.mp_NextLink;

            __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=mo_HeadFake.mp_NextLink;

            __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=mo_TailFake.mp_PrevLink;

            __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=mo_TailFake.mp_PrevLink;

            __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=mo_TailFake.mp_PrevLink;

            __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 ZtCLinkMoveList ###################################################*/


}/*
namespace ZNsMain*/


#endif //__ZCPPMAIN__ZTCLINKLIST_H__