RepoMain/ZCppMain/ZtCObjList.H



#ifndef __ZCPPMAIN__ZTCOBJLIST_H__
#define __ZCPPMAIN__ZTCOBJLIST_H__


#include "ZCppMain/ZMainHead.H"


namespace ZNsMain
{


    template //////////////////////////////////////////////////////
        <
            typename TType      , typename TTypArgu
          , typename TTypCAlloc , typename TTypeInit
          , typename TTypSize   , typename TMoveObj
          , typename TFeeeHeap
        >
    class ZtCObjList; /////////////////////////////////////////////



    namespace ZNsIFaceEx
    {

        template<> class ZtCFreeHeapCDL< ZNsConst::CI_ListKind_Double >
        {
        public:

            template<typename TObjList> class ZtCBody
            {
            public :
                typedef typename TObjList::TypeSize TypeSize;
                typedef typename TObjList::TypeInit TypeInit;
                typedef typename TObjList::ZCLink   ZCLink  ;
            public :

                template //////////////////////////////////////////////////////
                    <
                        typename TType      , typename TTypArgu
                      , typename TTypCAlloc , typename TTypeInit
                      , typename TTypSize   , typename TMoveObj
                      , typename TFeeeHeap
                    >
                friend class ZNsMain::ZtCObjList; /////////////////////////////

            private:
                TypeSize ml_UseSize   ;
                ZCLink*  mp_NoUseHead ;
                ZCLink*  mp_NoUseTail ;
            private:

                ZCLink* SendFreeOut()
                {
                    if(ml_UseSize==0)
                    {
                        ZCLink* VP_TempLink = new ZCLink  ;

                        if(TypeInit::ZEUseInit>0)
                            TypeInit::OnInit(*VP_TempLink, *this);

                        return VP_TempLink;
                    }/*
                    if(ml_UseSize==0)*/


                    ZCLink* VP_TempLink=mp_NoUseHead;

                    if(VP_TempLink==mp_NoUseTail)
                    {
                        mp_NoUseHead=0;
                        mp_NoUseTail=0;
                    }
                    else
                    {
                        mp_NoUseHead = mp_NoUseHead->GetNextPtr();
                    }
                  //else

                    --ml_UseSize; return VP_TempLink;
                }/*
                ZCLink* SendFreeOut()*/


                void SendFreeOut /*#####################################################*/
                    (
                        TypeSize AL_NeedCnt, ZCLink*& APR_HeadLink, ZCLink*& APR_TailLink
                    )
                /*######################################################################*/
                {
                    if(mp_NoUseHead==0)
                    {
                        MakeLink(AL_NeedCnt, RR(APR_HeadLink), RR(APR_TailLink));
                    }
                    else if(AL_NeedCnt==ml_UseSize)
                    {
                        ZCLink* VP_Temp = mp_NoUseHead;

                        while(true)
                        {
                            if(TypeInit::ZEUseInit>0)
                                TypeInit::OnInit(**VP_Temp, *this);

                            if(VP_Temp==mp_NoUseTail)
                                { break; }

                            VP_Temp = VP_Temp->GetNextPtr();
                        }/*
                        while(true)*/

                        APR_HeadLink = mp_NoUseHead ;
                        APR_TailLink = mp_NoUseTail ;

                        mp_NoUseHead =0 ;
                        mp_NoUseTail =0 ;
                        ml_UseSize   =0 ;
                    }
                    else if(AL_NeedCnt<ml_UseSize)
                    {
                        APR_HeadLink = mp_NoUseHead;

                        if(TypeInit::ZEUseInit>0)
                            TypeInit::OnInit(**mp_NoUseHead, *this);

                        for(TypeSize VL_Count=2; VL_Count<=AL_NeedCnt; ++VL_Count)
                        {
                            // VL_Count 가 2 부터 시작함으로 AL_NeedCnt-1 번 순환한다.
                            // 그래야지 AL_NeedCnt 개의 링크를 자를 수 있다.

                            mp_NoUseHead = mp_NoUseHead->GetNextPtr();

                            if(TypeInit::ZEUseInit>0)
                                TypeInit::OnInit(**mp_NoUseHead, *this);
                        }/*
                        for(TypeSize VL_Count=2; VL_Count<=AL_NeedCnt; ++VL_Count)*/

                        APR_TailLink = mp_NoUseHead ;
                        mp_NoUseHead = mp_NoUseHead->GetNextPtr();
                        ml_UseSize  -= AL_NeedCnt   ;
                    }
                    else // AL_NeedCnt > ml_UseSize
                    {
                        ZCLink* VP_Temp=mp_NoUseHead;

                        while(true)
                        {
                            if(VP_Temp==mp_NoUseTail)
                                { break; }

                            VP_Temp=VP_Temp->GetNextPtr() ;
                        }/*
                        while(true)*/

                        APR_HeadLink = mp_NoUseHead;

                        // MakeLink() 에서 TypeInit::OnInit() 가 호출됨.
                        MakeLink ///////////////////////////////////////
                            (
                                AL_NeedCnt - ml_UseSize       ,
                                RR(mp_NoUseTail->mp_NextLink) ,
                                RR(APR_TailLink)
                            );
                        ////////////////////////////////////////////////

                        mp_NoUseHead= 0 ;
                        mp_NoUseTail= 0 ;
                        ml_UseSize  = 0 ;
                    }/*
                    else // AL_NeedCnt > ml_UseSize*/
                }/*
                void SendFreeOut  ########################################################
                    (
                        TypeSize AL_NeedCnt, ZCLink*& APR_HeadLink, ZCLink*& APR_TailLink
                    )
                ########################################################################*/


                void SendFreeOutCopy /*////////////////////////////*/
                    (
                        ZCLink*  AP_LinkOrgin, TypeSize AL_FarNum   ,
                        ZCLink*& APR_HeadCopy, ZCLink*& APR_TailCopy
                    )
                /*/////////////////////////////////////////////////*/
                {
                    /*//////////////////////////////////////////////////////////////////////

                    ■  AL_FarNum > 0

                        AP_LinkOrgin 링크부터, AP_LinkOrgin 에서 AL_FarNum 만큼 떨어진 링크까
                        지를 복사하여 복사 생성된

                            처음   링크 포인터를 APR_HeadCopy 에,
                            마지막 링크 포인터를 APR_TailCopy 에

                        대입한다. AP_LinkOrgin 링크에서 그 다음 링크로 접근하면서 링크를 복사
                        할 것이다. 따라서 총 AL_FarNum  + 1 개의 링크가 만들어진다.

                        이 함수는 각 링크를 새로 생성하는 MakeLinkCopy() 함수와는 달리, 기존
                        에 있는 ml_UseSize 개의 링크를 먼저 사용한다.

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

                    if(mp_NoUseHead==0)
                    {
                        MakeLinkCopy /////////////////////////////
                            (
                                AP_LinkOrgin    , AL_FarNum ,
                                RR(APR_HeadCopy), RR(APR_TailCopy)
                            );
                        //////////////////////////////////////////
                    }
                    else if( AL_FarNum < ml_UseSize) // ( (AL_FarNum<0 ? -AL_FarNum : AL_FarNum)+1 <= ml_UseSize)
                    {
                        ml_UseSize    -= AL_FarNum+1    ;
                        **mp_NoUseHead = **AP_LinkOrgin ;
                        APR_HeadCopy   = mp_NoUseHead   ;

                        while(--AL_FarNum>=0)
                        {
                            mp_NoUseHead = mp_NoUseHead->GetNextPtr() ;
                            AP_LinkOrgin = AP_LinkOrgin->GetNextPtr() ;

                            **mp_NoUseHead = **AP_LinkOrgin ;
                        }
                      //while(--AL_FarNum>=0)

                        APR_TailCopy = mp_NoUseHead ;

                        // 이 부분에서 mp_NoUseHead 는 잘려나가는 마지막 링크가 된다.
                        // 그러므로 다시 다음 링크로 초기화한다.

                        mp_NoUseHead = mp_NoUseHead->GetNextPtr();

                        if(mp_NoUseHead==0)
                        {
                            mp_NoUseTail=0;

                            // mp_NoUseHead == 0 인데 mp_NoUseTail !=0 이라면
                            // 나중에 자칫 무한루프에 빠질 수 있다.
                            // 따라서 위 코드를 두었다.
                        }/*
                        if(mp_NoUseHead==0)*/
                    }
                    else // AL_FarNum > ml_UseSize
                    {
                        **mp_NoUseHead = **AP_LinkOrgin ;
                        APR_HeadCopy   = mp_NoUseHead   ;

                        while(mp_NoUseHead!=mp_NoUseTail)
                        {
                            mp_NoUseHead = mp_NoUseHead->GetNextPtr() ;
                            AP_LinkOrgin = AP_LinkOrgin->GetNextPtr() ;

                            **mp_NoUseHead = **AP_LinkOrgin ;
                        }/*
                        while(mp_NoUseHead!=mp_NoUseTail)*/

                        MakeLinkCopy /*++++++++++++++++++++++++++++++++++++++++++++*/
                            (
                                   AP_LinkOrgin->GetNextPtr() , AL_FarNum-ml_UseSize,
                                RR(mp_NoUseTail->mp_NextLink), RR(APR_TailCopy)
                            );
                        /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

                        mp_NoUseHead =
                        mp_NoUseTail = 0;
                        ml_UseSize   = 0;
                    }
                  //else // AL_FarNum > ml_UseSize
                }/*
                void SendFreeOutCopy ////////////////////////////////
                    (
                        ZCLink*  AP_LinkOrgin, TypeSize AL_FarNum   ,
                        ZCLink*& APR_HeadCopy, ZCLink*& APR_TailCopy
                    )
                ///////////////////////////////////////////////////*/


                void MakeLink ///////////////////////////////////////
                    (
                        TypeSize AL_MakeSize ,
                        ZCLink*& APR_HeadLink,
                        ZCLink*& APR_TailLink
                    )   const
                ///////////////////////////////////////////////////*/
                {
                    APR_HeadLink = new ZCLink;

                    if(APR_HeadLink==0)
                    {
                        // add codes for memory over

                        return;
                    }/*
                    if(APR_HeadLink==0)*/

                    if(TypeInit::ZEUseInit>0)
                        TypeInit::OnInit(**APR_HeadLink, *this);

                    ZCLink* VP_MakeLink  = 0           ;
                    ZCLink* VP_TempLink  = APR_HeadLink;
                    bool    VB_IsHeapOver= false       ;

                    /*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

                    ■  bool VB_IsHeapOver 은 new 연산자가 NULL 포인터를 반환했을 때
                        true 를 대입받는다. 이 값을 조사함으로써 heap overflow 를 처리한다.

                        bool VB_IsHeapOver 변수를 두지 않고 아래 for 문에서 직접 메모리 처리
                        를 하는 코드를 둘 수 있으나, for 문 안에 if 문 속에서 또 for 문을 써
                        야 함으로 가독성이 떨어질 수가 있다. 그래서 heap over 에 대한 예외처
                        리 코드를 for 문 바깥으로 빼려는 것이다.

                    ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/

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

                        VP_MakeLink = new ZCLink;

                        if(VP_MakeLink==0)
                        {
                            VB_IsHeapOver = true;  break;
                        }/*
                        if(VP_MakeLink==0)*/

                        if(TypeInit::ZEUseInit>0)
                            TypeInit::OnInit(**VP_MakeLink, *this);

                        ZCLink::JoinLink
                            (VP_TempLink, VP_MakeLink);

                        VP_TempLink = VP_MakeLink ;
                    }/*
                    while(--AL_MakeSize>0)*/

                    APR_TailLink = VP_TempLink;


                    // 메모리를 더 이상 할당할 수 없었다면
                    // 이미 만들어진 VL_Count 개의 비원형 이중 링크를 지운다.

                    if(VB_IsHeapOver==true)
                    {
                        VP_TempLink=APR_HeadLink;

                        // 이 시점에서 최소한 APR_HeadLink 하나는
                        // heap 에 생성되어 있다.

                        do //////
                        {
                            delete VP_TempLink;

                            if(VP_TempLink==APR_TailLink)
                            {
                                // Add extra codes for memory over

                                return;
                            }/*
                            if(VP_TempLink==APR_TailLink)*/

                            APR_HeadLink=APR_HeadLink->GetNextPtr();
                        }
                        while(true);
                    }/*
                    if(VB_IsHeapOver==true)*/
                }/*
                void MakeLink ///////////////////////////////////////
                    (
                        TypeSize AL_MakeSize ,
                        ZCLink*& APR_HeadLink,
                        ZCLink*& APR_TailLink
                    )   const
                ///////////////////////////////////////////////////*/


                void MakeLinkCopy ///////////////////////////////////
                    (
                        ZCLink*  AP_LinkOrgin, TypeSize AL_FarNum ,
                        ZCLink*& APR_HeadCopy, ZCLink*& APR_TailCopy
                    )   const
                ///////////////////////////////////////////////////*/
                {
                    /*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

                    ■  AP_LinkOrgin 링크부터, AP_LinkOrgin 에서 AL_FarNum 만큼 떨어진 링크까
                        지를 복사하여, 복사 생성된

                            처음   링크 포인터를 APR_HeadCopy 에,
                            마지막 링크 포인터를 APR_TailCopy 에

                        대입한다. AL_FarNum > 0 , 총 AL_FarNum + 1 개의 링크가 만들어진다.

                    ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/

                    ZCLink* VP_MakeLink  = 0    ;
                    ZCLink* VP_TailLink  = 0    ;
                    bool    VB_IsHeapOver= false;

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

                    if(VP_MakeLink==0)
                    {
                        //add codes for memory over

                        DeleteHeap();     return ;
                    }/*
                    if(VP_MakeLink==0)*/


                    APR_HeadCopy = VP_MakeLink;

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

                        if(VP_MakeLink==0)
                        {
                            APR_TailCopy = VP_TailLink ;
                            VB_IsHeapOver= true        ;

                            break;
                        }/*
                        if(VP_MakeLink==0)*/

                        ZCLink::JoinLink
                            (VP_TailLink, VP_MakeLink);

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

                    APR_TailCopy=VP_TailLink;

                    // 메모리를 더 이상 할당할 수 없었다면
                    // 이미 만들어진 비원형 이중 링크를 지운다.

                    if(VB_IsHeapOver==true)
                    {
                        do //////
                        {
                            delete APR_HeadCopy;

                            if(APR_HeadCopy==APR_TailCopy)
                            {
                                DeleteHeap(); return;
                            }/*
                            if(APR_HeadCopy==APR_TailCopy)*/

                            APR_HeadCopy = APR_HeadCopy->mp_NextLink;
                        }
                        while(true);
                    }/*
                    if(VB_IsHeapOver==true)*/
                }/*
                void MakeLinkCopy ///////////////////////////////////
                    (
                        ZCLink*  AP_LinkOrgin, TypeSize AL_FarNum,
                        ZCLink*& APR_HeadCopy, ZCLink*& APR_TailCopy
                    )   const
                ///////////////////////////////////////////////////*/


                void RecvFreeIn(ZCLink* AP_CutLink)
                {
                    if(++ml_UseSize==1) // ml_UseSize 이 0 일때
                    {
                        mp_NoUseHead =
                        mp_NoUseTail = AP_CutLink ;
                    }
                    else
                    {
                        // 새로운 링크는 mp_NoUseTail 다음에 붙인다.

                        ZCLink::JoinLink
                            (mp_NoUseTail, AP_CutLink);

                        mp_NoUseTail = AP_CutLink;
                    }
                  //else

                    if(TypeInit::ZEUseFini>0)
                        TypeInit::OnFini(**AP_CutLink, *this);
                }/*
                void RecvFreeIn(ZCLink* AP_Link)*/


                void RecvFreeIn ///////////////////////////////////////////////////
                    (
                        TypeSize AL_Count, ZCLink* AP_HeadLink, ZCLink* AP_TailLink
                    )
                ///////////////////////////////////////////////////////////////////
                {
                    if(TypeInit::ZEUseFini>0)
                    {
                        ZCLink* VP_NowLink = AP_HeadLink;

                        __for1(TypeSize, i, AL_Count)
                        {
                            TypeInit::OnFini(**VP_NowLink, *this) ;

                            VP_NowLink = VP_NowLink->GetNextPtr() ;
                        }
                        /*=========================*/
                    }/*
                    if(TypeInit::ZEUseFini>0)*/


                    if(ml_UseSize==0)
                    {
                        mp_NoUseHead = AP_HeadLink ;
                        mp_NoUseTail = AP_TailLink ;
                    }
                    else
                    {
                        // 새로운 링크는 mp_NoUseTail 다음에 붙인다.

                        ZCLink::JoinLink
                            (mp_NoUseTail, AP_HeadLink);

                        mp_NoUseTail = AP_TailLink;
                    }
                  //else

                    ml_UseSize += AL_Count ;
                }/*
                void RecvFreeIn ///////////////////////////////////////////////////
                    (
                        TypeSize AL_Count, ZCLink* AP_HeadLink, ZCLink* AP_TailLink
                    )
                /////////////////////////////////////////////////////////////////*/

        /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            private :
        +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
            public  :


                ZtCBody()
                {
                    ml_UseSize   = 0 ;
                    mp_NoUseHead =
                    mp_NoUseTail = 0 ;
                }/*
                ZtCBody()*/

                ~ZtCBody()
                {
                    DeleteHeap();
                }/*
                ~ZtCBody()*/

                ZtCBody(const ZtCBody& rhs)
                {
                    ml_UseSize   = 0 ;
                    mp_NoUseHead =
                    mp_NoUseTail = 0 ;
                }/*
                ZtCBody(const ZtCBody& rhs)*/


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


                void DeleteHeap()
                {
                    if(ml_UseSize<1) return ;

                    ZCLink*  VP_DelLink = mp_NoUseHead;
                    TypeSize VI_UseSize = ml_UseSize  ;

                    do /*++++++++++++++++++++++++++++*/
                    {
                        mp_NoUseHead =
                        mp_NoUseHead->GetNextPtr() ;

                        delete VP_DelLink;

                        VP_DelLink = mp_NoUseHead  ;
                    }
                    while(--VI_UseSize>0); /*++++++++*/

                    ml_UseSize   = 0 ;
                    mp_NoUseHead =
                    mp_NoUseTail = 0 ;
                }/*
                void DeleteHeap()*/


                TypeSize DeleteHeap(TypeSize AI_DelCnt)
                {
                    if(ml_UseSize<1) return 0;
                    if(AI_DelCnt <1) return 0;
                    if(AI_DelCnt >= size())
                    {
                        AI_DelCnt=size(); DeleteHeap(); return AI_DelCnt;
                    }/*
                    if(AI_DelCnt >= size())*/


                    TypeSize VI_DelCntCopy = AI_DelCnt    ;
                    ZCLink*  VP_DelLink    = mp_NoUseHead ;

                    do /*+++++++++++++++++++++++++++*/
                    {
                        mp_NoUseHead =
                        mp_NoUseHead->GetNextPtr() ;

                        delete VP_DelLink;

                        VP_DelLink = mp_NoUseHead  ;
                    }
                    while(--VI_DelCntCopy>0); /*++++*/

                    ml_UseSize -= AI_DelCnt;  return AI_DelCnt;
                }/*
                TypeSize DeleteHeap(TypeSize AI_DelCnt)*/


                void AddHeap(TypeSize AI_AddCnt)
                {
                    if(AI_AddCnt<1) return;

                    if(size() < 1)
                    {
                        MakeLink
                            (AI_AddCnt, RR(mp_NoUseHead), RR(mp_NoUseTail));
                    }
                    else
                    {
                        ZCLink* VP_MakeHead = 0;
                        ZCLink* VP_MakeTail = 0;

                        MakeLink
                            (AI_AddCnt, RR(VP_MakeHead), RR(VP_MakeTail));

                        ZCLink::JoinLink(mp_NoUseTail, VP_MakeHead);

                        mp_NoUseTail = VP_MakeTail ;
                    }/*
                    else*/

                    ml_UseSize += AI_AddCnt;
                }/*
                void AddHeap(TypeSize AI_AddCnt)*/


                void Fetch(ZtCBody& rhs)
                {
                    if(this==&rhs  ) return;
                    if(rhs.size()<1) return;

                    if(this->size()<1)
                        this->mp_NoUseHead = rhs.mp_NoUseHead;
                    else
                    {
                        ZCLink::JoinLink
                            (this->mp_NoUseTail, rhs.mp_NoUseHead);
                    }

                    this->mp_NoUseTail = rhs.mp_NoUseTail;
                    this->ml_UseSize  += rhs.ml_UseSize  ;

                    rhs.ml_UseSize   = 0 ;
                    rhs.mp_NoUseHead = 0 ;
                    rhs.mp_NoUseTail = 0 ;
                }/*
                void Fetch(ZtCBody& rhs)*/


                TypeSize Fetch(ZtCBody& rhs, TypeSize AI_FetchSize)
                {
                    // rhs 의 앞에서 AI_FetchSize 개를 가져온다.

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

                    if(AI_FetchSize>= rhs.size())
                    {
                        AI_FetchSize = rhs.size();

                        Fetch(rhs); return AI_FetchSize;
                    }/*
                    if(AI_FetchSize>= rhs.size())*/


                    ZCLink* VP_RhsCutTail =
                        rhs.mp_NoUseHead->GetNextPtr( AI_FetchSize-1 )  ;
                    ZCLink* VP_RhsNewHead = VP_RhsCutTail->GetNextPtr( );

                    if(ml_UseSize<1)
                    {
                        // mp_NoUseHead, mp_NoUseTail 이 0
                        this->mp_NoUseHead = rhs.mp_NoUseHead ;
                    }
                    else
                    {
                        // mp_NoUseHead 고정.
                        ZCLink::JoinLink
                            (this->mp_NoUseTail, rhs.mp_NoUseHead);
                    }

                    this->ml_UseSize  += AI_FetchSize ;
                    this->mp_NoUseTail = VP_RhsCutTail;
                    rhs.  ml_UseSize  -= AI_FetchSize ;
                    rhs.  mp_NoUseHead = VP_RhsNewHead;

                    return AI_FetchSize;
                }/*
                TypeSize Fetch(ZtCBody& rhs, TypeSize AI_FetchSize)*/


                void MakeEqual(ZtCBody& rhs)
                {
                    // 갯수만 맞춘다.

                    if(this==&rhs) return;

                    if(this->size() > rhs.size())
                          DeleteHeap( this->size() - rhs.  size() );
                    else  AddHeap   ( rhs.  size() - this->size() );
                }/*
                void MakeEqual(ZtCBody& rhs)*/


                TypeSize GetUseHeapSize() const
                {
                    return ml_UseSize;
                }/*
                TypeSize GetUseHeapSize() const*/

                TypeSize size() const
                {
                    return ml_UseSize;
                }/*
                TypeSize size() const*/

            public:
            };/*
            template<typename TObjList> class ZtCBody*/


        public:
        };/*
        template<> class ZtCFreeHeapCDL< ZNsConst::CI_ListKind_Double >*/


    }/*
    namespace ZNsIFaceEx*/



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

    ■  typename TTypeInit 는 별다른 역할을 하지 않고 있다. 다른 리스트
        클래스와 템플릿 인수를 비슷하게 맞추기 위해, 그리고 차후의 설계
        를 위해 일단 이대로 두자.

    ■  typename ZtCInit 가 필요한지 모르겠다. 일단 주석으로 막는다.

        -- 2025-08-11 14:47

        ZtCTreeData.H 에서 ZtCObjList<> 에서 TTypeInit 자리에 형을 지정
        하고 있다. 쓰긴 쓰니까 주석을 해제하자. -- 2025-08-14 13:43

        아, 일종의 TType 생성자의 다형성을 위해서 필요하겠네. 생성자에는
        가상 함수가 없으니까. -- 2025-10-03 19:15

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


    template<typename TypeObjList> class ZtCSortObjList;


    template<   typename TType  ///////////////////////////////////////////////////
              , typename TTypArgu   = const TType&
              , typename TTypCAlloc = ZCAllocator
              , typename TTypeInit  = ZtCInit<TType>
              , typename TTypSize   = ZTypLong
              , typename TMoveObj   = ZtCMoveObj<TType, TTypArgu, true>
              , typename TFeeeHeap  = ZNsIFaceEx::
                    ZtCFreeHeapCDL< ZNsConst::CI_ListKind_Double >
            >
    class ZtCObjList //////////////////////////////////////////////////////////////
    {
    public:
        template<typename TypeObjList> friend class ZtCSortObjList;
    public:
        typedef TType      Type       ;
        typedef TType      TypeData   ;
        typedef TTypArgu   TypeArg    ;
        typedef TTypCAlloc TypeAlloc  ;
        typedef TTypeInit  TypeInit   ;
        typedef TTypSize   TypeSize   ;
        typedef TMoveObj   TypeMoveObj;
    public:
        typedef ZtCObjList TypeThis   ;
    public:
        class ZCIterator;
        class ZCLink    ;
    public:
        typedef       ZCLink*          IterEasy; // 가장 대표적으로 쓰일 수 있는 반복자.
        typedef       ZCIterator       iterator;
        typedef const ZCIterator const_iterator;
    public:
        typedef typename TFeeeHeap::
            template ZtCBody<ZtCObjList> ZCFreeHeap;
    public:
        typedef ZtCObjOpt<ZCLink  > ZCLinkOpt;
        typedef ZtCObjOpt<TypeData> ZCDataOpt;
    public:


        class ZCLink : public TypeAlloc
        {
        public :
            template<typename TypeObjList> friend class ZtCSortObjList;
            /*++++++++++++++++++++++++++*/ friend class ZtCObjList    ;
        public :
            template<int> friend     class ZNsIFaceEx::ZtCFreeHeapCDL ;
        private:
            TypeData mo_DataObjt;
            ZCLink*  mp_NextLink;
            ZCLink*  mp_PrevLink;
        private:

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

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

      /*private:*/
        public :

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

            ZCLink(TypeArg AR_Type)
            {
                mp_NextLink = 0 ;
                mp_PrevLink = 0 ;
                mo_DataObjt = AR_Type ;
            }/*
            ZCLink(TypeArg AR_Type)*/

            ZCLink(const ZCLink& rhs)
            {
                mp_NextLink =0 ;
                mp_PrevLink =0 ;
                mo_DataObjt = rhs.mo_DataObjt ;
            }/*
            ZCLink(const ZCLink& rhs)*/

            ZCLink& operator=(const ZCLink& rhs)
            {
                mo_DataObjt = rhs.mo_DataObjt;  return *this;
            }/*
            ZCLink& operator=(const ZCLink& rhs)*/


            operator Type&     (){return mo_DataObjt;}
            operator Type      (){return mo_DataObjt;}
            Type&    GetData   (){return mo_DataObjt;}
            Type&    operator* (){return mo_DataObjt;}
            Type&    operator()(){return mo_DataObjt;}

            operator const Type&     () const{return mo_DataObjt;}
            const    Type& GetData   () const{return mo_DataObjt;}
            const    Type& operator* () const{return mo_DataObjt;}
            const    Type& operator()() const{return mo_DataObjt;}


            ZCLink* GetNextPrevPtr(TypeSize AL_FarNum)  // AL_FarNum 은 0 이거나 음수일 수 있다.
            {
                ZCLink* VP_TmpLink=this;

                if(AL_FarNum>=0)
                {
                    while(--AL_FarNum>=0) VP_TmpLink=VP_TmpLink->mp_NextLink;
                }
                else // AL_FarNum<0 인 경우.
                {
                    while(++AL_FarNum<=0) VP_TmpLink=VP_TmpLink->mp_PrevLink;
                }/*
                else*/

                return VP_TmpLink;
            }/*
            ZCLink* GetNextPrevPtr(TypeSize AL_FarNum)*/

            const ZCLink* GetNextPrevPtr(TypeSize AL_FarNum) const // or ZCLink const * const GetNextPrevPtr(TypeSize AL_FarNum) const
            {
                ZCLink* VP_TmpLink=const_cast<ZCLink*>(this);

                if(AL_FarNum>=0)
                {
                    while(--AL_FarNum>=0) VP_TmpLink=VP_TmpLink->mp_NextLink;
                }
                else // AL_FarNum<0 인 경우.
                {
                    while(++AL_FarNum<=0) VP_TmpLink=VP_TmpLink->mp_PrevLink;
                }/*
                else*/

                return VP_TmpLink;
            }/*
            const ZCLink* GetNextPrevPtr(TypeSize AL_FarNum) const*/


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

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


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

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

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

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

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

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


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

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

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

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

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

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


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

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


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

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

        public:
        };/*
        class ZCLink*/


  /*public   :*/
    protected:
        ZCLink*    mp_HeadLink;
        TypeSize   ml_LinkSize; mutable
        ZCFreeHeap mo_FreeObjt;
    protected:


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

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

                if(++ml_LinkSize==1)
                {
                    mp_HeadLink             =AP_LinkNew  ;
                    mp_HeadLink->mp_NextLink=mp_HeadLink    ;
                    mp_HeadLink->mp_PrevLink=mp_HeadLink    ;
                }
                else
                {
                    ZCLink* VP_TailLink = mp_HeadLink->mp_PrevLink ;

                    ZCLink::JoinLink(AP_LinkNew, mp_HeadLink);
                    ZCLink::MakeRing(AP_LinkNew, VP_TailLink);

                    mp_HeadLink=AP_LinkNew;
                }/*
                else*/
            }
            else
            {
                ++ml_LinkSize;

                ZCLink* AP_NextStd = AP_LinkStd->mp_NextLink ;

                ZCLink::JoinLink(AP_LinkStd, AP_LinkNew);
                ZCLink::JoinLink(AP_LinkNew, AP_NextStd);
            }/*
            else*/
        }/*
        void JoinAfter(ZCLink* AP_LinkNew, ZCLink* AP_LinkStd)*/


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

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

                if(++ml_LinkSize==1)
                {
                    mp_HeadLink             =AP_LinkNew ;
                    mp_HeadLink->mp_NextLink=mp_HeadLink;
                    mp_HeadLink->mp_PrevLink=mp_HeadLink;
                }
                else
                {
                    ZCLink* VP_TailLink = mp_HeadLink->mp_PrevLink ;

                    ZCLink::JoinLink(VP_TailLink, AP_LinkNew);
                    ZCLink::MakeRing(mp_HeadLink, AP_LinkNew);
                }/*
                else*/
            }
            else
            {
                ++ml_LinkSize;

                ZCLink* AP_PrevStd = AP_LinkStd->mp_PrevLink ;

                ZCLink::JoinLink(AP_PrevStd, AP_LinkNew);
                ZCLink::JoinLink(AP_LinkNew, AP_LinkStd);
            }/*
            else*/
        }/*
        void JoinBefore(ZCLink* AP_LinkNew, ZCLink* AP_LinkStd)*/


  /*protected:*/
    public   :


        void JoinAfter(ZtCObjList& rhs, ZCLinkOpt AO_StdOpt)
        {
            if(this == &rhs     ) return;
            if(rhs.ml_LinkSize<1) return;

            if(!bool(AO_StdOpt)) // 맨 앞에 삽입
            {
                if(ml_LinkSize==0)
                {
                    mp_HeadLink = rhs.mp_HeadLink ;
                    ml_LinkSize = rhs.ml_LinkSize ;
                }
                else
                {
                    ZCLink* VP_TailLink = rhs.mp_HeadLink->mp_PrevLink;

                    ZCLink::MakeRing(rhs.mp_HeadLink, mp_HeadLink->mp_PrevLink);
                    ZCLink::JoinLink(    VP_TailLink, mp_HeadLink             );

                    mp_HeadLink  = rhs.mp_HeadLink ;
                    ml_LinkSize += rhs.ml_LinkSize ;
                }/*
                else*/
            }
            else // bool(AO_StdOpt)
            {
                ZCLink* VP_RhsTail= rhs.mp_HeadLink->mp_PrevLink ;
                ZCLink* VP_LinkStd= &AO_StdOpt.value()           ;
                ZCLink* VP_StdNext= VP_LinkStd->mp_NextLink      ;

                ZCLink::JoinLink(VP_LinkStd, rhs.mp_HeadLink);
                ZCLink::JoinLink(VP_RhsTail, VP_StdNext     );

                ml_LinkSize += rhs.ml_LinkSize ;
            }/*
            else // bool(AO_StdOpt)*/

            rhs.mp_HeadLink = 0;
            rhs.ml_LinkSize = 0;
        }/*
        void JoinAfter (ZtCObjList& rhs, ZCLinkOpt AO_StdOpt)*/

        void JoinBefore(ZtCObjList& rhs, ZCLinkOpt AO_StdOpt)
        {
            if(this == &rhs     ) return;
            if(rhs.ml_LinkSize<1) return;

            if(!bool(AO_StdOpt)) // 맨 뒤에 삽입
            {
                if(ml_LinkSize==0)
                {
                    mp_HeadLink = rhs.mp_HeadLink ;
                    ml_LinkSize = rhs.ml_LinkSize ;
                }
                else
                {
                    ZCLink* VP_RhsTail = rhs.mp_HeadLink->mp_PrevLink ;
                    ZCLink* VP_LhsTail =     mp_HeadLink->mp_PrevLink ;

                    ZCLink::JoinLink(VP_LhsTail , rhs.mp_HeadLink);
                    ZCLink::MakeRing(mp_HeadLink,     VP_RhsTail );

                    ml_LinkSize += rhs.ml_LinkSize ;
                }/*
                else*/
            }
            else // bool(AO_StdOpt)
            {
                ZCLink* VP_RhsHead = rhs.mp_HeadLink             ;
                ZCLink* VP_RhsTail = rhs.mp_HeadLink->mp_PrevLink;
                ZCLink* VP_LinkStd= &AO_StdOpt.value()           ;
                ZCLink* VP_PrevStd = VP_LinkStd     ->mp_PrevLink;

                ZCLink::JoinLink(VP_PrevStd, VP_RhsHead);
                ZCLink::JoinLink(VP_RhsTail, VP_LinkStd);

                ml_LinkSize += rhs.ml_LinkSize ;
            }/*
            else // bool(AO_StdOpt)*/

            rhs.mp_HeadLink = 0;
            rhs.ml_LinkSize = 0;
        }/*
        void JoinBefore(ZtCObjList& rhs, ZCLinkOpt AO_StdOpt)*/


  /*public   :*/
    protected:


        ZCLink* CutLink(ZCLink* AP_CutLink)
        {
            if(AP_CutLink==mp_HeadLink)
            {
                if(mp_HeadLink==mp_HeadLink->mp_PrevLink)
                    mp_HeadLink=0;
                else
                {
                    ZCLink::MakeRing ////////////////////////////
                        (
                            mp_HeadLink=mp_HeadLink->mp_NextLink,
                            AP_CutLink->mp_PrevLink
                        );
                    /////////////////////////////////////////////
                }/*
                else*/
            }
            else if(AP_CutLink==mp_HeadLink->mp_PrevLink)
            {
                ZCLink::MakeRing(mp_HeadLink, AP_CutLink->mp_PrevLink);
            }
            else
            {
                ZCLink::JoinLink
                    (AP_CutLink->mp_PrevLink, AP_CutLink->mp_NextLink);
            }

            return (--ml_LinkSize, AP_CutLink);
        }/*
        protected: ZCLink* CutLink(ZCLink* AP_CutLink)*/


        TypeThis& CutLink  /*##########################################################*/
            (
                ZCLink*   AP_CutHead ,
                ZCLink*   AP_CutTail ,
                TypeSize  AL_CutSize ,
                TypeThis& ARR_Rhs
            )
        /*#############################################################################*/
        {
            // AP_CutHead 는 삭제하려는 링크의 범위의 앞의 링크
            // AP_CutTail 은 삭제하려는 링크의 범위의 뒤의 링크
            // ARR_Rhs 은 비어 있어야 한다.

            if(this==&ARR_Rhs) return *this ;

            if(ml_LinkSize<1) return ARR_Rhs;

            ZCLink* VP_TailLink = mp_HeadLink->mp_PrevLink;

            if(AP_CutHead==mp_HeadLink && AP_CutTail==VP_TailLink)
            {
                mp_HeadLink=0;  // 모든 링크를 삭제할 때.
            }
            else if(AP_CutHead==mp_HeadLink)
            {
                ZCLink::MakeRing
                    (
                        mp_HeadLink=AP_CutTail->mp_NextLink, VP_TailLink
                    );
                ////////////////
            }
            else if(AP_CutTail==VP_TailLink)
            {
                ZCLink::MakeRing
                    (
                        mp_HeadLink, AP_CutHead->mp_PrevLink
                    );
                ////////////////
            }
            else
            {
                ZCLink::JoinLink
                    (
                        AP_CutHead->mp_PrevLink, AP_CutTail->mp_NextLink
                    );
                ////////////////
            }


            ml_LinkSize -= AL_CutSize;


            // ARR_Rhs 은 비어 있어야 한다.

            ZCLink::MakeRing(AP_CutHead, AP_CutTail);

            ARR_Rhs.mp_HeadLink = AP_CutHead ;
            ARR_Rhs.ml_LinkSize = AL_CutSize ;

            return ARR_Rhs; /*:::::::::::::::::::::*/
        }/*
        TypeThis& CutLink  ##############################################################
            (
                ZCLink*   AP_CutHead ,
                ZCLink*   AP_CutTail ,
                TypeSize  AL_CutSize ,
                TypeThis& ARR_Rhs
            )
        ###############################################################################*/


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

            ■  AP_CutHead 는 삭제하려는 링크의 범위의 앞의 링크
                AP_CutTail 은 삭제하려는 링크의 범위의 뒤의 링크
                이 범위의 링크를 AP_RhsStd 뒤에 붙인다.

                AP_RhsStd 이 0 이면, rhs 의 앞에 붙인다.

            ■  bool AB_After 추가. -- 2025-10-07 09:36

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

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

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

            ZCLink* VP_TailLink = mp_HeadLink->mp_PrevLink;

            if(AP_CutHead==mp_HeadLink && AP_CutTail==VP_TailLink)
            {
                mp_HeadLink=0;  // 모든 링크를 삭제할 때.
            }
            else if(AP_CutHead==mp_HeadLink)
            {
                ZCLink::MakeRing ///////////////
                  (
                      mp_HeadLink =
                          AP_CutTail->mp_NextLink,
                      VP_TailLink
                  );
                ////////////////////////////////
            }
            else if(AP_CutTail==VP_TailLink)
            {
                ZCLink::MakeRing ///////////////
                    (
                        mp_HeadLink,
                        AP_CutHead->mp_PrevLink
                    );
                ////////////////////////////////
            }
            else
            {
                ZCLink::JoinLink ///////////////
                    (
                        AP_CutHead->mp_PrevLink,
                        AP_CutTail->mp_NextLink
                    );
                ////////////////////////////////
            }

            ml_LinkSize -= AL_CutSize;


            if(rhs.size()<1)
            {
                ZCLink::MakeRing
                  ( AP_CutHead, AP_CutTail ) ;

                rhs.mp_HeadLink = AP_CutHead ;
            }
            else if(AB_After)
            {
                if(AP_RhsStd==0) // 맨 앞에 삽입.
                {
                    ZCLink* VP_RhsHead = rhs.mp_HeadLink              ;
                    ZCLink* VP_RhsTail = rhs.mp_HeadLink->mp_PrevLink ;

                    ZCLink::JoinLink(AP_CutTail, VP_RhsHead);
                    ZCLink::MakeRing(AP_CutHead, VP_RhsTail);

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

                    ZCLink::JoinLink(AP_RhsStd , AP_CutHead   );
                    ZCLink::JoinLink(AP_CutTail, VP_RhsStdNext);
                }
            }
            else // !AB_After
            {
                if(AP_RhsStd==0) // 맨 뒤에 삽입.
                {
                    ZCLink* VP_RhsHead = rhs.mp_HeadLink              ;
                    ZCLink* VP_RhsTail = rhs.mp_HeadLink->mp_PrevLink ;

                    ZCLink::JoinLink(VP_RhsTail, AP_CutHead);
                    ZCLink::MakeRing(VP_RhsHead, AP_CutTail);
                }
                else // AP_RhsStd 의 앞에 삽입.
                {
                    ZCLink* VP_RhsStdPrev = AP_RhsStd->mp_PrevLink ;

                    ZCLink::JoinLink(VP_RhsStdPrev, AP_CutHead);
                    ZCLink::JoinLink(AP_CutTail   , AP_RhsStd );

                    if(AP_RhsStd==rhs.mp_HeadLink)
                        rhs.mp_HeadLink = AP_CutHead ;
                }
            }/*
            else // !AB_After*/

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


        ZtCObjList& CopyLink /*########################################################*/
            (
                const ZCLink* AP_CopyLink  ,
                TypeSize      AL_FarNum    ,
                TypeThis&     ARR_Rhs
            )   const
        /*#############################################################################*/
        {
            /*/////////////////////////////////////////////////////////

            ■  AP_CopyLink 부터 AP_CopyLink->GetNextPrevPtr(AL_FarNum)
                링크까지를 복사한다.

                AL_FarNum 은 0 이상이어야 한다.
                총 FarNum + 1 개의 링크가 만들어진다.

                ARR_Rhs 은 비어 있어야 한다. -- 2025-10-06 13:01

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

            if(ARR_Rhs.IsEmpty()!=true)
            {
                return ARR_Rhs;
            }/*
            if(ARR_Rhs.IsEmpty()!=true)*/

            ZCLink* VP_HeadLink=0;
            ZCLink* VP_TailLink=0;

            GetManyLinkCopy /////////////////////////////
                (
                    const_cast<ZCLink*>(AP_CopyLink),
                    AL_FarNum   ,
                    VP_HeadLink ,
                    VP_TailLink
                );
            /////////////////////////////////////////////

            ZCLink::MakeRing(VP_HeadLink, VP_TailLink);

            TypeThis VO_TempList;

            VO_TempList.mp_HeadLink = VP_HeadLink ;
            VO_TempList.ml_LinkSize =
                (AL_FarNum<0 ? -AL_FarNum : AL_FarNum)+1 ;

            return ARR_Rhs.JoinTail(VO_TempList);
        }/*
        ZtCObjList& CopyLink ############################################################
            (
                const ZCLink* AP_CopyLink  ,
                TypeSize      AL_FarNum    ,
                TypeThis&     ARR_Rhs
            )   const
        ###############################################################################*/


        ZtCObjList& MakeDefault
            (TypeSize AL_DefaultSize, ZtCObjList& ARR_Rhs) const
        {
            // must AL_DefaultSize > 0

            ZCLink* VP_HeadLink=0;
            ZCLink* VP_TailLink=0;

            GetManyLink
                (AL_DefaultSize, RR(VP_HeadLink), RR(VP_TailLink));
            ZCLink::MakeRing(VP_HeadLink, VP_TailLink);

            ARR_Rhs.mp_HeadLink= VP_HeadLink    ;
            ARR_Rhs.ml_LinkSize= AL_DefaultSize ;

            return ARR_Rhs; /*:::::::::::::::::::::::::::::::::::*/
        }/*
        ZtCObjList& MakeDefault
            (TypeSize AL_DefaultSize, ZtCObjList& ARR_Rhs) const*/


        void GetManyLink(
            TypeSize AL_LinkSize, ZCLink*& APR_HeadLink, ZCLink*& APR_TailLink) const
        {
            mo_FreeObjt.SendFreeOut
                (AL_LinkSize, RR(APR_HeadLink), RR(APR_TailLink));
        }/*
        void GetManyLink(
            TypeSize AL_LinkSize, ZCLink*& APR_HeadLink, ZCLink*&  APR_TailLink) const */


        void GetManyLinkCopy /*########################################################*/
            (
                ZCLink*   AP_CopyLink , TypeSize  AL_FarNum   ,
                ZCLink*&  APR_HeadLink, ZCLink*&  APR_TailLink
            )   const
        /*#############################################################################*/
        {
            // AL_FarNum 의 절대값 + 1 개의 링크가 생성된다.

            mo_FreeObjt.SendFreeOutCopy
                (AP_CopyLink, AL_FarNum, RR(APR_HeadLink), RR(APR_TailLink));
        }/*
        void GetManyLinkCopy ############################################################
            (
                ZCLink*   AP_CopyLink , TypeSize   AL_FarNum   ,
                ZCLink*&  APR_HeadLink, ZCLink*&  APR_TailLink
            )   const
        ###############################################################################*/


  /*protected:*/
    public   :


        ZtCObjList()
        {
            mp_HeadLink = 0;
            ml_LinkSize = 0;
        }/*
        ZtCObjList()*/

        ZtCObjList(const ZtCObjList& rhs):mp_HeadLink(0),ml_LinkSize(0)
        {
            *this=rhs;
        }/*
        ZtCObjList(const ZtCObjList& rhs)*/


        virtual ~ZtCObjList()
        {
            DeleteAll();
        #if(_CODE_NEW_)
            mo_FreeObjt.DeleteHeap();
        #endif
        }/*
        virtual ~ZtCObjList()*/


        ZtCObjList& operator=(const ZtCObjList& rhs)
        {
            if(rhs.ml_LinkSize<1)
            {
                return DeleteAll();
            }
            if(ml_LinkSize<=rhs.ml_LinkSize)
            {
                AddDefault(rhs.ml_LinkSize-ml_LinkSize, ml_LinkSize+1);
            }
            else // ml_LinkSize > rhs.ml_LinkSize
            {
                ZtCObjList VO_StoreList;

                CutLink  ////////////////////////////////////////////////
                    (
                        GetLinkPtr(rhs.ml_LinkSize+1),
                        GetLinkPtr(    ml_LinkSize  ),
                        ml_LinkSize - rhs.ml_LinkSize,
                        RR(VO_StoreList)
                    ).  DeleteAll();
                /////////////////////////////////////////////////////////
            }/*
            else*/


            ZCLink* pRhsLink = rhs.mp_HeadLink;
            ZCLink* pLhsLink =     mp_HeadLink;

            __for1(TypeSize, i, ml_LinkSize)
            {
                **pLhsLink = ** pRhsLink ;

                pLhsLink = pLhsLink->mp_NextLink;
                pRhsLink = pRhsLink->mp_NextLink;
            }/*
            __for1(TypeSize, i, ml_LinkSize)*/

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


        bool IsEmpty() const{ return mp_HeadLink==0 ; }
        bool empty  () const{ return mp_HeadLink==0 ; }


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

        TypeSize capacity() const
            { return size()+mo_FreeObjt.size(); }

        TypeSize GetFreeSize() const
          { return mo_FreeObjt.size(); }
        TypeSize size_free  () const
          { return mo_FreeObjt.size(); }


        ZCLink* GetHeadLinkPtr(){return mp_HeadLink;}
        ZCLink* GetTailLinkPtr()
        {
            return mp_HeadLink==0 ? 0 : mp_HeadLink->mp_PrevLink ;
        }/*
        ZCLink* GetTailLinkPtr()*/


        const ZCLink* GetHeadLinkPtr() const{return mp_HeadLink;}
        const ZCLink* GetTailLinkPtr() const
        {
            return mp_HeadLink==0 ? 0 : mp_HeadLink->mp_PrevLink ;
        }/*
        const ZCLink* GetTailLinkPtr() const*/


        ZCLinkOpt GetHeadLinkOpt(){return ZCLinkOpt(mp_HeadLink);}
        ZCLinkOpt GetTailLinkOpt()
        {
            if(mp_HeadLink==0) return ZCLinkOpt(0);

            return ZCLinkOpt(*mp_HeadLink->mp_PrevLink);
        }/*
        ZCLinkOpt GetTailLinkOpt()*/

        const ZCLinkOpt GetHeadLinkOpt() const{return ZCLinkOpt(mp_HeadLink);}
        const ZCLinkOpt GetTailLinkOpt() const
        {
            if(mp_HeadLink==0) return ZCLinkOpt(0);

            return ZCLinkOpt(*mp_HeadLink->mp_PrevLink);
        }/*
        const ZCLinkOpt GetTailLinkOpt()*/



        Type& operator[](TypeSize AL_Index) // start by 1
        {
            return GetLinkPtr(AL_Index)->GetData();
        }/*
        Type& operator[](TypeSize AL_Index)*/

        const Type& operator[](TypeSize AL_Index) const
        {
            return GetLinkPtr(AL_Index)->GetData();
        }/*
        Type& operator[](TypeSize AL_Index) const*/


        ZCFreeHeap& GetCFreeHeap() const
        {
            return mo_FreeObjt;
        }/*
        ZCFreeHeap& GetCFreeHeap() const*/


        TypeSize Find /*###############################################################*/
            (
                TypeArg  AR_SearchType        ,
                TypeSize AL_FirstFindIndex =1 ,
                bool     AB_DoFindFromFront=true
            )   const
        /*#############################################################################*/
        {
            // AB_DoFindFromFront==true 이면 AL_FirstFindIndex 번째 링크부터
            // 다음 링크로 순회하면서 GetData() == AR_SearchType 이 되는
            // 최초의 위치를 반환한다.

            const bool CB_IsTrue = //////////////////
                (
                    mp_HeadLink       == 0      ||
                    AL_FirstFindIndex <  1      ||
                    AL_FirstFindIndex > ml_LinkSize
                ) ;
            if(CB_IsTrue) return 0;  ////////////////

            TypeSize VL_FindIndex=AL_FirstFindIndex; const
            ZCLink*  VP_TempLink =GetLinkPtr(AL_FirstFindIndex);

            if(AB_DoFindFromFront==true)
            {
                do /////////
                {
                    if(VP_TempLink->GetData()==AR_SearchType) return VL_FindIndex;
                    if(VL_FindIndex          ==ml_LinkSize  ) return 0           ;

                    VP_TempLink=VP_TempLink->mp_NextLink;  ++VL_FindIndex;
                }
                while(true);
            }
            else // AB_DoFindFromFront!=true
            {
                do /////////
                {
                    if(VP_TempLink->GetData()==AR_SearchType) return VL_FindIndex;
                    if(VL_FindIndex          ==1            ) return 0           ;

                    VP_TempLink=VP_TempLink->mp_PrevLink;  --VL_FindIndex;
                }
                while(true);
            }/*
            else // AB_DoFindFromFront!=true*/

            return 0;
        }/*
        TypeSize Find ###################################################################
            (
                TypeArg  AR_SearchType        ,
                TypeSize AL_FirstFindIndex =1 ,
                bool     AB_DoFindFromFront=true
            )   const
        ###############################################################################*/


        TypeSize Find  /*##############################################################*/
            (
                const ZCLink& AR_SearchLink       ,
                TypeSize      AL_FirstFindIndex =1,
                bool          AB_DoFindFromFront=true
            )   const
        /*#############################################################################*/
        {
            if(mp_HeadLink==0 || AL_FirstFindIndex<1 || AL_FirstFindIndex>ml_LinkSize)
                return 0;
            //////////////////////////////////////////////////////////////////////////

            TypeSize VL_FindIndex= AL_FirstFindIndex;
            ZCLink*  VP_TempLink = const_cast<ZCLink*>
                ( GetLinkPtr(AL_FirstFindIndex) );

            if(AB_DoFindFromFront==true)
            {
                do /**/
                {
                    if(VP_TempLink ==&AR_SearchLink) return VL_FindIndex;
                    if(VL_FindIndex==ml_LinkSize   ) return 0           ;

                    VP_TempLink=VP_TempLink->mp_NextLink;  ++VL_FindIndex;
                }
                while(true);
            }
            else // AB_DoFindFromFront!=true
            {
                do /**/
                {
                    if(VP_TempLink ==&AR_SearchLink) return VL_FindIndex;
                    if(VL_FindIndex==1             ) return 0           ;

                    VP_TempLink=VP_TempLink->mp_PrevLink;  --VL_FindIndex;
                }
                while(true);
            }/*
            else // AB_DoFindFromFront!=true*/

            return 0;
        }/*
        TypeSize Find  ##################################################################
            (
                ZCLink&  AR_SearchLink        ,
                TypeSize AL_FirstFindIndex =1 ,
                bool     AB_DoFindFromFront=true
            )   const
        ###############################################################################*/


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

        ■  FindData(TypeArg, ~) 함수가 없다면, TypeArg 이 const Type& 으로 정의되어 있는 경우,
            const Type& 에 대해서만 찾기를 수행할 수 있고, Type& 에 대해서는 찾기를 수행할 수 없다.

            -- 2010-05-29 21:31:00

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

        TypeSize FindData(
            TypeArg AR_SearchType, TypeSize AL_FirstFindIndex=1, bool AB_DoFindFromFront=true) const
        {
            return Find(AR_SearchType, AL_FirstFindIndex, AB_DoFindFromFront);
        }/*
        TypeSize FindData(
            TypeArg AR_SearchType, TypeSize AL_FirstFindIndex=1, bool AB_DoFindFromFront=true) const*/


        ZCLink* GetLinkPtr(TypeSize AL_Index)
        {
            TypeSize VI_LeftDistance =AL_Index-1            ;
            TypeSize VI_RightDistance=ml_LinkSize-AL_Index+1;
            TypeSize VI_ShortDistance=
                (VI_LeftDistance<=VI_RightDistance ? VI_LeftDistance : -VI_RightDistance);

            return mp_HeadLink->GetNextPrevPtr(VI_ShortDistance);
        }/*
        ZCLink* GetLinkPtr(TypeSize AL_Index)*/

        const ZCLink* GetLinkPtr(TypeSize AL_Index) const    // or 'ZCLink const * const GetLinkPtr(TypeSize AL_Index) const'
        {
            TypeSize VI_LeftDistance = AL_Index-1             ;
            TypeSize VI_RightDistance= ml_LinkSize -AL_Index+1;
            TypeSize VI_ShortDistance=
                (VI_LeftDistance<=VI_RightDistance ? VI_LeftDistance : -VI_RightDistance);

            return mp_HeadLink->GetNextPrevPtr(VI_ShortDistance);
        }/*
        const ZCLink* GetLinkPtr(TypeSize AL_Index) const*/


        ZCLinkOpt GetLinkOpt(TypeSize AL_Index)
        {
            if(mp_HeadLink==0) return ZCLinkOpt(0);

            return ZCLinkOpt(*GetLinkPtr(AL_Index));
        }/*
        ZCLinkOpt GetLinkOpt(TypeSize AL_Index)*/

        const ZCLinkOpt GetLinkOpt(TypeSize AL_Index) const
        {
            if(mp_HeadLink==0) return ZCLinkOpt(0);

            return ZCLinkOpt(*GetLinkPtr(AL_Index));
        }/*
        const ZCLinkOpt GetLinkOpt(TypeSize AL_Index) const*/



        ZtCObjList& DeleteAll()
        {
            if(mp_HeadLink==0) return *this;

            mo_FreeObjt.RecvFreeIn
                ( ml_LinkSize, mp_HeadLink, mp_HeadLink->mp_PrevLink );

            mp_HeadLink= 0;  ml_LinkSize= 0;  return *this;
        }/*
        ZtCObjList& DeleteAll()*/

        ZtCObjList& clear()
        {
            return this->DeleteAll();
        }/*
        ZtCObjList& clear()*/


        ZtCObjList& DeleteHeap()
        {
            mo_FreeObjt.DeleteHeap(); return *this;
        }/*
        ZtCObjList& DeleteHeap()*/


        ZtCObjList& DeleteLink(ZCLink& AR_DeleteLink)
        {
        #if(_CODE_NEW_)
            mo_FreeObjt.RecvFreeIn
                ( this->CutLink(&AR_DeleteLink) );
        #else
            delete this->CutLink(&AR_DeleteLink);
        #endif
            return *this;
        }/*
        ZtCObjList& DeleteLink(ZCLink& AR_DeleteLink)*/


        ZtCObjList& Delete(ZCLink& AR_DeleteLink)
        {
            return DeleteLink(&AR_DeleteLink);
        }/*
        ZtCObjList& Delete(ZCLink& AR_DeleteLink)*/

        ZtCObjList& Delete(TypeSize AL_DeletePos)
        {
            if(AL_DeletePos<1 || this->ml_LinkSize>AL_DeletePos)
              { return *this; }
            Delete(this->GetLinkPtr(AL_DeletePos)); return *this;
        }/*
        ZtCObjList& Delete(TypeSize AL_DeletePos)*/


        ZtCObjList& DeleteHead()
        {
            if(ml_LinkSize>0)
            #if(_CODE_NEW_)
                mo_FreeObjt.RecvFreeIn
                     ( this->CutLink(mp_HeadLink) );
            #else
                delete this->CutLink(mp_HeadLink)  ;
            #endif

            return *this;
        }/*
        ZtCObjList& DeleteHead()*/


        void DeleteHead(TypeSize AL_DelSize)
        {
            // AL_DelSize 개의 링크를 앞 부분에서 삭제

            if(ml_LinkSize<1 || AL_DelSize<1){ return; }

            if(AL_DelSize> ml_LinkSize){ AL_DelSize=ml_LinkSize; }

            if(AL_DelSize==ml_LinkSize)
            {
                GetCFreeHeap().RecvFreeIn
                    (ml_LinkSize, mp_HeadLink, mp_HeadLink->mp_PrevLink);
                mp_HeadLink=0 ;
                ml_LinkSize=0 ;

                return;
            }/*
            if(AL_DelSize==ml_LinkSize)*/

            ZCLink* VP_TailLink= mp_HeadLink->mp_PrevLink    ;
            ZCLink* VP_NewHead = &((*mp_HeadLink)+AL_DelSize);
            GetCFreeHeap().RecvFreeIn
                (AL_DelSize, mp_HeadLink, VP_NewHead->mp_PrevLink);

            mp_HeadLink  = VP_NewHead   ;
            ml_LinkSize -= AL_DelSize   ;

            ZCLink::MakeRing(mp_HeadLink, VP_TailLink);
        }/*
        void DeleteHead(TypeSize AL_DelSize)*/


        ZtCObjList& DeleteTail()
        {
            if(ml_LinkSize>0)
            #if(_CODE_NEW_)
                mo_FreeObjt.RecvFreeIn
                     ( this->CutLink(mp_HeadLink->mp_PrevLink) );
            #else
                delete this->CutLink(mp_HeadLink->mp_PrevLink)  ;
            #endif

            return *this;
        }/*
        ZtCObjList& DeleteTail()*/


        void DeleteTail(TypeSize AL_DelSize)
        {
            if(ml_LinkSize==0 || AL_DelSize<1){ return; }

            if(AL_DelSize> ml_LinkSize){ AL_DelSize=ml_LinkSize; }

            if(AL_DelSize==ml_LinkSize)
            {
                GetCFreeHeap().RecvFreeIn
                    (ml_LinkSize, mp_HeadLink, mp_HeadLink->mp_PrevLink);
                mp_HeadLink=0 ;
                ml_LinkSize=0 ;

                return;
            }/*
            if(AL_DelSize==ml_LinkSize)*/

            ZCLink* VP_TailLink= mp_HeadLink->mp_PrevLink    ;
            ZCLink* VP_NewTail = &((*VP_TailLink)-AL_DelSize);
            GetCFreeHeap().RecvFreeIn
                (AL_DelSize, VP_NewTail->mp_NextLink, VP_TailLink);

            ml_LinkSize -= AL_DelSize    ;

            ZCLink::MakeRing(mp_HeadLink, VP_NewTail);
        }/*
        void DeleteTail(TypeSize AL_DelSize)*/


        ZCLink& AddDefault(TypeSize AL_DefSize, TypeSize AL_AddPos)
        {
            if(AL_DefSize<1) AL_DefSize= 1;
            if(AL_AddPos <1) AL_AddPos = 1;

            ZtCObjList VO_StoreList;  MakeDefault
                ( AL_DefSize, RR(VO_StoreList) ) ;

            ZCLink* VP_HeadLink= VO_StoreList.mp_HeadLink;

            if(AL_AddPos==1)
                 JoinAfter(VO_StoreList, ZCLinkOpt(0)           );
            else JoinAfter(VO_StoreList, GetLinkOpt(AL_AddPos-1));

            return *VP_HeadLink;
        }/*
        ZCLink& AddDefault(TypeSize AL_DefSize, TypeSize AL_AddPos)*/


        ZtCObjList& AddHead(TypeArg AR_Type)
        {
            ZCLink* VP_NewNode = mo_FreeObjt.SendFreeOut();

            if(TypeMoveObj::ZEUseMoveObj>0) ////////////////////
            {
                TypeMoveObj::Exec(**VP_NewNode, AR_Type);

                JoinAfter(VP_NewNode, 0); return *this  ;
            }
            **VP_NewNode = AR_Type; ////////////////////////////

            JoinAfter(VP_NewNode, 0); return *this;
        }/*
        ZtCObjList& AddHead(TypeArg AR_Type)*/

        ZtCObjList& AddHead(const ZtCObjList& rhs)
        {
            if(this==&rhs) return *this ;

            ZtCObjList VO_StoreList(rhs);

            JoinAfter(VO_StoreList, 0); return *this;
        }/*
        ZtCObjList& AddHead(const ZtCObjList& rhs)*/


        ZtCObjList& AddTail(TypeArg AR_Type)
        {
            ZCLink* VP_NewNode = mo_FreeObjt.SendFreeOut();

            if(TypeMoveObj::ZEUseMoveObj>0) ////////////////////
            {
                TypeMoveObj::Exec(**VP_NewNode, AR_Type);

                JoinAfter(VP_NewNode, GetTailLinkPtr()); return *this;
            }
            **VP_NewNode = AR_Type; ////////////////////////////

            JoinAfter
                (VP_NewNode, GetTailLinkPtr());
            return *this ;
        }/*
        ZtCObjList& AddTail(TypeArg AR_Type)*/

        ZtCObjList& AddTail(const ZtCObjList& rhs)
        {
            ZtCObjList VO_StoreList(rhs);  return JoinTail(VO_StoreList);
        }/*
        ZtCObjList& AddTail(const ZtCObjList& rhs)*/


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

        ■  ZCLink* AddHeadDef() 함수의 코드 중 return 문이 return *this
            라고 되어 있었다. 10 여년간 이를 모른 것이다. 자그마치 10 여년간!
            -- 2015-02-21- 21:36:00

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

        ZCLink& AddHeadDef()
        {
            ZCLink* VP_NewLink = mo_FreeObjt.SendFreeOut();

            JoinAfter(VP_NewLink, 0); return *VP_NewLink  ;
        }
        ZCLink& AddTailDef()
        {
            ZCLink* VP_NewLink = mo_FreeObjt.SendFreeOut();

            JoinAfter(VP_NewLink, GetTailLinkPtr()); return *VP_NewLink;
        }/*
        ZCLink& AddTailDef()*/


        ZtCObjList& pop_back (TypeArg AR_Type){return AddHead(AR_Type);}
        ZtCObjList& push_back(TypeArg AR_Type){return AddTail(AR_Type);}


        ZtCObjList& JoinHead(ZtCObjList& rhs)
        {
            if(this==&rhs) return *this;  JoinAfter(rhs, 0); return *this;
        }/*
        ZtCObjList& JoinHead(ZtCObjList& rhs)*/

        ZtCObjList& JoinHead(ZtCObjList& rhs, ZCLink& AR_CLink)
        {
            // rhs 의 AP_CLink 를 앞으로 연결한다.

            if(this==&rhs) return *this;

            JoinAfter
                (rhs.CutLink(&AR_CLink), 0);

            return *this;
        }/*
        ZtCObjList& JoinHead(ZtCObjList& rhs, ZCLink& AR_CLink)*/

        ZtCObjList& JoinTail(ZtCObjList& rhs)
        {
            if(this==&rhs) return *this;  JoinAfter(rhs, GetTailLinkPtr()); return *this;
        }/*
        ZtCObjList& JoinTail(ZtCObjList& rhs)*/

        ZtCObjList& JoinTail(ZtCObjList& rhs, ZCLink& AR_CLink)
        {
            // rhs 의 AR_CLink 를 뒤로 연결한다.

            if(this==&rhs) return *this;

            JoinAfter //////////////////////////////////////
                (
                    rhs.CutLink(&AR_CLink), GetTailLinkPtr()
                );
            return *this; //////////////////////////////////
        }/*
        ZtCObjList& JoinTail(ZtCObjList& rhs, ZCLink& AR_CLink)*/


        ZtCObjList& JoinAfter  /*######################################################*/
            (
                ZtCObjList& rhs         ,
                ZCLink&     AR_LinkOfRhs,
                ZCLinkOpt   AO_StdOpt
            )
        /*#############################################################################*/
        {
            // rhs 의 AP_LinkOfRhs 링크를 잘라서 AO_StdOpt 뒤에 붙인다.

            if(this==&rhs) return *this;

            JoinAfter(
                rhs.CutLink(&AR_LinkOfRhs), AO_StdOpt.Raw() );

            return *this;
        }/*
        ZtCObjList& JoinAfter  ##########################################################
            (
                ZtCObjList& rhs         ,
                ZCLink&     AR_LinkOfRhs,
                ZCLinkOpt   AO_StdOpt
            )
        ###############################################################################*/


        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 의 AR_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)
          { CutLink(&AR_CutLink); rhs.JoinAfter (&AR_CutLink, 0); }

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


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


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

            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 의 AO_ObjOpt 뒤에 연결한다.

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


        ZtCObjList& CopyThis(ZtCObjList& ARR_Rhs) const
        {
            return CopyLink(mp_HeadLink, ml_LinkSize-1, RR(ARR_Rhs));
        }/*
        ZtCObjList& CopyThis(ZtCObjList& ARR_Rhs) const*/



        operator Type&()
        {
            return AddDefault(1, ml_LinkSize+1)->GetData();
        }/*
        operator Type&()*/


        Type& GetData(TypeSize AI_Index)
        {
            return GetLinkPtr(AI_Index)->GetData();
        }/*
        Type& GetData(TypeSize AI_Index)*/

        const Type& GetData(TypeSize AI_Index) const
        {
            return GetLinkPtr(AI_Index)->GetData();
        }/*
        const Type& GetData(TypeSize AI_Index) const*/


        Type& GetHeadData()
        {
            return mp_HeadLink->GetData();
        }/*
        Type& GetHeadData()*/

        Type& GetTailData()
        {
            return mp_HeadLink->mp_PrevLink->GetData();
        }/*
        Type& GetTailData()*/

        const Type& GetHeadData() const
        {
            return mp_HeadLink->GetData();
        }/*
        const Type& GetHeadData() const*/

        const Type& GetTailData() const
        {
            return mp_HeadLink->mp_PrevLink->GetData();
        }/*
        const Type& GetTailData() const*/


        ZCDataOpt GetHeadDataOpt()
        {
            if(mp_HeadLink==0) return ZCDataOpt(0);

            return ZCDataOpt(**mp_HeadLink);
        }/*
        ZCDataOpt GetHeadDataOpt()*/
        ZCDataOpt GetTailDataOpt()
        {
            if(mp_HeadLink==0) return ZCDataOpt(0);

            return ZCDataOpt(**mp_HeadLink->mp_PrevLink);
        }/*
        ZCDataOpt GetTailDataOpt()*/


        const ZCDataOpt GetHeadDataOpt() const
        {
            if(mp_HeadLink==0) return ZCDataOpt(0);

            return ZCDataOpt(**mp_HeadLink);
        }/*
        const ZCDataOpt GetHeadDataOpt() const*/
        const ZCDataOpt GetTailDataOpt() const
        {
            if(mp_HeadLink==0) return ZCDataOpt(0);

            return ZCDataOpt(**mp_HeadLink->mp_PrevLink);
        }/*
        const ZCDataOpt GetTailDataOpt() const*/


        ZCDataOpt GetDataOpt(TypeSize AI_Index)
        {
            if(mp_HeadLink==0) return ZCDataOpt(0);

            return ZCDataOpt( GetLinkPtr(AI_Index)->GetData() );
        }/*
        ZCDataOpt GetDataOpt(TypeSize AI_Index)*/

        const ZCDataOpt GetDataOpt(TypeSize AI_Index) const
        {
            if(mp_HeadLink==0) return ZCDataOpt(0);

            return ZCDataOpt( GetLinkPtr(AI_Index)->GetData() );
        }/*
        const ZCDataOpt GetDataOpt(TypeSize AI_Index) const*/


        Type& front(){return GetHeadData();}
        Type& back (){return GetTailData();}

        const Type& front() const{return GetHeadData();}
        const Type& back () const{return GetTailData();}


        ZtCObjList& Rotate(TypeSize AL_RotateNum)
        {
            if(ml_LinkSize>0) mp_HeadLink =
                mp_HeadLink->GetNextPrevPtr(AL_RotateNum);

            return *this;
        }/*
        ZtCObjList& Rotate(TypeSize AL_RotateNum)*/

        ZtCObjList& Rotate    ()
            { if(ml_LinkSize>0) mp_HeadLink = mp_HeadLink->mp_NextLink ; return *this; }
        ZtCObjList& RotateBack()
            { if(ml_LinkSize>0) mp_HeadLink = mp_HeadLink->mp_PrevLink ; return *this; }


        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_LinkSize)*/
        }/*
        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_LinkSize)*/
        }/*
        template
            < typename TFunctor  , typename   TTypeHelp1  , typename   TTypeHelp2    >
        void IterElement
            ( TFunctor AO_Functor, TTypeHelp1 AO_TypeHelp1, TTypeHelp2 AO_TypeHelp2  )
        ###############################################################################*/


        template<typename TFunctor, typename TTypeHelp>
            void IterElemRef(TFunctor AO_Functor, TTypeHelp& AR_TypeHelp)
        {
            /* TTypeHelp 을 참조로 받고 있음에 주의한다. -- 2015-09-07 02:55:00 */

            ZCLink* VP_LoopLink=mp_HeadLink;

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

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


        template
            < typename TFunctor  , typename    TTypeHelp1  , typename TTypeHelp2      >
        void IterElemRef
            ( TFunctor AO_Functor, TTypeHelp1& AR_TypeHelp1, TTypeHelp2& AR_TypeHelp2 )
        /*#############################################################################*/
        {
            /* TTypeHelp1 과 2 을 참조로 받고 있음에 주의한다. -- 2021-03-04 04:00:00 */

            ZCLink* VP_LoopLink=mp_HeadLink;

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

                VP_LoopLink = VP_LoopLink->mp_NextLink ;
            }/*
            __for0(TypeSize, i, ml_LinkSize)*/
        }/*
        template
            < typename TFunctor  , typename    TTypeHelp1  , typename TTypeHelp2      >
        void IterElemRef
            ( TFunctor AO_Functor, TTypeHelp1& AR_TypeHelp1, TTypeHelp2& AR_TypeHelp2 )
        ###############################################################################*/


        template<typename TFunctor> void IterElemRev(TFunctor AO_Functor)
        {
            // 끝에서부터 순회한다.

            if(size()<1) return;  ZCLink*
                VP_LoopLink = mp_HeadLink->mp_PrevLink;

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

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

        template<typename TFunctor, typename TTypeHelp>
            void IterElemRev(TFunctor AO_Functor, TTypeHelp AO_TypeHelp)
        {
            if(size()<1) return; //////////////////////////////

            typedef ZNsMain::ZtCCheckRef<TTypeHelp> ZCCheckRef;

            ZCLink* VP_LoopLink = mp_HeadLink->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_LinkSize)*/
        }/*
        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 )
        /*#############################################################################*/
        {
            if(size()<1) return;

            typedef ZNsMain::ZtCCheckRef<TTypeHelp1> ZCCheckRef1;
            typedef ZNsMain::ZtCCheckRef<TTypeHelp2> ZCCheckRef2;

            ZCLink* VP_LoopLink = mp_HeadLink->mp_PrevLink ;

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

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


        template<typename TFunctor> void IterElemLink(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 IterElemLink(TFunctor AO_Functor) */


        template<typename TFunctor, typename TTypeHelp>
            void IterElemLink(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_LinkSize)*/
        }/*
        template<typename TFunctor, typename TTypeHelp>
            void IterElemLink(TFunctor AO_Functor, TTypeHelp AO_TypeHelp) */


        template
            < typename TFunctor  , typename   TTypeHelp1  , typename   TTypeHelp2    >
        void IterElemLink
            ( 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_LinkSize)*/
        }/*
        template
            < typename TFunctor  , typename   TTypeHelp1  , typename   TTypeHelp2    >
        void IterElemLink
            ( TFunctor AO_Functor, TTypeHelp1 AO_TypeHelp1, TTypeHelp2 AO_TypeHelp2  )
        ###############################################################################*/


        template<typename TFunctor> void IterElemLink ///////////////////////
            (
                ZCLink&   AR_StdLink     ,
                TypeSize  AL_WorkDistance,
                TFunctor  AO_Functor
            )
        /*#################################################################*/
        {
           /* AP_StdLink 부터 AL_WorkDistance 만큼 이동하면서
            * 각 ZCLink 에 대하여 AO_Functor() 함수를 수행한다.
                (총 수행 횟수는 (AL_WorkDistance)절대값+1)
            */
            ZCLink* VP_StdLink = &AR_StdLink;

            if(AL_WorkDistance>=0)
            {
                for(TypeSize VL_Loop=0; VL_Loop<=AL_WorkDistance; ++VL_Loop)
                {
                    ZtCTypeData<TFunctor>::
                        GetObjRef(AO_Functor)(*VP_StdLink);

                    VP_StdLink = VP_StdLink->mp_NextLink ;
                }/*
                for(TypeSize VL_Loop=0; VL_Loop<=AL_WorkDistance; ++VL_Loop)*/
            }
            else // AL_WorkDistance<0
            {
                AL_WorkDistance = -AL_WorkDistance;

                for(TypeSize VL_Loop=0; VL_Loop<=AL_WorkDistance; ++VL_Loop)
                {
                    ZtCTypeData<TFunctor>::
                        GetObjRef(AO_Functor)(*VP_StdLink);

                    VP_StdLink = VP_StdLink->mp_PrevLink ;
                }/*
                for(TypeSize VL_Loop=0; VL_Loop<=AL_WorkDistance; ++VL_Loop)*/
            }/*
            else // AL_WorkDistance<0*/
        }/*
        void IterElemLink ///////////////////////////////////////////////////
            (
                ZCLink&   AR_StdLink     ,
                TypeSize  AL_WorkDistance,
                TFunctor  AO_Functor
            )
        ###################################################################*/



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

        ■  IterElement() 예제.

            #include <iostream>
            #include "ZCppMain/ZtCObjList.H"

            using namespace std;

            int main()
            {
                ZNsMain:: ZtCObjList<int> myObjList;

                myObjList.AddTail(10);
                myObjList.AddTail(20);
                myObjList.AddTail(30);
                myObjList.AddTail(40);

                struct StFunctor
                {
                    static void ShowElement(int ArgiValue){cout<<"# Value="<<ArgiValue<<endl;}
                };
                struct StFunctor2
                {
                    int MI_Index;

                    StFunctor2(){MI_Index=0;}

                    void operator()(int ArgiValue){cout<<"# index="<<++MI_Index<<", Value="<<ArgiValue<<endl;}
                };


                StFunctor2 VO_StFunctor2;

                myObjList.IterElement(StFunctor::ShowElement);
                myObjList.IterElement(&VO_StFunctor2); // linux g++ 4.4.7 에서 컴파일 에러다.
                                                       // struct StFunctor2 정의를 main() 함수 바깥으로 빼면 컴파일된다.
                return 0;
            }

        ■  -- 2014-06-16 23:34:00
        
        ///////////////////////////////////////////////////////////////////////////*/


        class ZCIterator
        {
        protected:
            mutable ZCLink*  mp_Link;
            mutable TypeSize ml_Pos ;
        public   :

            ZCIterator(ZCLink* AP_CLink=0, TypeSize AL_Pos=0)
            {
                mp_Link=AP_CLink;
                ml_Pos =AL_Pos ;
            }/*
            ZCIterator(ZCLink* AP_CLink=0, TypeSize AL_Pos=0)*/

            ZCLink* GetLink()
            {
                return mp_Link;
            }/*
            ZCLink* GetLink()*/

            const ZCLink* GetLink() const
            {
                return mp_Link;
            }/*
            const ZCLink* GetLink() const*/

            TypeSize GetPos() const
            {
                return ml_Pos;
            }/*
            TypeSize GetPos() const*/

            Type& operator *()
            {
                return mp_Link->GetData();
            }/*
            Type& operator *()*/

            const Type& operator *() const
            {
                return mp_Link->GetData();
            }/*
            const Type& operator *() const*/

            ZCIterator& operator++()
            {
                mp_Link=mp_Link->GetNextPtr(); ++ml_Pos; return *this;
            }/*
            ZCIterator& operator++()*/

            const ZCIterator& operator++() const
            {
                mp_Link=mp_Link->GetNextPtr(); ++ml_Pos; return *this;
            }/*
            const ZCIterator& operator++() const*/

            ZCIterator operator++(int)
            {
                ZCIterator VO_CIterator(*this);

                mp_Link=mp_Link->GetNextPtr();

                ++ml_Pos; return VO_CIterator;
            }/*
            ZCIterator operator++(int)*/

            const ZCIterator operator++(int) const
            {
                ZCIterator VO_CIterator(*this);

                mp_Link=mp_Link->GetNextPtr();

                ++ml_Pos;  return VO_CIterator;
            }/*
            const ZCIterator operator++(int) const*/


            ZCIterator& operator--()
            {
                mp_Link=mp_Link->GetPrevPtr(); --ml_Pos; return *this;
            }/*
            ZCIterator& operator--()*/

            const ZCIterator& operator--() const
            {
                mp_Link=mp_Link->GetPrevPtr(); --ml_Pos; return *this;
            }/*
            const ZCIterator& operator--() const*/

            ZCIterator operator--(int)
            {
                ZCIterator VO_CIterator(*this);

                mp_Link=mp_Link->GetPrevPtr();

                --ml_Pos; return VO_CIterator;
            }/*
            ZCIterator operator--(int)*/

            const ZCIterator operator--(int) const
            {
                ZCIterator VO_CIterator(*this);

                mp_Link=mp_Link->GetPrevPtr();

                --ml_Pos; return VO_CIterator;
            }/*
            ZCIterator operator--(int) const*/


            ZCIterator operator+(TypeSize AI_FarNum) const
            {
                ZCIterator VO_CIterator(*this);

                VO_CIterator.mp_Link =mp_Link->GetNextPtr(AI_FarNum);
                VO_CIterator.ml_Pos +=AI_FarNum                     ;
                
                return VO_CIterator;
            }/*
            ZCIterator operator+(TypeSize AI_FarNum) const*/

            ZCIterator operator-(TypeSize AI_FarNum) const
            {
                ZCIterator VO_CIterator(*this);

                VO_CIterator.mp_Link =mp_Link->GetNextPtr(-AI_FarNum);
                VO_CIterator.ml_Pos -=AI_FarNum                      ;
                
                return VO_CIterator;
            }/*
            ZCIterator operator-(TypeSize AI_FarNum) const*/


            bool operator==(const ZCIterator& rhs) const
            {
                return mp_Link==rhs.mp_Link && ml_Pos==rhs.ml_Pos ;
            }/*
            bool operator==(const ZCIterator& rhs) const*/
            bool operator!=(const ZCIterator& rhs) const
            {
                return mp_Link!=rhs.mp_Link || ml_Pos!=rhs.mp_Pos ;
            }/*
            bool operator!=(const ZCIterator& rhs) const*/

        public:
        };/*
        class ZCIterator*/


        ZCIterator begin()
        {
            return ZCIterator(mp_HeadLink, (ml_LinkSize>0 ? 1 : 0) );
        }/*
        ZCIterator begin()*/

        ZCIterator end()
        {
            return ZCIterator(mp_HeadLink, (ml_LinkSize>0 ? ml_LinkSize+1 : 0) );
        }/*
        ZCIterator end()*/

        const ZCIterator begin() const
        {
            return ZCIterator(mp_HeadLink, (ml_LinkSize>0 ? 1 : 0) );
        }/*
        const ZCIterator begin() const*/

        const ZCIterator end() const
        {
            return ZCIterator(mp_HeadLink, (ml_LinkSize>0 ? ml_LinkSize+1 : 0) );
        }/*
        const ZCIterator end() const*/


        void erase(ZCIterator& AR_CIterator)
        {
            return DeleteLink(AR_CIterator.GetLink(), AR_CIterator.GetPos());
        }/*
        void erase(ZCIterator& AR_CIterator)*/

        void erase(ZCIterator& AR_CIterator1, ZCIterator& AR_CIterator2)
        {
            ZtCObjList VO_CObjList;

            CutLink //////////////////////////////////////////////////
                (
                    AR_CIterator1.GetLink(),  AR_CIterator2.GetLink(),
                    AR_CIterator2.GetPos () - AR_CIterator1.GetPos (),
                    RR(VO_CObjList)
                )
            .DeleteAll(); ////////////////////////////////////////////
        }/*
        void erase(ZCIterator& AR_CIterator1, ZCIterator& AR_CIterator2)*/


        IterEasy    GetHeadIterEasy   (){return             GetHeadLinkPtr();}
        IterEasy    GetTailIterEasy   (){return             GetTailLinkPtr();}
        IterEasyID  GetHeadIterEasyID (){return (IterEasyID)GetHeadLinkPtr();}
        IterEasyID  GetTailIterEasyID (){return (IterEasyID)GetTailLinkPtr();}

        IterEasy    GetHeadIterEasy   () const{return             GetHeadLinkPtr();}
        IterEasy    GetTailIterEasy   () const{return             GetTailLinkPtr();}
        IterEasyID  GetHeadIterEasyID () const{return (IterEasyID)GetHeadLinkPtr();}
        IterEasyID  GetTailIterEasyID () const{return (IterEasyID)GetTailLinkPtr();}

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


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

        ■  순차적으로 각 원소를 순회할 수 있는 자료 구조, 즉 리스트나 배열 클래스는

                MoveNextIter(),  MovePrevIter()

            멤버를 갖는 것으로 정했다. stl 의 반복자는 너무 일반화하다보니, 성능 상의
            제약이 발생한 것 같다.

            -- 2011-06-07 20:25:00

            GetDataInIter() 를 추가했다.

            -- 2011-06-12 16:35:00

        ■  --

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

        void MoveNextIter(ZCLink*&        APR_CLink      ) const
        {
            APR_CLink=APR_CLink->GetNextPtr();
        }
        void MoveNextIter(iterator&       ARR_CIterator  )
        {
            ++ARR_CIterator;
        }
        void MoveNextIter(IterEasyID&     ARRI_IterEasyID) const
        {
            MoveNextIter((ZCLink*&)(ARRI_IterEasyID));
        }
        void MoveNextIter(const ZCLink*&  APR_CLink      ) const
        {
            APR_CLink=APR_CLink->GetNextPtr();
        }
        void MoveNextIter(const iterator& ARR_CIterator  ) const
        {
            ++ARR_CIterator;
        }
        void MoveNextIter(IterEasyIDc&    ARRI_IterEasyID) const
        {
            MoveNextIter((const ZCLink*&)(ARRI_IterEasyID));
        }/*
        void MoveNextIter(IterEasyIDc&    ARRI_IterEasyID) const*/


        void MovePrevIter(ZCLink*&        APR_CLink      ) const
        {
            APR_CLink=APR_CLink->GetPrevPtr();
        }
        void MovePrevIter(iterator&       ARR_CIterator  )
        {
            --ARR_CIterator;
        }
        void MovePrevIter(IterEasyID&     ARRI_IterEasyID) const
        {
            MovePrevIter((ZCLink*&)(ARRI_IterEasyID));
        }
        void MovePrevIter(const ZCLink*&  APR_CLink      ) const
        {
            APR_CLink=APR_CLink->GetPrevPtr();
        }
        void MovePrevIter(const iterator& ARR_CIterator  ) const
        {
            --ARR_CIterator;
        }
        void MovePrevIter(IterEasyIDc&    ARRI_IterEasyID) const
        {
            MovePrevIter((const ZCLink*&)(ARRI_IterEasyID));
        }/*
        void MovePrevIter(IterEasyIDc&    ARRI_IterEasyID) const*/


        Type& GetDataInIter(ZCLink*     AP_CLink       ){return **AP_CLink    ;}
        Type& GetDataInIter(iterator&   ARR_CIterator  ){return *ARR_CIterator;}
        Type& GetDataInIter(IterEasyID  ARRI_IterEasyID)
            { return GetDataInIter((ZCLink*)ARRI_IterEasyID); }

        Type& GetDataInIter(ZCLink* AP_CLink, TypeSize AI_FarNum)
        {
            return **AP_CLink->GetNextPrevPtr(AI_FarNum);
        }/*
        Type& GetDataInIter(ZCLink* AP_CLink, TypeSize AI_FarNum)*/

        Type& GetDataInIter(iterator& ARR_CIterator, TypeSize AI_FarNum)
        {
            return *(ARR_CIterator+AI_FarNum);
        }/*
        Type& GetDataInIter(iterator& ARR_CIterator, TypeSize AI_FarNum)*/

        Type& GetDataInIter(IterEasyID ARRI_IterEasyID, TypeSize AI_FarNum)
        {
            return GetDataInIter((ZCLink*)ARRI_IterEasyID, AI_FarNum);
        }/*
        Type& GetDataInIter(IterEasyID ARRI_IterEasyID, TypeSize AI_FarNum)*/


        const Type& GetDataInIter(const ZCLink* AP_CLink) const
        {
            return **AP_CLink;
        }/*
        const Type& GetDataInIter(const ZCLink* AP_CLink) const*/

        const Type& GetDataInIter(const iterator& ARR_CIterator) const
        {
            return *ARR_CIterator;
        }/*
        const Type& GetDataInIter(const iterator& ARR_CIterator) const*/

        const Type& GetDataInIter(IterEasyIDc ARRI_IterEasyID) const
        {
            return GetDataInIter((const ZCLink*)ARRI_IterEasyID);
        }/*
        const Type& GetDataInIter(IterEasyIDc ARRI_IterEasyID) const*/


        const Type& GetDataInIter(const ZCLink* AP_CLink, TypeSize AI_FarNum) const
        {
            return **AP_CLink->GetNextPrevPtr(AI_FarNum);
        }/*
        const Type& GetDataInIter(const ZCLink* AP_CLink, TypeSize AI_FarNum) const*/

        const Type& GetDataInIter(const iterator& ARR_CIterator, TypeSize AI_FarNum) const
        {
            return *(ARR_CIterator+AI_FarNum);
        }/*
        const Type& GetDataInIter(const iterator& ARR_CIterator, TypeSize AI_FarNum) const*/

        const Type& GetDataInIter(IterEasyIDc ARRI_IterEasyID, TypeSize AI_FarNum) const
        {
            return GetDataInIter((ZCLink*)ARRI_IterEasyID, AI_FarNum);
        }/*
        const Type& GetDataInIter(IterEasyIDc ARRI_IterEasyID, TypeSize AI_FarNum) const*/


        // cf typedef ZCLink* IterEasy;

        IterEasy    ItHEasy(){return GetHeadIterEasy  ();}
        IterEasy    ItTEasy(){return GetTailIterEasy  ();}
        IterEasyID  ItHID  (){return GetHeadIterEasyID();}
        IterEasyID  ItTID  (){return GetTailIterEasyID();}

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

        const IterEasy   ItHEasy() const{return GetHeadIterEasy   ();}
        const IterEasy   ItTEasy() const{return GetTailIterEasy   ();}
        const IterEasyID ItHID  () const{return GetHeadIterEasyID ();}
        const IterEasyID ItTID  () const{return GetTailIterEasyID ();}

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

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

        Type& ItD(IterEasy   AP_CLink                           ){return GetDataInIter(AP_CLink                  );}
        Type& ItD(iterator&  ARR_CIterator                      ){return GetDataInIter(ARR_CIterator             );}
        Type& ItD(IterEasyID ARRI_IterEasyID                    ){return GetDataInIter(ARRI_IterEasyID           );}
        Type& ItD(ZCLink*    AP_CLink       , TypeSize AI_FarNum){return GetDataInIter(AP_CLink       , AI_FarNum);}
        Type& ItD(iterator&  ARR_CIterator  , TypeSize AI_FarNum){return GetDataInIter(ARR_CIterator  , AI_FarNum);}
        Type& ItD(IterEasyID ARRI_IterEasyID, TypeSize AI_FarNum){return GetDataInIter(ARRI_IterEasyID, AI_FarNum);}

        const Type& ItD(const IterEasy  AP_CLink                           ) const{return GetDataInIter(AP_CLink                  );}
        const Type& ItD(const iterator& ARR_CIterator                      ) const{return GetDataInIter(ARR_CIterator             );}
        const Type& ItD(IterEasyIDc     ARRI_IterEasyID                    ) const{return GetDataInIter(ARRI_IterEasyID           );}
        const Type& ItD(const ZCLink*   AP_CLink       , TypeSize AI_FarNum) const{return GetDataInIter(AP_CLink                  );}
        const Type& ItD(const iterator& ARR_CIterator  , TypeSize AI_FarNum) const{return GetDataInIter(ARR_CIterator  , AI_FarNum);}
        const Type& ItD(IterEasyIDc     ARRI_IterEasyID, TypeSize AI_FarNum) const{return GetDataInIter(ARRI_IterEasyID, AI_FarNum);}

    public:
    };/*
    template<   typename TType  ///////////////////////////////////////////////////
              , typename TTypArgu   = const TType&
              , typename TTypCAlloc = ZCAllocator
              , typename TTypeInit  = ZtCInit<TType>
              , typename TTypSize   = ZTypLong
              , typename TMoveObj   = ZtCMoveObj<TType, TTypArgu, true>
              , typename TFeeeHeap  = ZNsIFaceEx::
                    ZtCFreeHeapCDL< ZNsConst::CI_ListKind_Double >
            >
    class ZtCObjList ////////////////////////////////////////////////////////////*/


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

    ■  주로 IterElement() 을 사용하는 ZtCObjList<> 예제 --2025-08-10 11:41

        #include <iostream>

        #include "ZCppMain/ZtCArray.H"
        #include "ZCppMain/ZtCObjList.H"


        using namespace std    ;
        using namespace ZNsMain;


        int main()
        {
            typedef ZtCArray<int>      CArray   ;
            typedef ZtCObjList<int>    CObjList ;
            typedef CArray  ::IterEasy IterEasyA;
            typedef CObjList::IterEasy IterEasyL;


            CArray VO_CArray;  CObjList VO_CObjList;

            VO_CArray.AddTail(10);
            VO_CArray.AddTail(20);
            VO_CArray.AddTail(30);
            VO_CArray.AddTail(40);

            VO_CObjList.AddTail(10);
            VO_CObjList.AddTail(20);
            VO_CObjList.AddTail(30);
            VO_CObjList.AddTail(40);

            IterEasyA VH_IterA = VO_CArray  .ItHEasy();
            IterEasyL VH_IterL = VO_CObjList.ItHEasy();


            class CHelpObj
            {
            public:

                CHelpObj()
                {
                }

                CHelpObj(const CHelpObj& rhs)
                {
                    cout<<"* CHelpObj(const CHelpObj& rhs)"<<endl;
                }

            public:
            };  CHelpObj VO_CHelpObj; cout<<"VO_CHelpObj Ptr : "<<&VO_CHelpObj<<endl;

            struct StFunctor
            {
                static void ShowElement(int ArgiValue){cout<<"#1 Value="<<ArgiValue<<endl;}
            };
            struct StFunctor2
            {
                static void ShowElement(int ArgiValue, CHelpObj)
                    {cout<<"#2 Value="<<ArgiValue<<", CHelpObj Addr=None"<<" With CHelpObj"<<endl;}
            };
            struct StFunctor3
            {
                static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj)
                    {cout<<"#3 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj Ref"<<endl;}
            };
            struct StFunctor4
            {
                static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj)
                    {cout<<"#4 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj in Ptr"<<endl;}
            };
            struct StFunctor5
            {
                static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj, CHelpObj& AR_CHelpObj2)
                    {cout<<"#5 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj Ref 2"<<endl;}
            };
            struct StFunctor6
            {
                static void ShowElement(int ArgiValue, CHelpObj& AR_CHelpObj, CHelpObj AO_CHelpObj2)
                    {cout<<"#6 Value="<<ArgiValue<<", HelpObj Ptr="<<&AR_CHelpObj<<" With CHelpObj Half Ref"<<endl;}
            };


            VO_CArray.IterElement(StFunctor ::ShowElement);
            VO_CArray.IterElement(StFunctor2::ShowElement, VO_CHelpObj );
            VO_CArray.IterElement(StFunctor3::ShowElement, ZftMCR(VO_CHelpObj) );
            VO_CArray.IterElement(StFunctor4::ShowElement, ZftMCP(VO_CHelpObj) );
            VO_CArray.IterElement(StFunctor5::ShowElement, ZftMCP(VO_CHelpObj), ZftMCP(VO_CHelpObj) );
            VO_CArray.IterElement(StFunctor6::ShowElement, ZftMCP(VO_CHelpObj),        VO_CHelpObj  );

            __for1(int, i, VO_CArray.size())
            {
                cout<<i<<"th value="<<VO_CArray.ItD(VH_IterA)<<endl;  VO_CArray.ItNext(VH_IterA);
            }


            cout<<endl<<"#### Show CObjList Element ####"<<endl<<endl;


            VO_CObjList.IterElement(StFunctor ::ShowElement);
            VO_CObjList.IterElement(StFunctor2::ShowElement, VO_CHelpObj );
            VO_CObjList.IterElement(StFunctor3::ShowElement, ZftMCR(VO_CHelpObj) );
            VO_CObjList.IterElement(StFunctor4::ShowElement, ZftMCP(VO_CHelpObj) );
            VO_CObjList.IterElement(StFunctor5::ShowElement, ZftMCP(VO_CHelpObj), ZftMCP(VO_CHelpObj) );
            VO_CObjList.IterElement(StFunctor6::ShowElement, ZftMCP(VO_CHelpObj),        VO_CHelpObj  );

            __for1(int, i, VO_CObjList.size())
            {
                cout<<i<<"th value="<<VO_CObjList.ItD(VH_IterL)<<endl;  VO_CObjList.ItNext(VH_IterL);
            }


            return 0;
        }

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



    namespace ZNsType
    {

        /*////////////////////////////////////////////////////////////////////////////////////
        
        ■  class ZtCTypeObjUnitList<> 은 ZNsMain::ZtCObjUnitList<> 의 2번 템플릿 인자로 들어가
            서, 자칫 지저분하게 보일 수 있는 ZtCObjUnitList<> 선언을 단순하게 한다.

            ZtCObjUnitList<> 는 IOCP 형 쓰레드 풀의 작업 큐로 사용하는데에 최적화되었다.

        ■  int TInMaxUnitCnt
        
            동기화 영역에서 '작업 큐'에 한 번에 등록할 수 있는 ZCLinkUnit 의 최대 갯수. 무슨 얘
            기냐면, epoll_wait() 등의 이벤트 수신 함수에서처럼 작업을 배열로 받는 경우, 임시로
            '작업 큐'를 만들어서 여기에 등록한 다음, 이 임시 '작업 큐'('임시 작업 큐')의 모든
            원소를 한 번에 실제 '작업 큐'에 동기화 영역에서 고정 시간에 등록하게 된다. '임시 작
            업 큐'를 설계하지 않고 실제 '작업 큐'에 바로 배열을 각 원소마다 등록한다면, 배열의
            크기에 따른 선형 시간이 걸리게 되고, 동기화 영역의 수행 시간이 길어질 수 있다.

            그렇다고 배열로 받은 작업을 '임시 작업 큐'에 한꺼번에 등록해 버리면, 그 만큼의 메
            모리를, 즉 그 만큼의 '내부 삭제 리스트'를 동기화 영역에서 실제 '작업 큐'로부터 가
            지고 올 때, 선형 시간이 걸리게 된다. 그래서 '임시 작업 큐'에 등록하는 ZCLinkUnit 의
            최대 갯수를
            
                int TInMaxUnitCnt

            개로 제한하려는 것이다.

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


        template<   typename  TType                       ,
                    typename  TTypArg       =const TType& ,
                    typename  TTypCAlloc    =ZCAllocator  ,
                    typename  TTypSize      =ZTypLong     ,
                    ZTypInt   TInArrSize    =4            ,
                    ZTypInt   TInMaxUnitCnt =5
                >
        class ZtCTypeObjUnitList //////////////////////////
        {
        public   :
            enum{ZEArrSize    =TInArrSize   };
            enum{ZEMaxUnitCnt =TInMaxUnitCnt};
        public   :
            typedef TType      TypeData ;
            typedef TTypArg    TypeArg  ;
            typedef TTypSize   TypeSize ;
            typedef TTypCAlloc TypeAlloc;
        public:
        };/*
        template<   typename  TType                       ,
                    typename  TTypArg       =const TType& ,
                    typename  TTypCAlloc    =ZCAllocator  ,
                    typename  TTypSize      =ZTypLong     ,
                    ZTypInt   TInArrSize    =4            ,
                    ZTypInt   TInMaxUnitCnt =5
                >
        class ZtCTypeObjUnitList ////////////////////////*/

    }/*
    namespace ZNsType*/


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

    ■  class ZtCObjUnitList<> 는 IOCP 형 쓰레드 풀의 작업 큐로 사용하는데에 최적화되었다.

    ■  class ZtCObjUnitList<> 는 내부적으로 '내부 사용 리스트'와 '내부 삭제 리스트'를 갖는다. '내부 사용 리스트'
        에서 ZCLinkUnit 이 삭제가 되면 실제로 삭제되는 것이 아니고, '내부 삭제 리스트'로 옮겨 가는 것이다.

        -- 2013-02-14 10:42:00

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


    template<   typename TType , ///////////////////////////////////////////
                typename TTypeObjUnitList =
                    ZNsType::ZtCTypeObjUnitList<TType>
            >
    class ZtCObjUnitList ///////////////////////////////////////////////////
    {
    public :
        typedef TTypeObjUnitList TypeObjUnitList;
    public :
        enum{ZEArrSize    =TypeObjUnitList::ZEArrSize   };
        enum{ZEMaxUnitCnt =TypeObjUnitList::ZEMaxUnitCnt};
    public :
        typedef typename TypeObjUnitList::TypeData  TypeData ;
        typedef typename TypeObjUnitList::TypeArg   TypeArg  ;
        typedef typename TypeObjUnitList::TypeSize  TypeSize ;
        typedef typename TypeObjUnitList::TypeAlloc TypeAlloc;
    public :
        typedef TypeData TypeArr[ZEArrSize];
        typedef TypeData ZCLink            ; // 이 typedef 에 주의.
    public :


        class ZCLinkUnit : public TypeAlloc
        {
        public :
            friend class ZtCObjUnitList;
        private:
            TypeArr     mo_TypeArr ;
            TypeSize    ml_UseSize ;
            ZCLinkUnit* mp_NextUnit;
            ZCLinkUnit* mp_PrevUnit;
        private:

            static void JoinLink(ZCLinkUnit* lhs, ZCLinkUnit* rhs)
            {
                lhs->mp_NextUnit=rhs;
                rhs->mp_PrevUnit=lhs;
            }/*
            static void JoinLink(ZCLinkUnit* lhs, ZCLinkUnit* rhs)*/

            static void MakeRing(ZCLinkUnit* AP_HeadUnit, ZCLinkUnit* AP_TailUnit)
            {
                AP_HeadUnit->mp_PrevUnit=AP_TailUnit;
                AP_TailUnit->mp_NextUnit=AP_HeadUnit;
            }/*
            static void MakeRing(ZCLinkUnit* AP_HeadUnit, ZCLinkUnit* AP_TailUnit)*/

            TypeData& AddEmptyObj()
            {
                return mo_TypeArr[ml_UseSize++]; // must ml_UseSize>=ZEArrSize
            }/*
            TypeData& AddEmptyObj()*/

      /*private:*/
        public :

            ZCLinkUnit()
            {
                ml_UseSize =0 ;
                mp_NextUnit=0 ;
                mp_PrevUnit=0 ;
            }/*
            ZCLinkUnit()*/

            ZCLinkUnit(const ZCLinkUnit& rhs)
            {
                ml_UseSize =0 ;
                mp_NextUnit=0 ;
                mp_PrevUnit=0 ;

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

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

                ml_UseSize = rhs.ml_UseSize;

                __for0(TypeSize, i, rhs.ml_UseSize)
                {
                    mo_TypeArr[i] = rhs.mo_TypeArr[i] ;
                }/*
                __for0(TypeSize, i, rhs.ml_UseSize)*/

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

            TypeData*   GetHeadObjPtr (){return mo_TypeArr ;}
            ZCLinkUnit* GetNextUnitPtr(){return mp_NextUnit;}
            ZCLinkUnit* GetPrevUniPtr (){return mp_PrevUnit;}

            TypeSize          size          () const{return ml_UseSize ;}
            TypeSize          GetUseSize    () const{return ml_UseSize ;}
            const TypeData*   GetHeadObjPtr () const{return mo_TypeArr ;}
            const ZCLinkUnit* GetNextUnitPtr() const{return mp_NextUnit;}
            const ZCLinkUnit* GetPrevUniPtr () const{return mp_PrevUnit;}

            TypeData& GetData   (TypeSize AI_Index)
                { return mo_TypeArr[AI_Index-1]; } // AI_Index start from 1
            TypeData& operator[](TypeSize AI_Index)
                { return mo_TypeArr[AI_Index  ]; }

            const TypeData& GetData   (TypeSize AI_Index) const // AI_Index start from 1
                { return mo_TypeArr[AI_Index-1]; }
            const TypeData& operator[](TypeSize AI_Index) const
                { return mo_TypeArr[AI_Index  ]; }

                  TypeArr&  operator*()      { return mo_TypeArr; }
            const TypeArr&  operator*() const{ return mo_TypeArr; }


            bool AddObj(TypeArg AR_Object)
            {
                if(ml_UseSize>=ZEArrSize) return false;

                mo_TypeArr[ml_UseSize++]=AR_Object; return true;
            }/*
            bool AddObj(TypeArg AR_Object)*/

            void AddObjArr(TypeData* AP_ObjArr, TypeSize AI_ArrSize)
            {
                if(ml_UseSize>=ZEArrSize) return;

                while(--AI_ArrSize>=0)
                {
                    mo_TypeArr[ml_UseSize++] = *AP_ObjArr++;

                    if(ml_UseSize>=ZEArrSize) return;
                }/*
                while(--AI_ArrSize>=0)*/
            }/*
            void AddObjArr(TypeData* AP_ObjArr, TypeSize AI_ArrSize)*/

            bool AddEmptyObj(TypeData*& APR_Object)
            {
                if(ml_UseSize>=ZEArrSize) return false;

                APR_Object=mo_TypeArr+(ml_UseSize++); return true;
            }/*
            bool AddEmptyObj(TypeData*& APR_Object)*/


            ZCLinkUnit* GetUnitPtr(TypeSize AI_Distance)
            {
                if(AI_Distance==0) return this;

                ZCLinkUnit* VP_NowUnit=this;

                if(AI_Distance<0)
                {
                    for(; AI_Distance!=0; ++AI_Distance)
                        VP_NowUnit = VP_NowUnit->mp_PrevUnit ;

                    return VP_NowUnit;
                }/*
                if(AI_Distance<0)*/

                for(; AI_Distance!=0; --AI_Distance)
                    { VP_NowUnit = VP_NowUnit->mp_NextUnit; }

                return VP_NowUnit;
            }/*
            ZCLinkUnit* GetUnitPtr(TypeSize AI_Distance)*/

            const ZCLinkUnit* GetUnitPtr(TypeSize AI_Distance) const
            {
                if(AI_Distance==0) return this;

                ZCLinkUnit* VP_NowUnit=this;

                if(AI_Distance<0)
                {
                    for(; AI_Distance!=0; ++AI_Distance)
                        VP_NowUnit = VP_NowUnit->mp_PrevUnit ;

                    return VP_NowUnit;
                }/*
                if(AI_Distance<0)*/

                for(; AI_Distance!=0; --AI_Distance)
                    { VP_NowUnit=VP_NowUnit->mp_NextUnit; }

                return VP_NowUnit;
            }/*
            const ZCLinkUnit* GetUnitPtr(TypeSize AI_Distance) const*/

            ZCLinkUnit* GetUnitPtr(TypeSize AI_Distance, TypeSize& ARRI_ObjCnt)
            {
                if(AI_Distance==0) return this;


                ARRI_ObjCnt=ml_UseSize;  ZCLinkUnit* VP_NowUnit=this;

                if(AI_Distance<0)
                {
                    for(; AI_Distance!=0; ++AI_Distance)
                    {
                        VP_NowUnit  = VP_NowUnit->mp_PrevUnit;
                        ARRI_ObjCnt+= VP_NowUnit->ml_UseSize ;
                    }/*
                    for(; AI_Distance!=0; ++AI_Distance)*/

                    return VP_NowUnit;
                }/*
                if(AI_Distance<0)*/

                for(; AI_Distance!=0; --AI_Distance)
                {
                    VP_NowUnit  = VP_NowUnit->mp_NextUnit;
                    ARRI_ObjCnt+= VP_NowUnit->ml_UseSize ;
                }/*
                for(; AI_Distance!=0; --AI_Distance)*/

                return VP_NowUnit;
            }/*
            ZCLinkUnit* GetUnitPtr(TypeSize AI_Distance, TypeSize& ARRI_ObjCnt)*/

            const ZCLinkUnit* GetUnitPtr(TypeSize AI_Distance, TypeSize& ARRI_ObjCnt) const
            {
                if(AI_Distance==0) return this;


                ARRI_ObjCnt=ml_UseSize;  ZCLinkUnit* VP_NowUnit=this;

                if(AI_Distance<0)
                {
                    for(; AI_Distance!=0; ++AI_Distance)
                    {
                        VP_NowUnit  = VP_NowUnit->mp_PrevUnit;
                        ARRI_ObjCnt+= VP_NowUnit->ml_UseSize ;
                    }/*
                    for(; AI_Distance!=0; ++AI_Distance)*/

                    return VP_NowUnit;
                }/*
                if(AI_Distance<0)*/

                for(; AI_Distance!=0; --AI_Distance)
                {
                    VP_NowUnit  = VP_NowUnit->mp_NextUnit;
                    ARRI_ObjCnt+= VP_NowUnit->ml_UseSize ;
                }/*
                for(; AI_Distance!=0; --AI_Distance)*/

                return VP_NowUnit;
            }/*
            const ZCLinkUnit* GetUnitPtr(TypeSize AI_Distance, TypeSize& ARRI_ObjCnt) const*/

        public :
        };/*
        class ZCLinkUnit*/


  /*public :*/
    private:
        ZCLinkUnit* mp_NowHeadUnit; // '내부 사용 리스트'의 첫 ZCLinkUnit 포인터.
        ZCLinkUnit* mp_CutHeadUnit; // '내부 삭제 리스트'의 첫 ZCLinkUnit 포인터. 일종의 삭제 버퍼다.
        TypeSize    ml_NowUnitCnt ; // '내부 사용 리스트'의 ZCLinkUnit 의 갯수.
        TypeSize    ml_CutUnitCnt ; // '내부 삭제 리스트'의 ZCLinkUnit 의 갯수 , 즉 삭제 버퍼에 있는 ZCLinkUnit 의 갯수.
        TypeSize    ml_NowObjtCnt ; // '내부 사용 리스트'의 모든 ZCLinkUnit 의 원소 수.
  /*private:*/
    private:

        ZCLinkUnit* CreateUnit()
        {
            return new ZCLinkUnit;
        }/*
        ZCLinkUnit* CreateUnit()*/

        void DeleteUnit(ZCLinkUnit* AP_CLinkUnit)
        {
            delete AP_CLinkUnit;
        }/*
        void DeleteUnit(ZCLinkUnit* AP_CLinkUnit)*/

        ZCLinkUnit& AllocUnit()
        {
            // '내부 삭제 리스트'에 ZCLinkUnit 가 있다면 그것을 반환한다.

            if(ml_CutUnitCnt<1)
            {
                ZCLinkUnit* VP_NewLinkUnit=CreateUnit();

                VP_NewLinkUnit->ml_UseSize=0; return *VP_NewLinkUnit;
            }/*
            if(ml_CutUnitCnt<1)*/

            ZCLinkUnit* VP_CutHeadUnit=mp_CutHeadUnit             ;
            ZCLinkUnit* VP_CutTailUnit=mp_CutHeadUnit->mp_PrevUnit;

            mp_CutHeadUnit=mp_CutHeadUnit->mp_NextUnit;

            if(--ml_CutUnitCnt<1)
                mp_CutHeadUnit=0;
            else
                ZCLinkUnit::MakeRing(mp_CutHeadUnit, VP_CutTailUnit);
          //else

            VP_CutHeadUnit->ml_UseSize=0;  return *VP_CutHeadUnit;
        }/*
        ZCLinkUnit& AllocUnit()*/

        ZCLinkUnit& AllocUnitAtHead()
        {
            // AllocUnit() 을 통해 가져온 ZCLinkUnit* 을
            // '내부 사용 리스트'의 앞에 삽입한다.

            ZCLinkUnit* VP_NewLinkUnit= &AllocUnit();

            if(++ml_NowUnitCnt<=1)
            {
                mp_NowHeadUnit              = VP_NewLinkUnit;
                mp_NowHeadUnit->mp_NextUnit = mp_NowHeadUnit  ;
                mp_NowHeadUnit->mp_PrevUnit = mp_NowHeadUnit  ;
            }
            else
            {
                ZCLinkUnit* VP_TailCLinkUnit= mp_NowHeadUnit->mp_PrevUnit;

                ZCLinkUnit::JoinLink(VP_NewLinkUnit, mp_NowHeadUnit  );
                ZCLinkUnit::MakeRing(VP_NewLinkUnit, VP_TailCLinkUnit);

                mp_NowHeadUnit=VP_NewLinkUnit;
            }/*
            else*/

            return *VP_NewLinkUnit;
        }/*
        ZCLinkUnit& AllocUnitAtHead()*/

        ZCLinkUnit& AllocUnitAtTail()
        {
            // AllocUnit() 을 통해 가져온 ZCLinkUnit* 을
            // '내부 사용 리스트'의 뒤에 삽입한다.

            ZCLinkUnit* VP_NewLinkUnit= &AllocUnit();

            if(++ml_NowUnitCnt<=1)
            {
                mp_NowHeadUnit             = VP_NewLinkUnit;
                mp_NowHeadUnit->mp_NextUnit= mp_NowHeadUnit;
                mp_NowHeadUnit->mp_PrevUnit= mp_NowHeadUnit;
            }
            else
            {
                ZCLinkUnit* VP_TailCLinkUnit= mp_NowHeadUnit->mp_PrevUnit;

                ZCLinkUnit::JoinLink(VP_TailCLinkUnit, VP_NewLinkUnit);
                ZCLinkUnit::MakeRing(mp_NowHeadUnit  , VP_NewLinkUnit);
            }/*
            else*/

            return *VP_NewLinkUnit;
        }/*
        ZCLinkUnit& AllocUnitAtTail()*/

  /*private:*/
    public :

        ZtCObjUnitList()
        {
            mp_NowHeadUnit=0;
            mp_CutHeadUnit=0;
            ml_NowUnitCnt =0;
            ml_CutUnitCnt =0;
            ml_NowObjtCnt =0;
        }/*
        ZtCObjUnitList()*/

        ZtCObjUnitList(const ZtCObjUnitList& rhs)
        {
            mp_NowHeadUnit=0;
            mp_CutHeadUnit=0;
            ml_NowUnitCnt =0;
            ml_CutUnitCnt =0;
            ml_NowObjtCnt =0;

            AddTail(rhs);
        }/*
        ZtCObjUnitList(const ZtCObjUnitList& rhs)*/

        ~ZtCObjUnitList()
        {
            ClearEx();
        }/*
        ~ZtCObjUnitList()*/

        ZtCObjUnitList& operator=(const ZtCObjUnitList& rhs)
        {
            if(this!=&rhs)
            {
                DeleteAll(); AddTail(rhs);
            }/*
            if(this!=&rhs)*/
            
            return *this;
        }/*
        ZtCObjUnitList& operator=(const ZtCObjUnitList& rhs)*/

        TypeSize   size          () const{return ml_NowObjtCnt;}

        TypeSize    GetNowUnitCnt() const{return ml_NowUnitCnt;}
        TypeSize    GetNowObjtCnt() const{return ml_NowObjtCnt;}
        TypeSize    GetCutUnitCnt() const{return ml_CutUnitCnt;}

        ZCLinkUnit* GetNowHeadUnitPtr()  {return mp_NowHeadUnit;}
        ZCLinkUnit* GetCutHeadUnitPtr()  {return mp_CutHeadUnit;}
        TypeData&   GetHeadData      ()  {return mp_NowHeadUnit->mo_TypeArr[0];}

        const ZCLinkUnit* GetNowHeadUnitPtr() const{return mp_NowHeadUnit;}
        const ZCLinkUnit* GetCutHeadUnitPtr() const{return mp_CutHeadUnit;}
        const TypeData&   GetHeadData      () const{return mp_NowHeadUnit->mo_TypeArr[0];}

        ZCLinkUnit* GetNowUnitPtr(TypeSize AI_Distance){
            if(mp_NowHeadUnit==0) return 0; return mp_NowHeadUnit->GetUnitPtr(AI_Distance); }
        ZCLinkUnit* GetCutUnitPtr(TypeSize AI_Distance){
            if(mp_CutHeadUnit==0) return 0; return mp_CutHeadUnit->GetUnitPtr(AI_Distance); }

        const ZCLinkUnit* GetNowUnitPtr(TypeSize AI_Distance) const{
            if(mp_NowHeadUnit==0) return 0; return mp_NowHeadUnit->GetUnitPtr(AI_Distance); }
        const ZCLinkUnit* GetCutUnitPtr(TypeSize AI_Distance) const{
            if(mp_CutHeadUnit==0) return 0; return mp_CutHeadUnit->GetUnitPtr(AI_Distance); }
      

        void AddTail(TypeArg AR_Object)
        {
            if(ml_NowUnitCnt>0 && mp_NowHeadUnit->mp_PrevUnit->size() < this->ZEArrSize)
            {
                mp_NowHeadUnit->mp_PrevUnit->AddObj(AR_Object); ++ml_NowObjtCnt; return;
            }/*
            if(ml_NowUnitCnt>0 && mp_NowHeadUnit->mp_PrevUnit->size() < this->ZEArrSize)*/

            AllocUnitAtTail().AddObj(AR_Object); ++ml_NowObjtCnt;
        }/*
        void AddTail(TypeArg AR_Object)*/

        void AddTail(const ZCLinkUnit& AR_CLinkUnit)
        {
            if(AR_CLinkUnit.size()>0)
            {
                AllocUnitAtTail()=AR_CLinkUnit;  ml_NowObjtCnt+=AR_CLinkUnit.size();
            }/*
            if(AR_CLinkUnit.size()>0)*/
        }/*
        void AddTail(const ZCLinkUnit& AR_CLinkUnit)*/

        void AddTail(const ZtCObjUnitList& AR_ZtCObjUnitList)
        {
                  TypeSize    VL_RhsNowUnitCnt  = AR_ZtCObjUnitList.GetNowUnitCnt    ();
            const ZCLinkUnit* VP_RhsNowHeadUnit = AR_ZtCObjUnitList.GetNowHeadUnitPtr();

            while(--VL_RhsNowUnitCnt>=0)
            {
                AddTail(*VP_RhsNowHeadUnit);  VP_RhsNowHeadUnit=VP_RhsNowHeadUnit->GetNextUnitPtr();
            }/*
            while(--VL_RhsNowUnitCnt>=0)*/
        }/*
        void AddTail(const ZtCObjUnitList& AR_ZtCObjUnitList)*/

        TypeData& AddTail()
        {
            if(ml_NowUnitCnt>0 && mp_NowHeadUnit->mp_PrevUnit->size() < this->ZEArrSize)
            {
                ++ml_NowObjtCnt; return mp_NowHeadUnit->mp_PrevUnit->AddEmptyObj_E();
            }/*
            if(ml_NowUnitCnt>0 && mp_NowHeadUnit->mp_PrevUnit->size() < this->ZEArrSize)*/

            ++ml_NowObjtCnt;  return AllocUnitAtTail().AddEmptyObj_E();
        }/*
        TypeData& AddTail()*/


        void AddTail(TypeData* AP_ObjArr, TypeSize AI_ArrSize)
        {
            // 마지막 ZCLinkUnit 이 채워져 있지 않아도, 건너
            // 뛰고 새 ZCLinkUnit 부터 채워 나가기 시작한다.

            if(AI_ArrSize<1) return;

            TypeSize VI_AddUnitCnt =AI_ArrSize/ZEArrSize;
            TypeSize VI_AddExtraCnt=AI_ArrSize%ZEArrSize;

            while(--VI_AddUnitCnt>=0)
            {
                AllocUnitAtTail().AddObjArr
                    ( AP_ObjArr, ZEArrSize ) ;
                AP_ObjArr += ZEArrSize ;
            }/*
            while(--VI_AddUnitCnt>=0)*/

            if(VI_AddExtraCnt<1) return;

            AllocUnitAtTail().
                AddObjArr(AP_ObjArr, VI_AddExtraCnt);
            ml_NowObjtCnt += AI_ArrSize ;
        }/*
        void AddTail(TypeData* AP_ObjArr, TypeSize AI_ArrSize)*/


        // 무조건 새로운 ZCLinkUnit 에 AR_Object 를 추가.

        void AddTailInNewUnit(TypeArg AR_Object)
        {
            AllocUnitAtTail().AddObj(AR_Object); ++ml_NowObjtCnt;
        }/*
        void AddTailInNewUnit(TypeArg AR_Object)*/


        template<typename TAllocWork> void AddTailInPool(
			      TAllocWork& AR_CAllocWork, TypeData* AP_ObjArr, TypeSize AI_ArrSize)
        {
            /*//////////////////////////////////////////////////////////////////////

            ■  ZEMaxUnitCnt 개 단위로 등록한다.
                CAllocWork_BASE2_T<> 를 참고하면, *this 는 '임시 작업 큐'다.

            ■  AR_CAllocWork.AddList() 는 작업 AP_ObjArr 을

                1) '임시 작업 큐'에 등록하고,
                2) 대기 작업 쓰레드가 있으면 하나를 깨우고,
                3) 해당 쓰레드의 작업 큐의 '내부 삭제 리스트'를 적당한 크기로
                    *this 의 '내부 삭제 리스트'에 돌려준다.

                -- 2025-10-04 08:31

                TAllocWork 은 일종의 thread pool 이고,
                *this 는 그 pool 의 '임시 작업 큐'다. -- 2025-10-04 08:36

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

            if(AI_ArrSize<1) return;

            TypeSize VI_AddUnitCnt = AI_ArrSize/ZEArrSize;
            TypeSize VI_AddExtraCnt= AI_ArrSize%ZEArrSize;
            TypeSize VI_MaxUnitCnt = ZEMaxUnitCnt        ;

            while(--VI_AddUnitCnt>=0)
            {
                AllocUnitAtTail().
                    AddObjArr(AP_ObjArr, ZEArrSize);
                AP_ObjArr     += ZEArrSize ;
                ml_NowObjtCnt += ZEArrSize ;

                if(--VI_MaxUnitCnt<=0)
                {
                    AR_CAllocWork.AddList(RR(*this)); VI_MaxUnitCnt=ZEMaxUnitCnt;
                }/*
                if(--VI_MaxUnitCnt<=0)*/
            }/*
            while(--VI_AddUnitCnt>=0)*/

            if(VI_MaxUnitCnt>0)
            {
                if(VI_AddExtraCnt>0)
                {
                    AllocUnitAtTail().
                        AddObjArr(AP_ObjArr, VI_AddExtraCnt);
                    ml_NowObjtCnt += VI_AddExtraCnt ;

                    AR_CAllocWork.AddList(RR(*this)); return;
                }/*
                if(VI_AddExtraCnt>0)*/
            }/*
            if(VI_MaxUnitCnt>0)*/


            if(VI_AddExtraCnt<1)
            {
                AR_CAllocWork.AddList(RR(*this)); return;
            }/*
            if(VI_AddExtraCnt<1)*/

            AllocUnitAtTail().
                AddObjArr(AP_ObjArr, VI_AddExtraCnt);
            ml_NowObjtCnt += VI_AddExtraCnt ;

            AR_CAllocWork.AddList(RR(*this));
        }/*
        template<typename TAllocWork> void AddTailInPool(
			      TAllocWork& AR_CAllocWork, TypeData* AP_ObjArr, TypeSize AI_ArrSize) */


        template<typename TAllocWork, typename TypeData2> void AddTailInPool2
            ( TAllocWork& AR_CAllocWork, TypeData2* AP_ObjArr, TypeSize AI_ArrSize )
        {
            // TypeData = TypeData2 연산자가 지원되어야 한다.

            if(AI_ArrSize<1) return;

            TypeSize VI_AddUnitCnt = AI_ArrSize/ZEArrSize;
            TypeSize VI_AddExtraCnt= AI_ArrSize%ZEArrSize;
            TypeSize VI_MaxUnitCnt = ZEMaxUnitCnt        ;

            while(--VI_AddUnitCnt>=0)
            {
                __for0(TypeSize, i, ZEArrSize)
                    push_back() = *(AP_ObjArr++) ;

                if(--VI_MaxUnitCnt<=0)
                {
                    AR_CAllocWork.AddList(RR(*this)); VI_MaxUnitCnt=ZEMaxUnitCnt;
                }/*
                if(--VI_MaxUnitCnt<=0)*/
            }/*
            while(--VI_AddUnitCnt>=0)*/

            if(VI_MaxUnitCnt>0)
            {
                if(VI_AddExtraCnt>0)
                {
                    __for0(TypeSize, i, VI_AddExtraCnt)
                        { push_back() = *(AP_ObjArr++); }

                    AR_CAllocWork.AddList(RR(*this)); return;
                }/*
                if(VI_AddExtraCnt>0)*/
            }/*
            if(VI_MaxUnitCnt>0)*/


            if(VI_AddExtraCnt<1)
            {
                AR_CAllocWork.AddList(RR(*this)); return;
            }/*
            if(VI_AddExtraCnt<1)*/

            __for0(TypeSize, i, VI_AddExtraCnt)
                { push_back() = *(AP_ObjArr++); }

            AR_CAllocWork.AddList(RR(*this));
        }/*
        template<typename TAllocWork, typename TypeData2> void AddTailInPool2
            ( TAllocWork& AR_CAllocWork, TypeData2* AP_ObjArr, TypeSize AI_ArrSize ) */


        void AddUnitInCutList(TypeSize AI_AddUnitCnt)
        {
            // 초기에 이 함수로 미리 ZCLinkUnit 을 할당해 놓으면 좋다.

            if(AI_AddUnitCnt<1) return;

            ZCLinkUnit* VP_UnitHead  =CreateUnit() ;
            ZCLinkUnit* VP_UnitTail  =VP_UnitHead  ;
            TypeSize    VI_AddUnitCnt=AI_AddUnitCnt;

            while(--VI_AddUnitCnt>0) // AI_AddUnitCnt-1 번 순환.
            {
                ZCLinkUnit* VP_UnitTail2 = CreateUnit();
                ZCLinkUnit::JoinLink(VP_UnitTail, VP_UnitTail2);

                VP_UnitTail=VP_UnitTail2;
            }/*
            while(--VI_AddUnitCnt>0)*/

            if(ml_CutUnitCnt<1)
            {
                ZCLinkUnit::MakeRing(VP_UnitHead, VP_UnitTail);

                mp_CutHeadUnit = VP_UnitHead; /////////////////
            }
            else
            {
                ZCLinkUnit::JoinLink(mp_CutHeadUnit->mp_PrevUnit, VP_UnitHead);
                ZCLinkUnit::MakeRing(mp_CutHeadUnit             , VP_UnitTail);
            }/*
            else*/

            ml_CutUnitCnt += AI_AddUnitCnt;
        }/*
        void AddUnitInCutList(TypeSize AI_AddUnitCnt)*/


        operator TypeData& (){return AddTail();}

        void      push_back(TypeArg AR_Object){return AddTail(AR_Object);}
        TypeData& push_back()                 {return AddTail()         ;}


        void DeleteAll()
        {
            // '내부 사용 리스트'를 '내부 삭제 리스트'의 끝으로 옮긴다.

            if(ml_NowUnitCnt<1) return;

            if(ml_CutUnitCnt>0)
            {
                ZCLinkUnit* VP_TailLink=mp_NowHeadUnit->mp_PrevUnit;

                ZCLinkUnit::JoinLink(mp_CutHeadUnit->mp_PrevUnit, mp_NowHeadUnit);
                ZCLinkUnit::MakeRing(mp_CutHeadUnit             , VP_TailLink   );
            }
            else
                mp_CutHeadUnit=mp_NowHeadUnit;
          //else

            mp_NowHeadUnit =0             ;
            ml_CutUnitCnt +=ml_NowUnitCnt ;
            ml_NowUnitCnt  =0             ;
            ml_NowObjtCnt  =0             ;
        }/*
        void DeleteAll()*/


        void DeleteHead()
        {
            if(ml_NowUnitCnt<1) return;

            if(--ml_NowUnitCnt<1)
            {
                ZCLinkUnit::JoinLink(mp_CutHeadUnit->mp_PrevUnit, mp_NowHeadUnit);
                ZCLinkUnit::MakeRing(mp_CutHeadUnit             , mp_NowHeadUnit);

                mp_NowHeadUnit=0;
                ml_NowObjtCnt =0;
            }
            else
            {
                ZCLinkUnit* VP_HeadLink=mp_NowHeadUnit;
                ZCLinkUnit* VP_TailLink=mp_NowHeadUnit->mp_PrevUnit;

                mp_NowHeadUnit = mp_NowHeadUnit->mp_NextUnit;
                ml_NowObjtCnt -= VP_HeadLink->size();

                ZCLinkUnit::MakeRing(mp_NowHeadUnit             , VP_TailLink);
                ZCLinkUnit::JoinLink(mp_CutHeadUnit->mp_PrevUnit, VP_HeadLink);
                ZCLinkUnit::MakeRing(mp_CutHeadUnit             , VP_HeadLink);
            }/*
            else*/

            ++ml_CutUnitCnt;
        }/*
        void DeleteHead()*/


        void DeleteAllCutList()
        {
            // '내부 삭제 리스트'를 지운다.

            ZCLinkUnit* VP_CutHead=mp_CutHeadUnit;

            for(; ml_CutUnitCnt>0; --ml_CutUnitCnt)
            {
                mp_CutHeadUnit=mp_CutHeadUnit->mp_NextUnit;

                DeleteUnit(VP_CutHead);  VP_CutHead=mp_CutHeadUnit;
            }/*
            for(; ml_CutUnitCnt>0; --ml_CutUnitCnt)*/

            mp_CutHeadUnit=0;
        }/*
        void DeleteAllCutList()*/


        void Clear  (){DeleteAll();}
        void clear  (){DeleteAll();}

        void ClearEx(){DeleteAll(); DeleteAllCutList();}

        void JoinTail  (ZtCObjUnitList& rhs){JoinAtTail(rhs);} // for compatiblity with ZNsMain::ZtCObjList<>
        void JoinHead  (ZtCObjUnitList& rhs){JoinAtHead(rhs);} // for compatiblity with ZNsMain::ZtCObjList<>

        void JoinHeadEx(ZtCObjUnitList& rhs){JoinAtHead(rhs); JoinCutListAtTail(rhs);}
        void JoinTailEx(ZtCObjUnitList& rhs){JoinAtTail(rhs); JoinCutListAtTail(rhs);}

        void JoinAtTail(ZtCObjUnitList& rhs)
        {
            if(this==&rhs) return;

            if(rhs.ml_NowUnitCnt<1) return;

            if(ml_NowUnitCnt<1)
            {
                mp_NowHeadUnit=rhs.mp_NowHeadUnit;
            }
            else
            {
                ZCLinkUnit* VP_RhsTailUnit=rhs.mp_NowHeadUnit->mp_PrevUnit;

                ZCLinkUnit::JoinLink(mp_NowHeadUnit->mp_PrevUnit, rhs.mp_NowHeadUnit);
                ZCLinkUnit::MakeRing(mp_NowHeadUnit,              VP_RhsTailUnit    );
            }/*
            else*/

            ml_NowUnitCnt+=rhs.ml_NowUnitCnt; rhs.ml_NowUnitCnt=0;
            ml_NowObjtCnt+=rhs.ml_NowObjtCnt; rhs.ml_NowObjtCnt=0; rhs.mp_NowHeadUnit=0;
        }/*
        void JoinAtTail(ZtCObjUnitList& rhs)*/

        void JoinAtHead(ZtCObjUnitList& rhs)
        {
            if(this==&rhs) return;

            if(rhs.ml_NowUnitCnt<1) return;

            if(ml_NowUnitCnt>=1)
            {
                ZCLinkUnit* VP_RhsTailUnit=rhs.mp_NowHeadUnit->mp_PrevUnit;
                ZCLinkUnit* VP_LhsTailUnit=    mp_NowHeadUnit->mp_PrevUnit;

                ZCLinkUnit::JoinLink(VP_RhsTailUnit    , mp_NowHeadUnit);
                ZCLinkUnit::MakeRing(rhs.mp_NowHeadUnit, VP_LhsTailUnit);
            }/*
            if(ml_NowUnitCnt>=1)*/

            ml_NowUnitCnt += rhs.ml_NowUnitCnt ; rhs.ml_NowUnitCnt =0;
            ml_NowObjtCnt += rhs.ml_NowObjtCnt ; rhs.ml_NowObjtCnt =0;
            mp_NowHeadUnit = rhs.mp_NowHeadUnit; rhs.mp_NowHeadUnit=0;
        }/*
        void JoinAtHead(ZtCObjUnitList& rhs)*/


        void JoinRhsTailAtTail(ZtCObjUnitList& rhs, TypeSize AI_FetchSize)
        {
            // rhs 의 '내부 사용 리스트'의 마지막 AI_FetchSize 개의 링크를
            // 자신의 '내부 사용 리스트'로 가져온다.

            if(AI_FetchSize<1) return ;

            if(rhs.ml_NowUnitCnt<=AI_FetchSize)
            {
                JoinAtTail(RR(rhs)); return;
            }/*
            if(rhs.ml_CutUnitCnt<=AI_FetchSize)*/


            // rhs.ml_NowUnitCnt>AI_FetchSize 이고 rhs.ml_NowUnitCnt>0

            TypeSize    VI_RhsObjCnt  = 0                               ;
            ZCLinkUnit* VP_RhsNowTail = rhs.mp_NowHeadUnit->mp_PrevUnit ;
            ZCLinkUnit* VP_RhsNowHead = VP_RhsNowTail->
                GetUnitPtr( -(AI_FetchSize-1), RR(VI_RhsObjCnt) )       ;

            ZCLinkUnit::MakeRing(
                rhs.mp_NowHeadUnit, VP_RhsNowHead->mp_PrevUnit);
            rhs.ml_NowUnitCnt -= AI_FetchSize;
            rhs.ml_NowObjtCnt -= VI_RhsObjCnt;

            if(ml_NowUnitCnt<1)
            {
                ZCLinkUnit::MakeRing(VP_RhsNowHead, VP_RhsNowTail); mp_NowHeadUnit=VP_RhsNowHead;
            }
            else
            {
                ZCLinkUnit::JoinLink(mp_NowHeadUnit->mp_PrevUnit, VP_RhsNowHead);
                ZCLinkUnit::MakeRing(mp_NowHeadUnit             , VP_RhsNowTail);
            }
            ml_NowUnitCnt += AI_FetchSize;
            ml_NowObjtCnt += VI_RhsObjCnt;
        }/*
        void JoinRhsTailAtTail(ZtCObjUnitList& rhs, TypeSize AI_FetchSize)*/

        void JoinRhsHeadAtTail(ZtCObjUnitList& rhs, TypeSize AI_FetchSize)
        {
            // rhs 의 '내부 사용 리스트'의 처음 AI_FetchSize 개의 링크를
            // 자신의 '내부 사용 리스트'로 가져온다.

            if(AI_FetchSize<1) return ;

            if(rhs.ml_NowUnitCnt<=AI_FetchSize)
            {
                JoinAtTail(RR(rhs)); return;
            }/*
            if(rhs.ml_CutUnitCnt<=AI_FetchSize)*/


            // rhs.ml_NowUnitCnt>AI_FetchSize 이고 rhs.ml_NowUnitCnt>0

            TypeSize    VI_RhsObjCnt = 0                       ;
            ZCLinkUnit* VP_RhsNowHead= rhs.mp_NowHeadUnit      ;
            ZCLinkUnit* VP_RhsNowTail= VP_RhsNowHead->
                GetUnitPtr( AI_FetchSize-1, RR(VI_RhsObjCnt) ) ;

            rhs.mp_NowHeadUnit = VP_RhsNowTail->mp_NextUnit    ;

            ZCLinkUnit::MakeRing(
                rhs.mp_NowHeadUnit, VP_RhsNowHead->mp_PrevUnit);
            rhs.ml_NowUnitCnt -= AI_FetchSize;
            rhs.ml_NowObjtCnt -= VI_RhsObjCnt;

            if(ml_NowUnitCnt<1)
            {
                ZCLinkUnit::MakeRing(VP_RhsNowHead, VP_RhsNowTail);

                mp_NowHeadUnit=VP_RhsNowHead; /////////////////////
            }
            else
            {
                ZCLinkUnit::JoinLink(mp_NowHeadUnit->mp_PrevUnit, VP_RhsNowHead);
                ZCLinkUnit::MakeRing(mp_NowHeadUnit             , VP_RhsNowTail);
            }
            ml_NowUnitCnt += AI_FetchSize;
            ml_NowObjtCnt += VI_RhsObjCnt;
        }/*
        void JoinRhsHeadAtTail(ZtCObjUnitList& rhs, TypeSize AI_FetchSize)*/


        void JoinRhsTailOneAtTail(ZtCObjUnitList& rhs)
        {
            // rhs 의 '내부 사용 리스트'의 마지막 1 개의 링크를
            // 자신의 '내부 사용 리스트'로 가져온다.

            if(rhs.ml_NowUnitCnt<1) return;

            ZCLinkUnit* VP_RhsNowTail=rhs.mp_NowHeadUnit->mp_PrevUnit;

            if(--rhs.ml_NowUnitCnt<1)
            {
                rhs.mp_NowHeadUnit=0;
            }
            else
            {
                ZCLinkUnit::MakeRing(
                    rhs.mp_NowHeadUnit, VP_RhsNowTail->mp_PrevUnit);
            }
            rhs.ml_NowObjtCnt -= VP_RhsNowTail->ml_UseSize ;

            if(++ml_NowUnitCnt<=1)
            {
                ZCLinkUnit::MakeRing(VP_RhsNowTail, VP_RhsNowTail);

                mp_NowHeadUnit=VP_RhsNowTail; /////////////////////
            }
            else
            {
                ZCLinkUnit::JoinLink(mp_NowHeadUnit->mp_PrevUnit, VP_RhsNowTail);
                ZCLinkUnit::MakeRing(mp_NowHeadUnit             , VP_RhsNowTail);
            }
            ml_NowObjtCnt += VP_RhsNowTail->ml_UseSize ;
        }/*
        void JoinRhsTailOneAtTail(ZtCObjUnitList& rhs)*/

        void JoinRhsHeadOneAtTail(ZtCObjUnitList& rhs)
        {
            // rhs 의 '내부 사용 리스트'의 처음 1 개의 링크를
            // 자신의 '내부 사용 리스트'로 가져온다.

            if(rhs.ml_NowUnitCnt<1) return;

            ZCLinkUnit* VP_RhsNowHead = rhs.mp_NowHeadUnit;
            rhs.        mp_NowHeadUnit= rhs.mp_NowHeadUnit->mp_NextUnit;

            if(--rhs.ml_NowUnitCnt<1)
            {
                rhs.mp_NowHeadUnit=0;
            }
            else
            {
                ZCLinkUnit::MakeRing(
                    rhs.mp_NowHeadUnit, VP_RhsNowHead->mp_PrevUnit);
            }
            rhs.ml_NowObjtCnt -= VP_RhsNowHead->ml_UseSize ;

            if(++ml_NowUnitCnt<=1)
            {
                ZCLinkUnit::MakeRing(VP_RhsNowHead, VP_RhsNowHead);

                mp_NowHeadUnit=VP_RhsNowHead; /////////////////////
            }
            else
            {
                ZCLinkUnit::JoinLink(mp_NowHeadUnit->mp_PrevUnit, VP_RhsNowHead);
                ZCLinkUnit::MakeRing(mp_NowHeadUnit             , VP_RhsNowHead);
            }
            ml_NowObjtCnt += VP_RhsNowHead->ml_UseSize ;
        }/*
        void JoinRhsHeadOneAtTail(ZtCObjUnitList& rhs)*/


        void JoinCutListAtTail(ZtCObjUnitList& rhs)
        {
            if(rhs.ml_CutUnitCnt<1) return;

            if(ml_CutUnitCnt<1)
            {
                mp_CutHeadUnit=rhs.mp_CutHeadUnit;
            }
            else
            {
                ZCLinkUnit* VP_RhsTailUnit = rhs.mp_CutHeadUnit->mp_PrevUnit;

                ZCLinkUnit::JoinLink(mp_CutHeadUnit->mp_PrevUnit, rhs.mp_CutHeadUnit);
                ZCLinkUnit::MakeRing(mp_CutHeadUnit             ,     VP_RhsTailUnit);
            }/*
            else*/

                ml_CutUnitCnt += rhs.ml_CutUnitCnt;
            rhs.ml_CutUnitCnt   = 0               ;
            rhs.mp_CutHeadUnit  = 0               ;
        }/*
        void JoinCutListAtTail(ZtCObjUnitList& rhs)*/


        void JoinRhsCutListTailAtTail(ZtCObjUnitList& rhs, TypeSize AI_FetchSize)
        {
            // rhs 의 '내부 삭제 리스트'의 마지막 AI_FetchSize 개의 링크를
            // 자신의 '내부 삭제 리스트'로 가져온다.

            if(AI_FetchSize<1) return ;

            if(rhs.ml_CutUnitCnt<=AI_FetchSize)
            {
                JoinCutListAtTail(RR(rhs)); return;
            }/*
            if(rhs.ml_CutUnitCnt<=AI_FetchSize)*/


            // rhs.ml_CutUnitCnt>AI_FetchSize 이고 rhs.ml_CutUnitCnt>0

            ZCLinkUnit* VP_RhsCutTail = rhs.mp_CutHeadUnit->mp_PrevUnit;
            ZCLinkUnit* VP_RhsCutHead =
                VP_RhsCutTail->GetUnitPtr( -(AI_FetchSize-1)  );

            ZCLinkUnit::MakeRing(
                rhs.mp_CutHeadUnit, VP_RhsCutHead->mp_PrevUnit);
            rhs.ml_CutUnitCnt -= AI_FetchSize;

            if(ml_CutUnitCnt<1)
            {
                ZCLinkUnit::MakeRing(VP_RhsCutHead, VP_RhsCutTail);

                mp_CutHeadUnit = VP_RhsCutHead; ///////////////////
            }
            else
            {
                ZCLinkUnit::JoinLink(mp_CutHeadUnit->mp_PrevUnit, VP_RhsCutHead);
                ZCLinkUnit::MakeRing(mp_CutHeadUnit             , VP_RhsCutTail);
            }
            ml_CutUnitCnt += AI_FetchSize;
        }/*
        void JoinRhsCutListTailAtTail(ZtCObjUnitList& rhs, TypeSize AI_FetchSize)*/

        void JoinRhsCutListHeadAtTail(ZtCObjUnitList& rhs, TypeSize AI_FetchSize)
        {
            // rhs 의 '내부 삭제 리스트'의 처음 AI_FetchSize 개의 링크를
            // 자신의 '내부 삭제 리스트'로 가져온다.

            if(AI_FetchSize<1) return ;

            if(rhs.ml_CutUnitCnt<=AI_FetchSize)
            {
                JoinCutListAtTail(RR(rhs)); return;
            }/*
            if(rhs.ml_CutUnitCnt<=AI_FetchSize)*/


            // rhs.ml_CutUnitCnt>AI_FetchSize 이고 rhs.ml_CutUnitCnt>0

            ZCLinkUnit* VP_RhsCutHead = rhs.mp_CutHeadUnit ;
            ZCLinkUnit* VP_RhsCutTail =
                VP_RhsCutHead->GetUnitPtr(AI_FetchSize-1)  ;

            rhs.mp_CutHeadUnit = VP_RhsCutTail->mp_NextUnit;

            ZCLinkUnit::MakeRing(
                rhs.mp_CutHeadUnit, VP_RhsCutHead->mp_PrevUnit);
            rhs.ml_CutUnitCnt -= AI_FetchSize;

            if(ml_CutUnitCnt<1)
            {
                ZCLinkUnit::MakeRing(VP_RhsCutHead, VP_RhsCutTail);

                mp_CutHeadUnit=VP_RhsCutHead; /////////////////////
            }
            else
            {
                ZCLinkUnit::JoinLink(mp_CutHeadUnit->mp_PrevUnit, VP_RhsCutHead);
                ZCLinkUnit::MakeRing(mp_CutHeadUnit             , VP_RhsCutTail);
            }
            ml_CutUnitCnt += AI_FetchSize;
        }/*
        void JoinRhsCutListHeadAtTail(ZtCObjUnitList& rhs, TypeSize AI_FetchSize)*/


        void JoinRhsCutTailOneAtTail(ZtCObjUnitList& rhs)
        {
            // rhs 의 '내부 삭제 리스트'의 마지막 1 개의 링크를
            // 자신의 '내부 삭제 리스트'로 가져온다.

            if(rhs.ml_CutUnitCnt<1) return;

            ZCLinkUnit* VP_RhsNowTail=rhs.mp_CutHeadUnit->mp_PrevUnit;

            if(--rhs.ml_CutUnitCnt<1)
                rhs.mp_CutHeadUnit=0;
            else
            {
                ZCLinkUnit::MakeRing(
                    rhs.mp_CutHeadUnit, VP_RhsNowTail->mp_PrevUnit);
            }/*
            else*/

            if(++ml_CutUnitCnt<=1)
            {
                ZCLinkUnit::MakeRing(VP_RhsNowTail, VP_RhsNowTail);

                mp_CutHeadUnit=VP_RhsNowTail; /////////////////////
            }
            else
            {
                ZCLinkUnit::JoinLink(mp_CutHeadUnit->mp_PrevUnit, VP_RhsNowTail);
                ZCLinkUnit::MakeRing(mp_CutHeadUnit             , VP_RhsNowTail);
            }/*
            else*/
        }/*
        void JoinRhsCutTailOneAtTail(ZtCObjUnitList& rhs)*/

        void JoinRhsCutHeadOneAtTail(ZtCObjUnitList& rhs)
        {
            // rhs 의 '내부 삭제 리스트'의 처음 1 개의 링크를
            // 자신의 '내부 삭제 리스트'로 가져온다.

            if(rhs.ml_CutUnitCnt<1) return;

            ZCLinkUnit* VP_RhsNowHead=rhs.mp_CutHeadUnit;

            rhs.mp_CutHeadUnit=rhs.mp_CutHeadUnit->mp_NextUnit;

            if(--rhs.ml_CutUnitCnt<1) {rhs.mp_CutHeadUnit=0;} else
            {
                ZCLinkUnit::MakeRing(
                    rhs.mp_CutHeadUnit, VP_RhsNowHead->mp_PrevUnit);
            }/*
            ////////////////////////////////////////////////////*/

            if(++ml_CutUnitCnt<=1)
            {
                ZCLinkUnit::
                    MakeRing(VP_RhsNowHead, VP_RhsNowHead);
                mp_CutHeadUnit = VP_RhsNowHead;
            }
            else
            {
                ZCLinkUnit::JoinLink(mp_CutHeadUnit->mp_PrevUnit, VP_RhsNowHead);
                ZCLinkUnit::MakeRing(mp_CutHeadUnit             , VP_RhsNowHead);
            }/*
            else*/
        }/*
        void JoinRhsCutHeadOneAtTail(ZtCObjUnitList& rhs)*/


        TypeData& GetDataInIter(TypeData*   AP_Object   )
            { return *AP_Object              ; }
        TypeArr & GetDataInIter(ZCLinkUnit* AP_CLinkUnit)
            { return AP_CLinkUnit->mo_TypeArr; }

        void MoveNextIter(TypeData*& APR_Object){++APR_Object;}
        void MovePrevIter(TypeData*& APR_Object){--APR_Object;}

        void MoveNextIter(ZCLinkUnit*& APR_CLinkUnit)
            { APR_CLinkUnit=APR_CLinkUnit->mp_NextUnit; }
        void MovePrevIter(ZCLinkUnit*& APR_CLinkUnit)
            { APR_CLinkUnit=APR_CLinkUnit->mp_PrevUnit; }


        void ItNext(TypeData*& APR_Object){++APR_Object;}
        void ItPrev(TypeData*& APR_Object){--APR_Object;}

        void ItNext(ZCLinkUnit*& APR_CLinkUnit)
            { APR_CLinkUnit=APR_CLinkUnit->mp_NextUnit; }
        void ItPrev(ZCLinkUnit*& APR_CLinkUnit)
            { APR_CLinkUnit=APR_CLinkUnit->mp_PrevUnit; }

        TypeData& ItD(TypeData*   AP_Object   )
            { return *AP_Object    ; }
        TypeArr & ItD(ZCLinkUnit* AP_CLinkUnit)
            { return **AP_CLinkUnit; }

    public :
    };/*
    template<   typename TType , ///////////////////////////////////////////
                typename TTypeObjUnitList =
                    ZNsType::ZtCTypeObjUnitList<TType>
            >
    class ZtCObjUnitList /////////////////////////////////////////////////*/

}/*
namespace ZNsMain*/


#endif //__ZCPPMAIN__ZTCOBJLIST_H__