#ifndef __NSMAIN_CLOADDATABLOCK_H__
#define __NSMAIN_CLOADDATABLOCK_H__


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


using namespace ZNsMain;


namespace ZNsMain
{

    template<   typename TDerive    , /////////
                typename TStringData,
                bool     TBooIncMark
            >
    class ZtCLoadDataBlock; ///////////////////


    namespace ZNsInterface
    {

        template<typename TStringData> class ZtCChildLoadDataBlock
        {
        public   :

            template<   typename TyDerive , ////////////////
                        typename TyString ,
                        bool     TyBoIncMark
                    >
            friend class ZtCLoadDataBlock; /////////////////

        public   :
            typedef typename TStringData::TypeData TypeChar;
        protected:

            ZERun ExecBlockIn(const TStringData& AR_CStringData)
            {
                cout<<"Search Data Block IN =>\""<<AR_CStringData<<"\""<<endl; return ZERun_OK;
            }/*
            ZERun ExecBlockIn(const TStringData& AR_CStringData)*/

            template<typename THelpObj> ZERun ExecBlockIn
                (const TStringData& AR_CStringData, THelpObj AO_HelpObj)
            {
                cout<<"Help:Search Data Block IN =>\""<<AR_CStringData<<"\""<<endl; return ZERun_OK;
            }/*
            template<typename THelpObj> ZERun ExecBlockIn
                (const TStringData& AR_CStringData, THelpObj AO_HelpObj)*/


            ZERun ExecBlockOut(const TypeChar* AP_Data, ZTypLength AL_Length)
            {
                if(AL_Length>0)
                     cout<<"Search Data Block OUT=>\""    ;
                else cout<<"Search Data Block OUT=>\"NULL";

                for(ZTypLength i=0; i<AL_Length; ++i)
                    { cout.put(AP_Data[i]); }
                /////////////////////////////////////

                cout<<"\""<<endl; return ZERun_OK;
            }/*
            ZERun ExecBlockOut(const TypeChar* AP_Data, ZTypLength AL_Length)*/

            template<typename THelpObj> ZERun ExecBlockOut
                (const TypeChar* AP_Data, ZTypLength AL_Length, THelpObj AO_HelpObj)
            {
                if(AL_Length>0)
                     cout<<"Help:Search Data Block OUT=>\""    ;
                else cout<<"Help:Search Data Block OUT=>\"NULL";

                for(ZTypLength i=0; i<AL_Length; ++i)
                    { cout.put(AP_Data[i]); }
                /////////////////////////////////////

                cout<<"\""<<endl; return ZERun_OK;
            }/*
            template<typename THelpObj> ZERun ExecBlockOut ZERun ExecBlockOut
                (const TypeChar* AP_Data, ZTypLength AL_Length, THelpObj AO_HelpObj)*/

        protected:
        };/*
        template<typename TStringData> class ZtCChildLoadDataBlock */

    }/*
    namespace ZNsInterface*/


    /*  찾은 2 개 문자열 사이에 있는 문자열 블럭에 대하여 특정한 처리를 해준다.
        찾은 2 개 문자열 사이에 아무 문자열이 없더라도 지정된 함수를 호출한다. */

    template<   typename TDerive    , // ZNsIFace::ZtCChildLoadDataBlock<>
                typename TStringData,
                bool     TBooIncMark =false
            >
    class ZtCLoadDataBlock ////////////////
    {
    public   :
        typedef          TStringData               ZCStringData;
        typedef typename ZCStringData::ZCMainChars ZCMainChars ;
        typedef typename ZCStringData::TypeChar    TypeChar    ;
        typedef typename ZCStringData::TypeLength  TypeLength  ;
    public   :
        typedef TStringData TypeData;
    protected:

        TStringData mo_StartMarkCStr;
        TStringData mo_CloseMarkCStr;
        TStringData mo_MarkBuffCStr ; // FindPosReady() 함수를 위한 버퍼
        TStringData mo_BlockBuffCStr; // mo_StartMarkCStr, mo_CloseMarkCStr 사이에 있는 데이타는 여기에 쌓아둔다.
        bool        mb_DoFindStart  ; // mo_StartMarkCStr 을 찾은 상태라면 true

  //protected:
    private  :
        TDerive& GetChildObj(){ return static_cast<TDerive&>(*this); }
    public   :

        _NP_ ZERun OnMeetNormal(const TypeChar* APC_Data, TypeLength AL_Length)
        {
            if(mb_DoFindStart==true)
            {
                if(TBooIncMark==true && mo_BlockBuffCStr.size()<1)
                    { mo_BlockBuffCStr.append(mo_StartMarkCStr); }

                mo_BlockBuffCStr.append(APC_Data, AL_Length);

                return ZERun_OK; ////////////////////////////
            }/*
            if(mb_DoFindStart==true)*/

            return GetChildObj().ExecBlockOut(APC_Data, AL_Length);
        }/*
        _NP_ ZERun OnMeetNormal(const TypeChar* APC_Data, TypeLength AL_Length)*/

        template<typename THelpType> _NP_ ZERun OnMeetNormal(
            const TypeChar* APC_Data, TypeLength AL_Length, THelpType AO_CHelpType)
        {
            typedef ZNsMain::ZtCCheckRef<THelpType> ZCCheckRef;

            if(mb_DoFindStart==true)
            {
                if(TBooIncMark==true && mo_BlockBuffCStr.size()<1)
                    { mo_BlockBuffCStr.append(mo_StartMarkCStr); }

                mo_BlockBuffCStr.append(APC_Data, AL_Length);

                return ZERun_OK; ////////////////////////////
            }/*
            if(mb_DoFindStart==true)*/

            return GetChildObj().ExecBlockOut
                (
                    APC_Data, AL_Length, ZCCheckRef::PassData(AO_CHelpType)
                );
            /////////////////////////////////
        }/*
        template<typename THelpType> _NP_ ZERun OnMeetNormal(
            const TypeChar* APC_Data, TypeLength AL_Length, THelpType AO_CHelpType) */

        _NP_ ZERun OnMeetReady
            (
                const TypeChar* APC_Data, TypeLength AL_Length, ZERun AE_ERun
            )
        /*##################*/
        {
            if(AE_ERun==ZERun_OK) return ZERun_OK;

            if(mb_DoFindStart==true)
            {
                /*//////////////////////////////////////////////////////////////////////////////////////////////////
                
                ■  mo_StartMarkCStr 은 이미 찾은 상태에서 mo_CloseMarkCStr 을 찾았기 때문에 이 함수가 호출된 것이다.
                    이때는 mo_CloseMarkCStr 을 찾기 전까지 모아 두었던 데이타 mo_BlockBuffCStr 을 출력하고 내용을 비
                    운다. 이 함수 수행이 끝나면 바로 mb_DoFindStart 는 false 가 된다.

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

                if(TBooIncMark==true) mo_BlockBuffCStr.append(mo_CloseMarkCStr);

                if(GetChildObj().ExecBlockIn(mo_BlockBuffCStr)==ZERun_NO)
                {
                    mo_BlockBuffCStr=""; return ZERun_NO;
                }/*
                if(GetChildObj().ExecBlockIn(mo_BlockBuffCStr)==ZERun_NO)*/

                mo_BlockBuffCStr="";
            }/*
            if(mb_DoFindStart==true)*/

            return ZERun_OK;
        }/*
        _NP_ ZERun OnMeetReady
            (
                const TypeChar* APC_Data, TypeLength AL_Length, ZERun AE_ERun
            )
        ####################*/


        template<typename THelpType> _NP_ ZERun OnMeetReady
            (
                const TypeChar* APC_Data, TypeLength AL_Length,
                ZERun AE_ERun           , THelpType  AO_CHelpType
            )
        /*###############################################*/
        {
            typedef ZNsMain::
                ZtCCheckRef<THelpType> ZCCheckRef;

            if(AE_ERun==ZERun_OK) return ZERun_OK;

            if(mb_DoFindStart==true)
            {
                /*//////////////////////////////////////////////////////////////////////////////////////////////////
                
                ■  mo_StartMarkCStr 은 이미 찾은 상태에서 mo_CloseMarkCStr 을 찾았기 때문에 이 함수가 호출된 것이다.
                    이때는 mo_CloseMarkCStr 을 찾기 전까지 모아 두었던 데이타 mo_BlockBuffCStr 을 출력하고 내용을 비
                    운다. 이 함수 수행이 끝나면 바로 mb_DoFindStart 는 false 가 된다.

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

                if(TBooIncMark==true)
                    { mo_BlockBuffCStr.append(mo_CloseMarkCStr); }

                if  ( GetChildObj().ExecBlockIn
                        (
                            mo_BlockBuffCStr, ZCCheckRef::PassData(AO_CHelpType)
                        )
                        ==ZERun_NO
                    )
                ///////////////////////////////
                {
                    mo_BlockBuffCStr=""; return ZERun_NO;
                }
                ///////////////////////////////////

                mo_BlockBuffCStr = "";
            }/*
            if(mb_DoFindStart==true)*/

            return ZERun_OK;
        }/*
        template<typename THelpType> _NP_ ZERun OnMeetReady
            (
                const TypeChar* APC_Data, TypeLength AL_Length,
                ZERun AE_ERun           , THelpType  AO_CHelpType
            )
        #################################################*/

  /*public:*/
    public:

        ZtCLoadDataBlock()
        {
            mb_DoFindStart=false;
        }/*
        ZtCLoadDataBlock()*/

        ~ZtCLoadDataBlock()
        {
        }/*
        ~ZtCLoadDataBlock()*/

        TStringData& GetStartMark(){return mo_StartMarkCStr;}
        TStringData& GetCloseMark(){return mo_CloseMarkCStr;}
        TStringData& GetMarkBuff (){return mo_MarkBuffCStr ;}

        ZERun LoadData(const TypeChar* APC_Data, TypeLength AL_Length)
        {
            bool       VB_IsOK    =false    ;
            TypeLength VL_StartPos=0        ;
            ZERun      VE_ERun    =ZERun_OK ;

            do ////
            {
                if(mb_DoFindStart==false)
                {
                    VB_IsOK = ZCMainChars::template
                        FindPosReady<ZtCLoadDataBlock&, TStringData>
                            (
                                *this                   ,
                                APC_Data                ,
                                mo_StartMarkCStr.data() ,
                                AL_Length               ,
                                mo_StartMarkCStr.size() ,
                                RR(mo_MarkBuffCStr)     ,
                                RR(VL_StartPos)         ,
                                RR(VE_ERun)
                            );
                    ////////////////////////////////////////////////

                    if(VB_IsOK==true) mb_DoFindStart=true;
                }
                else // mb_DoFindStart==true
                {
                    VB_IsOK=ZCMainChars::template
                        FindPosReady<ZtCLoadDataBlock&, TStringData>
                            (
                                *this                   ,
                                APC_Data                ,
                                mo_CloseMarkCStr.data() ,
                                AL_Length               ,
                                mo_CloseMarkCStr.size() ,
                                RR(mo_MarkBuffCStr)     ,
                                RR(VL_StartPos)         ,
                                RR(VE_ERun)
                              );
                    ////////////////////////////////////////////////

                    if(VB_IsOK==true) mb_DoFindStart=false;
                }/*
                else // mb_DoFindStart==true */
            }
            while(VB_IsOK==true && VE_ERun==ZERun_OK);

            return VE_ERun; //////////////////////////
        }/*
        ZERun LoadData(const TypeChar* APC_Data, TypeLength AL_Length)*/

        ZERun LoadData(const TStringData& AR_CStringData)
        {
            return LoadData(AR_CStringData.data(), AR_CStringData.size());
        }/*
        ZERun LoadData(const TStringData& AR_CStringData)*/


        template<typename THelpType> ZERun LoadData(
            const TStringData& AR_CStringData, THelpType AO_CHelpType)
        {
            return LoadData<THelpType> ///////////////
                (
                    AR_CStringData.data(), AR_CStringData.size(), AO_CHelpType
                );
            //////////////////////////////////////////
        }/*
        template<typename THelpType> ZERun LoadData(
            const TStringData& AR_CStringData, THelpType AO_CHelpType) */

        template<typename THelpType> ZERun LoadData(
            const TypeChar* APC_Data, TypeLength AL_Length, THelpType AO_CHelpType)
        {
            typedef ZNsMain::ZtCCheckRef<THelpType> ZCCheckRef;
            typedef typename ZCCheckRef::TypeData   TypeObject;

            bool       VB_IsOK    =false    ;
            ZTypLength VL_StartPos=0        ;
            ZERun      VE_ERun    =ZERun_OK ;

            do ////
            {
                if(mb_DoFindStart==false)
                {
                    VB_IsOK = ZCMainChars::template FindPosReady
                        <ZtCLoadDataBlock&, TStringData, TypeObject>
                            (
                                *this
                              , ZCCheckRef::PassData(AO_CHelpType)
                              , APC_Data
                              , mo_StartMarkCStr.data()
                              , AL_Length
                              , mo_StartMarkCStr.size()
                              , RR(mo_MarkBuffCStr)
                              , RR(VL_StartPos    )
                              , RR(VE_ERun        )
                            );
                    ////////////////////////////////////////////////

                    if(VB_IsOK==true) mb_DoFindStart=true;
                }
                else // mb_DoFindStart==true
                {
                    VB_IsOK = ZCMainChars::template FindPosReady
                        <ZtCLoadDataBlock&, TStringData, TypeObject>
                            (
                                *this
                              , ZCCheckRef::PassData(AO_CHelpType)
                              , APC_Data
                              , mo_CloseMarkCStr.data()
                              , AL_Length
                              , mo_CloseMarkCStr.size()
                              , RR(mo_MarkBuffCStr)
                              , RR(VL_StartPos    )
                              , RR(VE_ERun        )
                            );
                    ////////////////////////////////////////////////

                    if(VB_IsOK==true) mb_DoFindStart=false;
                }/*
                else // mb_DoFindStart==true*/
            }
            while(VB_IsOK==true && VE_ERun==ZERun_OK);

            return VE_ERun; //////////////////////////////////////
        }/*
        template<typename THelpType> ZERun LoadData(
            const TypeChar* APC_Data, TypeLength AL_Length, THelpType AO_CHelpType) */


        void InitBuff()
        {
            mb_DoFindStart  =false;

            mo_MarkBuffCStr ="";
            mo_BlockBuffCStr="";
        }/*
        void InitBuff()*/

        void FiniBuff()
        {
            if(mb_DoFindStart==true     ) GetChildObj().
                ExecBlockOut(mo_StartMarkCStr.data(), mo_StartMarkCStr.size());
            if(mo_BlockBuffCStr.size()>0) GetChildObj().
                ExecBlockOut(mo_BlockBuffCStr.data(), mo_MarkBuffCStr.size());
            if(mo_MarkBuffCStr .size()>0) GetChildObj().
                ExecBlockOut(mo_MarkBuffCStr. data(), mo_MarkBuffCStr. size());
        }/*
        void FiniBuff()*/

        template<typename THelpType> void FiniBuff(THelpType AO_CHelpType)
        {
            typedef ZNsMain::ZtCCheckRef<THelpType> ZCCheckRef;

            if(mb_DoFindStart==true     ) GetChildObj().ExecBlockOut
                (mo_StartMarkCStr.data(), mo_StartMarkCStr.size(), ZCCheckRef::PassData(AO_CHelpType));
            if(mo_BlockBuffCStr.size()>0) GetChildObj().ExecBlockOut
                (mo_BlockBuffCStr.data(), mo_BlockBuffCStr.size(), ZCCheckRef::PassData(AO_CHelpType));
            if(mo_MarkBuffCStr .size()>0) GetChildObj().ExecBlockOut
                (mo_MarkBuffCStr. data(), mo_MarkBuffCStr. size(), ZCCheckRef::PassData(AO_CHelpType));
        }/*
        template<typename THelpType> void FiniBuff(THelpType AO_CHelpType) */


    public:
    };/*
    template<   typename TDerive     ,
                typename TStringData ,
                bool     TBooIncMark =false
            >
    class ZtCLoadDataBlock //////////////*/



    namespace ZNsType
    {

        template<   typename TStringData ,
                    typename TTypeBase  = ZNsIFace::
                        ZtCChildLoadDataBlock<TStringData>,
                    bool     TBooIncMark=false
                >
        class ZtCTypeLoadDataBlock //////////////////////////////////////////////////
        {
        public:

            class ZCLoadDataBlock :
                public TTypeBase,  public ZNsMain::ZtCLoadDataBlock
                <
                    ZCLoadDataBlock, TStringData, TBooIncMark
                >
            ///////////////////////////////////////////////////////
                {  };/*
            class CTypeLoadDataBlock ////////////////////////////*/

            typedef          TStringData                ZCStringData;
            typedef typename ZCStringData::ZCMainChars  ZCMainChars ;
            typedef typename ZCStringData::TypeChar     TypeChar    ;
            typedef typename ZCStringData::TypeLength   TypeLength  ;
            typedef          ZCLoadDataBlock            TypeMain    ;

        public:
        };/*
        template<   typename TStringData ,
                    typename TTypeBase  =ZNsIFace::
                        ZtCChildLoadDataBlock<TStringData>,
                    bool     TBooIncMark=false
                >
        class ZtCTypeLoadDataBlock ////////////////////////////////////////////////*/

    }/*
    namespace ZNsType*/


    namespace ZNsExam
    {

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

        ■  ZCMainChars::FindPosReady<>(~) 함수를 이용한 예제.

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


        template<typename TStringData> class ZtCExamReadyExec
        {
        public   :
            typedef ZNsMain::ZCMainChars ZCMainChars;
        protected:
            TStringData mo_StartMarkCStr ;
            TStringData mo_CloseMarkCStr ;
            TStringData mo_MarkBuffCStr  ;
            TStringData mo_BuffMarkExCStr;
            TStringData mo_BlockBuffCStr ; // mo_StartMarkCStr, mo_CloseMarkCStr 사이에 있는 데이타는 여기에 쌓아둔다.
            bool        mb_DoFindStart   ; // mo_StartMarkCStr 을 찾을 상태라면 true
        public   :

            ZtCExamReadyExec()
            {
                mo_StartMarkCStr="{◆◆◆◆◆{";
                mo_CloseMarkCStr="}◆◆◆◆◆}";
                mb_DoFindStart  =false;
            }/*
            ZtCExamReadyExec()*/

            ~ZtCExamReadyExec()
            {
                ShowMarkBuff();
            }/*
            ~ZtCExamReadyExec()*/

            TStringData& GetStartMark(){return mo_StartMarkCStr;}
            TStringData& GetCloseMark(){return mo_CloseMarkCStr;}

            const TStringData& GetStartMark() const {return mo_StartMarkCStr;}
            const TStringData& GetCloseMark() const {return mo_CloseMarkCStr;}

            ZERun OnMeetNormal(const char* APC_Data, ZTypLength AL_Length)
            {
                if(mb_DoFindStart==true)
                    mo_BlockBuffCStr.append(APC_Data, AL_Length);
                else
                {   TStringData  VO_CString(APC_Data, AL_Length);

                    cout<<"OnMeetNormal ="<<VO_CString<<"(Length="<<AL_Length<<")"<<endl;
                }/*
                else*/

                return ZERun_OK;
            }/*
            ZERun OnMeetNormal(const char* APC_Data, ZTypLength AL_Length)*/

            template<typename THelpType> ZERun OnMeetNormal
                (const char* APC_Data, ZTypLength AL_Length, THelpType AO_CHelpType)
            {
                if(mb_DoFindStart==true)
                    mo_BlockBuffCStr.append(APC_Data, AL_Length);
                else
                {   TStringData  VO_CString(APC_Data, AL_Length);

                    cout<<"THelpType ☞ "<<typeid(THelpType).name()<<" : OnMeetNormal ="<<VO_CString<<endl;
                }/*
                else*/

                return ZERun_OK;
            }/*
            template<typename THelpType> ZERun OnMeetNormal
                (const char* APC_Data, ZTypLength AL_Length, THelpType AO_CHelpType) */

            ZERun OnMeetReady(const char* APC_Data, ZTypLength AL_Length, ZERun AE_ERun)
            {
                if(AE_ERun==ZERun_OK)
                {
                    mo_BuffMarkExCStr.append(APC_Data, AL_Length); return ZERun_OK;
                }/*
                if(AE_ERun==ZERun_OK)*/

                if(mb_DoFindStart==true)
                {
                    cout<<"♣♣Body♣♣ ="<<mo_BlockBuffCStr<<endl; mo_BlockBuffCStr="";
                }/*
                if(mb_DoFindStart==true)*/

                mo_BuffMarkExCStr.append(APC_Data, AL_Length);
                {
                    cout<<endl<<"OnMeetReady="<<mo_BuffMarkExCStr<<endl;
                }
                mo_BuffMarkExCStr=""; ////////////////////////

                return ZERun_OK;
            }/*
            ZERun OnMeetReady(const char* APC_Data, ZTypLength AL_Length, ZERun AE_ERun)*/

            template<typename THelpType> ZERun OnMeetReady
                (const char* APC_Data, ZTypLength AL_Length, ZERun AE_ERun, THelpType AO_CHelpType)
            {
                if(AE_ERun==ZERun_OK)
                {
                    mo_BuffMarkExCStr.append(APC_Data,AL_Length); return ZERun_OK;
                }/*
                if(AE_ERun==ZERun_OK)*/

                if(mb_DoFindStart==true)
                {
                    cout<<"♣♣Body♣♣ ="<<mo_BlockBuffCStr<<endl; mo_BlockBuffCStr="";
                }/*
                if(mb_DoFindStart==true) */

                mo_BuffMarkExCStr.append(APC_Data,AL_Length);
                {
                    cout<<"THelpType ☞ "<<typeid(THelpType).name()<<" : OnMeetReady! ="<<mo_BuffMarkExCStr<<endl;
                }
                mo_BuffMarkExCStr=""; ///////////////////////

                return ZERun_OK;
            }/*
            template<typename AO_CHelpType> ZERun OnMeetReady
                (const char* APC_Data, ZTypLength AL_Length, ZERun AE_ERun, THelpType AO_CHelpType) */

            void LoadData(const char* APC_Data, ZTypLength AL_Length)
            {
                bool       VB_IsOK    =false    ;
                ZTypLength VL_StartPos=0        ;
                ZERun      VE_ERun    =ZERun_OK ;

                do ////
                {
                    if(mb_DoFindStart==false)
                    {
                        VB_IsOK=ZCMainChars::FindPosReady
                            <ZtCExamReadyExec&, char, TStringData>
                                (
                                    *this
                                  , APC_Data
                                  , mo_StartMarkCStr.data()
                                  , AL_Length
                                  , mo_StartMarkCStr.size()
                                  , RR(mo_MarkBuffCStr)
                                  , RR(VL_StartPos)
                                  , RR(VE_ERun)
                                );
                        //////////////////////////////////////////

                        if(VB_IsOK==true) mb_DoFindStart=true;
                    }
                    else // mb_DoFindStart==true
                    {
                        VB_IsOK=ZCMainChars::FindPosReady
                            <ZtCExamReadyExec&, char, TStringData>
                                (
                                    *this
                                  , APC_Data
                                  , mo_CloseMarkCStr.data()
                                  , AL_Length
                                  , mo_CloseMarkCStr.size()
                                  , RR(mo_MarkBuffCStr)
                                  , RR(VL_StartPos)
                                  , RR(VE_ERun)
                                );
                        //////////////////////////////////////////

                        if(VB_IsOK==true) mb_DoFindStart=false;
                    }/*
                    else // mb_DoFindStart==true*/
                }
                while(VB_IsOK==true);
            }/*
            void LoadData(const char* APC_Data, ZTypLength AL_Length)*/

            template<typename THelpType> void LoadData(
                const char* APC_Data, ZTypLength AL_Length, THelpType AO_CHelpType)
            {
                typedef ZNsMain::ZtCCheckRef<THelpType> ZCCheckRef;
                typedef typename ZCCheckRef::TypeData   TypeObject;

                bool       VB_IsOK    =false    ;
                ZTypLength VL_StartPos=0        ;
                ZERun      VE_ERun    =ZERun_OK ;

                do ////
                {
                    if(mb_DoFindStart==false)
                    {
                        VB_IsOK = ZCMainChars::FindPosReady
                            <ZtCExamReadyExec&, char, TStringData, TypeObject>
                                (
                                    *this
                                  , ZCCheckRef::PassData(AO_CHelpType)
                                  , APC_Data
                                  , mo_StartMarkCStr.data()
                                  , AL_Length
                                  , mo_StartMarkCStr.size()
                                  , RR(mo_MarkBuffCStr)
                                  , RR(VL_StartPos)
                                  , RR(VE_ERun)
                                );
                        /////////////////////////////////////////////////////

                        if(VB_IsOK==true) mb_DoFindStart=true;
                    }
                    else // mb_DoFindStart==true
                    {
                        VB_IsOK = ZCMainChars::FindPosReady
                            <ZtCExamReadyExec&, char, TStringData, TypeObject>
                                (
                                    *this
                                  , ZCCheckRef::PassData(AO_CHelpType)
                                  , APC_Data
                                  , mo_CloseMarkCStr.data()
                                  , AL_Length
                                  , mo_CloseMarkCStr.size()
                                  , RR(mo_MarkBuffCStr)
                                  , RR(VL_StartPos)
                                  , RR(VE_ERun)
                                );
                        //////////////////////////////////////////////

                        if(VB_IsOK==true) mb_DoFindStart=false;
                    }/*
                    else // mb_DoFindStart==true */
                }
                while(VB_IsOK==true);
            }/*
            template<typename THelpType> void LoadData(
                const char* APC_Data, ZTypLength AL_Length, THelpType AO_CHelpType) */

            void ShowMarkBuff()
            {
                if(mo_MarkBuffCStr.size()>0)
                      cout<<"MarkBuff="    <<mo_MarkBuffCStr.data()<<endl;
                else  cout<<"MarkBuff=NULL"<<endl;
            }/*
            void ShowMarkBuff()*/

        public:
        };/*
        template<typename TStringData> class ZtCExamReadyExec*/


        template<typename TDummy=void> class ZtCDummy
        {
        public:
            typedef ZNsMain::ZtCStringBase<char>    ZCStringBase;
            typedef typename ZCStringBase::TypeChar TypeChar    ;
        public:


            class ZCExamLoadBlock1 : public ZNsMain::
                ZtCLoadDataBlock<ZCExamLoadBlock1, ZCStringBase>
            {
            protected:

                friend class ZNsMain::ZtCLoadDataBlock<ZCExamLoadBlock1, ZCStringBase>;

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

                ■  ZNsMain::ZtCLoadDataBlock<CLoadDataBlock, ZCStringBase> 을 TypeBase
                    로 typedef 하고 friend class TypeBase 라 하면 g++ 에서는 컴파일이 안
                    된다.

                        CLoadDataBlock_test.cpp:26: error:
                        using typedef-name `std::CLoadDataBlock::TypeBase' after `class'

                    Visual C++ 2008 에서는 컴파일되는데, 이점은 Visual C++ 쪽이 좀 더 합
                    리적인 것 같다.

                    -- 2008-12-10 21:14:00

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

            protected:

                ZERun ExecBlockIn(const ZCStringBase& AR_CString)
                {
                    cout<<"▷ Search Data Block IN =>\""<<AR_CString<<"\""<<endl; return ZERun_OK;
                }/*
                ZERun ExecBlockIn(const ZCStringBase& AR_CString)*/

                template<typename THelpObj> ZERun ExecBlockIn
                    (const ZCStringBase& AR_CStringData, THelpObj AO_HelpObj)
                {
                    cout<<"Help:Search Data Block IN =>\""<<AR_CStringData<<"\""<<endl; return ZERun_OK;
                }/*
                template<typename THelpObj> ZERun ExecBlockIn
                    (const ZCStringBase& AR_CStringData, THelpObj AO_HelpObj)*/


                ZERun ExecBlockOut(const char* AP_Data, long AL_Length)
                {
                    if(AL_Length>0)
                          cout<<"▷ Search Data Block OUT=>\""    ;
                    else  cout<<"▷ Search Data Block OUT=>\"NULL";

                    for(long i=0;i<AL_Length;++i)
                    {
                        cout.put( AP_Data[i] );
                    }
                    /////////////////////////////

                    cout<<"\""<<endl;  return ZERun_OK;
                }/*
                ZERun ExecBlockOut(const char* AP_Data, long AL_Length)*/

                template<typename THelpObj> ZERun ExecBlockOut
                    (const TypeChar* AP_Data, ZTypLength AL_Length, THelpObj AO_HelpObj)
                {
                    if(AL_Length>0)
                          cout<<"▷ Help:Search Data Block OUT=>\""    ;
                    else  cout<<"▷ Help:Search Data Block OUT=>\"NULL";

                    for(long i=0;i<AL_Length;++i)
                    {
                        cout.put( AP_Data[i] );
                    }
                    /////////////////////////////

                    cout<<"\""<<endl;  return ZERun_OK;
                }/*
                template<typename THelpObj> ZERun ExecBlockOut ZERun ExecBlockOut
                    (const TypeChar* AP_Data, ZTypLength AL_Length, THelpObj AO_HelpObj)*/

            protected:
            };/*
            class ZCExamLoadBlock1 : public ZNsMain::
                ZtCLoadDataBlock<ZCExamLoadBlock1, ZCStringBase>*/


            class ZCExamLoadBlock2 : public ZNsMain::
                ZtCLoadDataBlock<ZCExamLoadBlock2, ZCStringBase>
            {
            protected:

                friend class ZNsMain::ZtCLoadDataBlock<ZCExamLoadBlock2, ZCStringBase>;

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

                ■  ZNsMain::ZtCLoadDataBlock<CLoadDataBlock, ZCStringBase> 을 TypeBase
                    로 typedef 하고 friend class TypeBase 라 하면 g++ 에서는 컴파일이 안
                    된다.

                        CLoadDataBlock_test.cpp:26: error:
                        using typedef-name `std::CLoadDataBlock::TypeBase' after `class'

                    Visual C++ 2008 에서는 컴파일되는데, 이점은 Visual C++ 쪽이 좀 더 합
                    리적인 것 같다.

                    -- 2008-12-10 21:14:00

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

            protected:

                ZERun ExecBlockIn(const ZCStringBase& AR_CString)
                {
                    cout<<"▷ Search2 Data Block IN =>\""<<AR_CString<<"\""<<endl; return ZERun_OK;
                }/*
                ZERun ExecBlockIn(const ZCStringBase& AR_CString)*/

                template<typename THelpObj> ZERun ExecBlockIn
                    (const ZCStringBase& AR_CStringData, THelpObj& AO_HelpObj)
                {
                    cout<<"Help2:Search2 Data Block IN =>\""<<AR_CStringData<<"\""<<endl; return ZERun_OK;
                }/*
                template<typename THelpObj> ZERun ExecBlockIn
                    (const ZCStringBase& AR_CStringData, THelpObj& AO_HelpObj)*/


                ZERun ExecBlockOut(const char* AP_Data, long AL_Length)
                {
                    if(AL_Length>0)
                          cout<<"▷ Search2 Data Block OUT=>\""    ;
                    else  cout<<"▷ Search2 Data Block OUT=>\"NULL";

                    for(long i=0;i<AL_Length;++i)
                    {
                        cout.put( AP_Data[i] );
                    }
                    /////////////////////////////

                    cout<<"\""<<endl;  return ZERun_OK;
                }/*
                ZERun ExecBlockOut(const char* AP_Data, long AL_Length)*/

                template<typename THelpObj> ZERun ExecBlockOut
                    (const TypeChar* AP_Data, ZTypLength AL_Length, THelpObj& AO_HelpObj)
                {
                    if(AL_Length>0)
                          cout<<"▷ Help2:Search2 Data Block OUT=>\""    ;
                    else  cout<<"▷ Help2:Search2 Data Block OUT=>\"NULL";

                    for(long i=0;i<AL_Length;++i)
                    {
                        cout.put( AP_Data[i] );
                    }
                    /////////////////////////////

                    cout<<"\""<<endl;  return ZERun_OK;
                }/*
                template<typename THelpObj> ZERun ExecBlockOut ZERun ExecBlockOut
                    (const TypeChar* AP_Data, ZTypLength AL_Length, THelpObj& AO_HelpObj)*/

            protected:
            };/*
            class ZCExamLoadBlock2 : public ZNsMain::
                ZtCLoadDataBlock<ZCExamLoadBlock2, ZCStringBase>*/

        public:
        };/*
        template<typename TDummy=void> class ZtCDummy*/


        template<typename TDummy=void*> class ZtCExamLoadDataBlock
        {
        public:

            class ZCHelpObj
            {
            public:
                ZCHelpObj(){}
                ZCHelpObj(const ZCHelpObj& rhs)
                    { cout<<"<ZCHelpObj copy constructor>"; }
                ZCHelpObj& operator =(const ZCHelpObj& rhs)
                    { cout<<"<ZCHelpObj operator =>"      ; }
            public:
            };
            ///////////////

        public:

            static int Main(int AI_ArgCnt=0, const char* APA_ArgVal[]=0)
            {
                typedef ZNsMain    ::ZtCStringBase<char> ZCStringBase   ;

                ZNsExam::ZtCDummy<>::ZCExamLoadBlock1 VO_CLoadDataBlock1;
                ZNsExam::ZtCDummy<>::ZCExamLoadBlock2 VO_CLoadDataBlock2;

                ZCHelpObj    VO_CHelpObj     ;
                /////////////////////////////////////////////////////////

                ZCStringBase VO_CStringBase1
                    (
                        "{{}}{{body2}}{{}}{{body4-sauron}}"
                        "{bad5}}{{body6}}{{body7}"
                    );
                ZCStringBase VO_CStringBase2
                    (
                        "}}"
                    );
                /////////////////////////////////////////////////////////

                VO_CLoadDataBlock1.GetStartMark()="{{";
                VO_CLoadDataBlock1.GetCloseMark()="}}";
                VO_CLoadDataBlock2.GetStartMark()="{{";
                VO_CLoadDataBlock2.GetCloseMark()="}}";

                VO_CLoadDataBlock1.LoadData(VO_CStringBase1, VO_CHelpObj);
                VO_CLoadDataBlock1.LoadData(VO_CStringBase2, VO_CHelpObj);

                VO_CLoadDataBlock1.InitBuff();  cout<<endl<<"#### Use HelpObj Ref ###"<<endl;

                VO_CLoadDataBlock2.LoadData(VO_CStringBase1, ZftMCP(VO_CHelpObj));
                VO_CLoadDataBlock2.LoadData(VO_CStringBase2, ZftMCP(VO_CHelpObj));

                return 0; //////////////////////////////////
            }/*
            static int Main(int AI_ArgCnt=0, const char* APA_ArgVal[]=0)*/

        public:
        };/*
        template<typename TDummy=void*> class ZtCExamLoadDataBlock*/

    }/*
    namespace ZNsExam*/



    namespace ZNsInterface
    {

        template<typename TStringData> class ZtCParentLoadDataBlockArr
        {
        public:
            typedef typename TStringData::TypeData TypeChar;
        public:

            ZERun ExecBlockIn(const TypeChar* AP_Data, ZTypLength AL_Length, int AI_SearchArrNum)
            {
                cout<<"Search Data Block IN : "
                    "AI_SearchArrNum="<<AI_SearchArrNum<<", Data=>\"";

                for(ZTypLength i=0;i<AL_Length;++i)
                    { cout.put(AP_Data[i]); }

                cout<<"\""<<endl;  return ZERun_OK;
            }/*
            ZERun ExecBlockIn(const TypeChar* AP_Data, ZTypLength AL_Length, int AI_SearchArrNum) */

            ZERun ExecBlockMatch(const TypeChar* AP_Data, ZTypLength AL_Length, int AI_SearchArrNum)
            {
                if(AL_Length>0)
                      cout<<"Search Data Block Match : AI_SearchArrNum="<<AI_SearchArrNum<<", Data=>\""    ;
                else  cout<<"Search Data Block Match : AI_SearchArrNum="<<AI_SearchArrNum<<", Data=>\"NULL";

                for(ZTypLength i=0;i<AL_Length;++i)
                    { cout.put(AP_Data[i]); }

                cout<<"\""<<endl;  return ZERun_OK;
            }/*
            ZERun ExecBlockMatch(const TypeChar* AP_Data, ZTypLength AL_Length, int AI_SearchArrNum)*/


            template<typename THelpType> ZERun ExecBlockIn(
                const TypeChar* AP_Data, ZTypLength AL_Length, int AI_SearchArrNum, THelpType AO_HelpType)
            {
                cout<<"Search Data Block IN : AI_SearchArrNum="<<
                    AI_SearchArrNum         <<", THelpType=" <<
                    typeid(THelpType).name()<<", Data=>\""    ;

                for(ZTypLength i=0; i<AL_Length; ++i)
                    { cout.put(AP_Data[i]); }

                cout<<"\""<<endl;   return ZERun_OK ;
            }/*
            template<typename THelpType> ZERun ExecBlockIn(
                const TypeChar* AP_Data, ZTypLength AL_Length, int AI_SearchArrNum, THelpType AO_HelpType) */

            template<typename THelpType> ZERun ExecBlockMatch(
                const TypeChar* AP_Data, ZTypLength AL_Length, int AI_SearchArrNum, THelpType AO_HelpType)
            {
                if(AL_Length>0)
                      cout<<"Search Data Block Match : AI_SearchArrNum="<<AI_SearchArrNum<<", THelpType="<<typeid(THelpType).name()<<", Data=>\"";
                else  cout<<"Search Data Block Match : AI_SearchArrNum="<<AI_SearchArrNum<<", THelpType="<<typeid(THelpType).name()<<", Data=>\"NULL";

                for(ZTypLength i=0; i<AL_Length; ++i)
                    { cout.put(AP_Data[i]); }

                cout<<"'"<<endl;    return ZERun_OK ;
            }/*
            template<typename THelpType> ZERun ExecBlockMatch(
                const TypeChar* AP_Data, ZTypLength AL_Length, int AI_SearchArrNum, THelpType AO_HelpType) */

        public:
        };/*
        template<typename TStringData> class ZtCParentLoadDataBlockArr */

    }/*
    namespace ZNsInterface*/


    /*///////////////////////////////////////////////////////////////////////////////
    
    ■  찾는 데이타를 문자열 배열로 구성해서, 이 배열의 각 원소의 문자열을 찾을 때마다
        그 이전에 찾은 문자열 사이의 데이타에 대하여, '어떤 처리'를 해준다. 결국 '어떤
        처리'의 대상이 되려면 그 이전에 찾은 문자열이 있어야 한다.

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

    template<   typename TDerive    ,
                typename TStringData,
                typename TStringArr=ZNsMain::ZtCArray<TStringData>
            >
    class ZtCLoadDataBlockArr /*############################*/
    {
    public   :
        typedef TStringData TypeString; // 이 public 영역은 외부 참고용 type 정의다.
        typedef TStringArr  TypeData  ;
        typedef TStringArr  TypeArray ;
    public   :
        typedef typename TStringData::TypeChar    TypeChar   ;
        typedef typename TStringData::TypeLength  TypeLength ;
        typedef typename TStringData::ZCMainChars ZCMainChars;
    protected:
        typedef TStringData ZCStringData;
        typedef TStringArr  CStringArr ;
    protected:
        CStringArr    mo_CArrSearch ; // 이 배열에 있는 값을 순서대로 찾는다.
        ZCStringData* mp_CSearchNow ; // mo_CArrSearch 의 특정 원소를 가리킨다.
        ZCStringData  mo_CStringBuff;
        TypeLength    mi_NowArrPos  ; // mp_CSearchNow 이 mo_CArrSearch 에서 가리키는 번호, 유효한 번호이면 1 부터 시작
    protected:

        TDerive& GetParentObj()
        {
            return (static_cast<TDerive&>(*this));
        }/*
        TDerive& GetParentObj()*/

  /*protected:*/
    public   :

        ZtCLoadDataBlockArr()
        {
            mp_CSearchNow=0;
            mi_NowArrPos =0;
        }/*
        ZtCLoadDataBlockArr()*/

        void clear()
        {
            mp_CSearchNow=0;
            mi_NowArrPos =0;
            mo_CArrSearch.clear();
            mo_CStringBuff="";
        }/*
        void clear()*/

        void ClearCursor()
        {
            mp_CSearchNow=0;
            mi_NowArrPos =0;
            mo_CStringBuff="";
        }/*
        void ClearCursor()*/

        void ClearSearch()
        {
            mo_CArrSearch.clear();
        }/*
        void ClearSearch()*/

        CStringArr& GetSeachCStrArr()
        {
            return mo_CArrSearch;
        }/*
        CStringArr& GetSeachCStrArr()*/

        const CStringArr& GetSeachCStrArr() const
        {
            return mo_CArrSearch;
        }/*
        const CStringArr& GetSeachCStrArr() const*/

        void AddSearchData(const ZCStringData& AR_CStringData)
        {
            mo_CArrSearch.push_back(AR_CStringData);
        }/*
        void AddSearchData(const ZCStringData& AR_CStringData)*/


        TypeLength GetNowArrPos() const
        {
            return mi_NowArrPos;
        }/*
        TypeLength GetNowArrPos() const*/

        void SetNowArrPos(int AI_NewArrPos=1)
        {
            if(AI_NewArrPos>0 && AI_NewArrPos<=mo_CArrSearch.size())
              { mi_NowArrPos=AI_NewArrPos; }
        }/*
        void SetNowArrPos(int AI_NewArrPos=1)*/


        void LoadData(const TypeChar* APC_Origin, TypeLength AL_Length)
        {
            if(AL_Length<1 || mo_CArrSearch.size()<1)
            {
                return;
            }
            if(mi_NowArrPos<1)
            {
                mi_NowArrPos =1;
                mp_CSearchNow=&mo_CArrSearch[0];
            }
            if(mp_CSearchNow->size()<1)
            {
                return;
            }/*
            if(mp_CSearchNow->size()<1)*/

            const TypeChar* VPC_Origin=APC_Origin;

            TypeLength VL_StartPos  =0;
            TypeLength VL_ValidReady=0;
            TypeLength VL_ValidLen  =0;
            bool       VB_IsOK      =true;

            do ////
            {
                VPC_Origin=APC_Origin+VL_StartPos;

                VB_IsOK=ZCMainChars::FindPosReadyValid( //////////////////
                                APC_Origin           ,
                                mp_CSearchNow->data(),
                                AL_Length            ,
                                mp_CSearchNow->size(),
                                RR(mo_CStringBuff)   ,
                                RR(VL_StartPos)      ,
                                RR(VL_ValidReady)    ,
                                RR(VL_ValidLen)
                /*/////////*/ ); ////////////////////////////////////////

                if(VL_ValidReady>0)
                {
                    ZERun CE_ERun=GetParentObj().ExecBlockIn(
                                    mo_CStringBuff.data(),
                                    VL_ValidReady        ,
                                    mi_NowArrPos
                    /*/////////*/ ); ////////////////////////////////////

                    if(CE_ERun==ZERun_NO) return;
                }
                if(VL_ValidLen>0)
                {
                    ZERun CE_ERun=GetParentObj().ExecBlockIn(
                                    VPC_Origin  ,
                                    VL_ValidLen ,
                                    mi_NowArrPos
                    /*//////////*/ ); ///////////////////////////////////

                    if(CE_ERun==ZERun_NO) return;
                }/*
                if(VL_ValidLen>0)*/

                if(VB_IsOK==false) return;

                ZERun CE_ERun=GetParentObj().ExecBlockMatch(
                                mp_CSearchNow->data()   ,
                                mp_CSearchNow->size()   ,
                                mi_NowArrPos
                /*//////////*/ ); //////////////////////////////////////

                if(CE_ERun==ZERun_NO)
                    { return;         }
                if(++mi_NowArrPos>mo_CArrSearch.size())
                    { mi_NowArrPos=1; }

                mp_CSearchNow=&mo_CArrSearch[mi_NowArrPos-1];
            }
            while(true);
        }/*
        void LoadData(const TypeChar* APC_Origin, TypeLength AL_Length)*/

        void LoadData(ZCStringData& AR_CStringData)
        {
            LoadData(AR_CStringData.data(), AR_CStringData.size());
        }/*
        void LoadData(ZCStringData& AR_CStringData)*/


        template<typename THelpType> void LoadData(
            const TypeChar* APC_Origin, TypeLength AL_Length, THelpType AO_HelpType)
        {
            typedef ZNsMain::
                ZtCCheckRef<THelpType> ZCCheckRef ;


            if(AL_Length<1 || mo_CArrSearch.size()<1)
            {
                return;
            }
            if(mi_NowArrPos<1)
            {
                mi_NowArrPos =1;
                mp_CSearchNow=&mo_CArrSearch[0];
            }
            if(mp_CSearchNow->size()<1)
            {
                return;
            }/*
            if(mp_CSearchNow->size()<1)*/

      const TypeChar*  VPC_Origin   =APC_Origin;
            TypeLength VL_StartPos  =0    ;
            TypeLength VL_ValidReady=0    ;
            TypeLength VL_ValidLen  =0    ;
            bool       VB_IsOK      =true ;

            do ////
            {
                VPC_Origin=APC_Origin+VL_StartPos;

                VB_IsOK=ZCMainChars::FindPosReadyValid( ////////////////////////
                                APC_Origin           ,
                                mp_CSearchNow->data(),
                                AL_Length            ,
                                mp_CSearchNow->size(),
                                RR(mo_CStringBuff)   ,
                                RR(VL_StartPos)      ,
                                RR(VL_ValidReady)    ,
                                RR(VL_ValidLen)
                /*/////////*/ ); //////////////////////////////////////////////

                if(VL_ValidReady>0)
                {
                    const ZERun CE_ERun=GetParentObj().ExecBlockIn
                        (
                            mo_CStringBuff.data(), VL_ValidReady        ,
                            mi_NowArrPos         , ZCCheckRef::PassData(AO_HelpType)
                        );
                    //////////////////////////////////////////////

                    if(CE_ERun==ZERun_NO) return;
                }
                if(VL_ValidLen>0)
                {
                    const ZERun CE_ERun=GetParentObj().ExecBlockIn
                        (
                            VPC_Origin  , VL_ValidLen ,
                            mi_NowArrPos, ZCCheckRef::PassData(AO_HelpType)
                        );
                    //////////////////////////////////////////////

                    if(CE_ERun==ZERun_NO) return;
                }/*
                if(VL_ValidLen>0)*/

                if(VB_IsOK==false) return;

                const ZERun CE_ERun=GetParentObj().ExecBlockMatch
                    (
                        mp_CSearchNow->data(), mp_CSearchNow->size(),
                        mi_NowArrPos         , ZCCheckRef::PassData(AO_HelpType)
                    );
                /////////////////////////////////////////////////

                if(CE_ERun==ZERun_NO)
                  {return        ;}
                if(++mi_NowArrPos>mo_CArrSearch.size())
                  {mi_NowArrPos=1;}

                mp_CSearchNow = &mo_CArrSearch[mi_NowArrPos-1];
            }
            while(true);
        }/*
        template<typename THelpType> void LoadData(
            const TypeChar* APC_Origin, TypeLength AL_Length, THelpType AO_HelpType) */

        template<typename THelpType>
            void LoadData(ZCStringData& AR_CStringData, THelpType AO_HelpType)
        {
            LoadData(AR_CStringData.data(), AR_CStringData.size(), AO_HelpType);
        }/*
        template<typename THelpType>
            LoadData(ZCStringData& AR_CStringData, THelpType AO_HelpType) */

        void LoadData()
        {
            // mo_CStringBuff 에 남아 있는 마지막 데이타를 처리한다.

            if(mo_CStringBuff.size()>0)
            {
                GetParentObj().ExecBlockIn( ///////////////
                                mo_CStringBuff.data(),
                                mo_CStringBuff.size(),
                                mi_NowArrPos
                /*//////////*/ ); /////////////////////////

                mo_CStringBuff = "";
            }/*
            if(mo_CStringBuff.size()>0)*/
        }/*
        void LoadData()*/

        template<typename THelpType> void LoadDataHelp(THelpType AO_HelpType)
        {
            typedef ZNsMain::ZtCCheckRef<THelpType> ZCCheckRef;

            if(mo_CStringBuff.size()>0)
            {
                GetParentObj().ExecBlockIn //////////////
                    (
                        mo_CStringBuff.data(),
                        mo_CStringBuff.size(),
                        mi_NowArrPos         ,
                        ZCCheckRef::PassData(AO_HelpType)
                    );
                /////////////////////////////////////////

                mo_CStringBuff = "";
            }/*
            if(mo_CStringBuff.size()>0)*/
        }/*
        template<typename THelpType> void LoadDataHelp(THelpType AO_HelpType) */

    public:
    };/*
    template<   typename TDerive    ,
                typename TStringData,
                typename TStringArr =ZNsMain::ZtCArray<TStringData>
            >
    class ZtCLoadDataBlockArr */


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

    ■  ZtCLoadDataBlockArr<> class template 선언에 아래와 같이 멤버함수 템플릿이 있을 경우

        template<typename TStringData>
        void LoadData(TStringData& AR_CStringData)
        {
            LoadData(AR_CStringData.data(),AR_CStringData.size());
        }


        아래 멤버 템플릿 함수 특수화가 컴파일 안된다.

        template<>

        template<   typename TDerive    ,
                    typename TStringData,
                    typename TStringArr
                >
        void ZtCLoadDataBlockArr<TDerive,TStringData,TStringArr>::LoadData<const char*>(const char* APC_Origin)
        {
            this->LoadData(APC_Origin,ZNsMain::GetLength(APC_Origin));
        }

    ※  아래 처럼 CLoadDataBlockArr 이 템플릿이 아닌 클래스라면 컴파일된다.

        template<>
        void CLoadDataBlockArr::LoadData<const char*>(const char* APC_Origin)
        {
            this->LoadData(APC_Origin,ZNsMain::GetLength(APC_Origin));
        }

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



    namespace ZNsType
    {

        template<   typename TStringData,
                    typename TTypeBase=ZNsIFace::ZtCParentLoadDataBlockArr<TStringData>
                >
        class CTypeLoadDataBlockArr_T ////////////////////////////////////////////////
        {
        public:

            class ZCLoadDataBlock :
                public TTypeBase,  public ZNsMain::ZtCLoadDataBlockArr
                <
                    ZCLoadDataBlock, TStringData, ZNsMain::ZtCArray<TStringData>
                >
            //////////////////////////////////////////////////////////
            {
            public:

            public:
            };/*
            class ZCLoadDataBlock*/

            typedef          TStringData               ZCStringData;
            typedef typename ZCStringData::ZCMainChars ZCMainChars ;
            typedef typename ZCStringData::TypeChar    TypeChar    ;
            typedef typename ZCStringData::TypeLength  TypeLength  ;
            typedef          ZCLoadDataBlock           TypeMain    ;

        public:
        };/*
        template<   typename TStringData,
                    typename TTypeBase=ZNsIFace::ZtCParentLoadDataBlockArr<TStringData>
                >
        class CTypeLoadDataBlockArr_T //////////////////////////////////////////////*/

    }/*
    namespace ZNsType*/


    template<   typename TDerive,
                typename TStringData
            >
    class ZtCLoadDataBlockOne;


    namespace ZNsInterface
    {

        template<typename TStringData> class ZtCChildLoadDataBlockOne
        {
        public :
            template<   typename TTDerive, /*#################*/
                        typename TTStringData
                    >
            friend class ZtCLoadDataBlockOne; /*##############*/
        public :
            typedef typename TStringData::TypeChar    TypeChar   ;
            typedef typename TStringData::TypeLength  TypeLength ;
            typedef typename TStringData::ZCMainChars ZCMainChars;
      /*public :*/

        private:

            ZERun ExecBlockIn(const TypeChar* AP_Data, TypeLength AL_Length)
            {
                cout<<"Search Data Block IN : Data=>";

                for(ZTypLength i=0; i<AL_Length; ++i) cout.put(AP_Data[i]);

                cout<<endl; return ZERun_OK;
            }/*
            ZERun ExecBlockIn(const TypeChar* AP_Data, TypeLength AL_Length)*/

            ZERun ExecBlockMatch(const TypeChar* AP_Data, TypeLength AL_Length)
            {
                if(AL_Length>0)
                    cout<<"Search Data Block Match : Data=>";
                else
                    cout<<"Search Data Block Match : Data=>NULL";
              //else

                for(ZTypLength i=0; i<AL_Length; ++i) cout.put(AP_Data[i]);

                cout<<endl; return ZERun_OK;
            }/*
            ZERun ExecBlockMatch(const TypeChar* AP_Data, TypeLength AL_Length)*/


            template<typename THelpType> ZERun ExecBlockIn(
                const TypeChar* AP_Data, TypeLength AL_Length, THelpType AO_HelpType)
            {
                cout<<"Search Data Block IN : THelpType="<<typeid(THelpType).name()<<", Data=>";

                for(TypeLength i=0; i<AL_Length; ++i)
                {
                    cout.put(AP_Data[i]);
                }/*
                for(TypeLength i=0; i<AL_Length; ++i)*/

                cout<<endl; return ZERun_OK;
            }/*
            template<typename THelpType> ZERun ExecBlockIn(
                const TypeChar* AP_Data, TypeLength AL_Length, THelpType AO_HelpType)*/

            template<typename THelpType>    ZERun ExecBlockMatch(
                const TypeChar* AP_Data, TypeLength AL_Length, THelpType AO_HelpType)
            {
                if(AL_Length>0)
                    cout<<"Search Data Block Match : THelpType="<<typeid(THelpType).name()<<", Data=>";
                else
                    cout<<"Search Data Block Match : THelpType="<<typeid(THelpType).name()<<", Data=>NULL";
              //else

                for(ZTypLength i=0; i<AL_Length; ++i)
                {
                    cout.put(AP_Data[i]);
                }/*
                for(ZTypLength i=0; i<AL_Length; ++i)*/

                cout<<endl; return ZERun_OK;
            }/*
            template<typename THelpType> ZERun ExecBlockMatch(
                const TypeChar* AP_Data, TypeLength AL_Length, THelpType AO_HelpType)*/

        private:
        };/*
        template<typename TStringData> class ZtCChildLoadDataBlockOne */

    }/*
    namespace ZNsInterface*/


    /* ZtCLoadDataBlockArr<> 클래스 템플릿에서 한 개의
    문자열만 찾는 경우를 최적화한 클래스 템플릿이다. */

    template<   typename TDerive, typename TStringData
            >
    class ZtCLoadDataBlockOne ////////////////////////
    {
    public   :
        typedef TStringData ZCStringData;
    public   :
        typedef typename ZCStringData::TypeChar    TypeChar   ;
        typedef typename ZCStringData::TypeLength  TypeLength ;
        typedef typename ZCStringData::ZCMainChars ZCMainChars;
    protected:
        ZCStringData mo_CStrSearch ; // 찾아야 하는 값
        ZCStringData mo_CStringBuff;
    protected:

        TDerive& GetParentObj()
        {
            return (static_cast<TDerive&>(*this));
        }/*
        TDerive& GetParentObj()*/

  /*protected:*/
    public   :

        ZtCLoadDataBlockOne()
        {
        }/*
        ZtCLoadDataBlockOne()*/

        void clear()
        {
            mo_CStrSearch ="";
            mo_CStringBuff="";
        }/*
        void clear()*/

        ZCStringData& GetSearchCString()
        {
            return mo_CStrSearch;
        }/*
        ZCStringData& GetSearchCString()*/

        const ZCStringData& GetSearchCString() const
        {
            return mo_CStrSearch;
        }/*
        const ZCStringData& GetSearchCString() const*/

        void SetSearchCString(const TypeChar* APC_Search, TypeLength AL_Length)
        {
            mo_CStrSearch=""; mo_CStrSearch.append(APC_Search, AL_Length);
        }/*
        void SetSearchCString(const TypeChar* APC_Search, TypeLength AL_Length)*/

        void SetSearchCString(const ZCStringData& AR_CStrSearch)
        {
            mo_CStrSearch=AR_CStrSearch;
        }/*
        void SetSearchCString(const ZCStringData& AR_CStrSearch)*/

        void AddSearchData(const ZCStringData& AR_CStrSearch) // for ZtCLoadDataBlockArr 와의 호환을 위해...
        {
            mo_CStrSearch=AR_CStrSearch;
        }/*
        void AddSearchData(const ZCStringData& AR_CStrSearch)*/

        void AddSearchData(const TypeChar* APC_Search, TypeLength AL_Length) // for ZtCLoadDataBlockArr<> 와의 호환을 위해...
        {
            mo_CStrSearch=""; mo_CStrSearch.append(APC_Search, AL_Length);
        }/*
        void AddSearchData(const TypeChar* APC_Search, TypeLength AL_Length)*/


        void LoadData(const TypeChar* APC_Origin, TypeLength AL_Length)
        {
            if(AL_Length<1 || mo_CStrSearch.size()<1) return;

            const TypeChar* VPC_Origin=APC_Origin;

            TypeLength VL_StartPos  =0;
            TypeLength VL_ValidReady=0;
            TypeLength VL_ValidLen  =0;
            bool       VB_IsOK      =true;

            do ////
            {
                VPC_Origin=APC_Origin+VL_StartPos;

                VB_IsOK=ZCMainChars::FindPosReadyValid( ////////////////////////
                                APC_Origin              ,
                                mo_CStrSearch.data()    ,
                                AL_Length               ,
                                mo_CStrSearch.size()    ,
                                RR(mo_CStringBuff)      ,
                                RR(VL_StartPos)         ,
                                RR(VL_ValidReady)       ,
                                RR(VL_ValidLen)
                /*/////////*/ ); //////////////////////////////////////////////

                if(VL_ValidReady>0)
                {
                    const ZERun CE_ERun=GetParentObj().ExecBlockIn(
                                    mo_CStringBuff.data(),
                                    VL_ValidReady
                    /*/////////*/ ); //////////////////////////////////////////

                    if(CE_ERun==ZERun_NO) return;
                }
                if(VL_ValidLen>0)
                {
                    const ZERun CE_ERun=GetParentObj().ExecBlockIn(
                                    VPC_Origin  ,
                                    VL_ValidLen
                    /*//////////*/ ); /////////////////////////////////////////

                    if(CE_ERun==ZERun_NO) return;
                }/*
                if(VL_ValidLen>0)*/

                if(VB_IsOK==false) return;

                const ZERun CE_ERun=GetParentObj().ExecBlockMatch(
                                mo_CStrSearch.data(),
                                mo_CStrSearch.size()
                /*//////////*/ ); ////////////////////////////////////////////

                if(CE_ERun==ZERun_NO) return;
            }
            while(true);
        }/*
        void LoadData(const TypeChar* APC_Origin, TypeLength AL_Length)*/

        void LoadData(const ZCStringData& AR_CStringData)
        {
            LoadData(AR_CStringData.data(), AR_CStringData.size());
        }/*
        void LoadData(const ZCStringData& AR_CStringData)*/


        template<typename THelpType> void LoadData(
            const TypeChar* APC_Origin, TypeLength AL_Length, THelpType AO_HelpType)
        {
            typedef ZNsMain::ZtCCheckRef<THelpType> ZCCheckRef;

            if(AL_Length<1 || mo_CStrSearch.size()<1)  return ;

            const TypeChar* VPC_Origin=APC_Origin;

            TypeLength VL_StartPos  =0;
            TypeLength VL_ValidReady=0;
            TypeLength VL_ValidLen  =0;
            bool       VB_IsOK      =true;

            do ////
            {
                VPC_Origin=APC_Origin+VL_StartPos;

                VB_IsOK=ZCMainChars::FindPosReadyValid( ////////////////////////
                                APC_Origin              ,
                                mo_CStrSearch.data()    ,
                                AL_Length               ,
                                mo_CStrSearch.size()    ,
                                RR(mo_CStringBuff)      ,
                                RR(VL_StartPos)         ,
                                RR(VL_ValidReady)       ,
                                RR(VL_ValidLen)
                /*/////////*/ ); //////////////////////////////////////////////

                if(VL_ValidReady>0)
                {
                    const ZERun CE_ERun=GetParentObj().ExecBlockIn
                        (
                            mo_CStringBuff.data(), VL_ValidReady,
                            ZCCheckRef::PassData(AO_HelpType)
                        );
                    //////////////////////////////////////////////

                    if(CE_ERun==ZERun_NO) return;
                }
                if(VL_ValidLen>0)
                {
                    const ZERun CE_ERun=GetParentObj().ExecBlockIn
                        (
                            VPC_Origin  , VL_ValidLen ,
                            ZCCheckRef::PassData(AO_HelpType)
                        );
                    //////////////////////////////////////////////

                    if(CE_ERun==ZERun_NO) return;
                }/*
                if(VL_ValidLen>0)*/

                if(VB_IsOK==false) return;

                const ZERun CE_ERun = GetParentObj().ExecBlockMatch
                    (
                        mo_CStrSearch.data(), mo_CStrSearch.size(),
                        ZCCheckRef::PassData(AO_HelpType)
                    );
                ///////////////////////////////////////////////////

                if(CE_ERun==ZERun_NO) return;
            }
            while(true);
        }/*
        template<typename THelpType> void LoadData(
            const TypeChar* APC_Origin, TypeLength AL_Length, THelpType AO_HelpType) */

        template<typename THelpType>
            void LoadData(const ZCStringData& AR_CStringData, THelpType AO_HelpType)
        {
            LoadData(AR_CStringData.data(), AR_CStringData.size(), AO_HelpType);
        }/*
        template<typename THelpType>
            LoadData(const ZCStringData& AR_CStringData, THelpType AO_HelpType) */

        void LoadData()
        {
            // mo_CStringBuff 에 남아 있는 마지막 데이타를 처리한다.

            if(mo_CStringBuff.size()>0)
            {
                GetParentObj().ExecBlockIn
                    (mo_CStringBuff.data(), mo_CStringBuff.size());

                mo_CStringBuff="";
            }/*
            if(mo_CStringBuff.size()>0)*/
        }/*
        void LoadData()*/

        template<typename THelpType> void LoadDataHelp(THelpType AO_HelpType)
        {
            typedef ZNsMain::ZtCCheckRef<THelpType> ZCCheckRef;

            if(mo_CStringBuff.size()>0)
            {
                GetParentObj().ExecBlockIn ////////////////////
                    (
                        mo_CStringBuff.data(),
                        mo_CStringBuff.size(),
                        ZCCheckRef::PassData(AO_HelpType)
                    );
                ///////////////////////////////////////////////

                mo_CStringBuff = "" ;
            }/*
            if(mo_CStringBuff.size()>0)*/
        }/*
        template<typename THelpType> void LoadDataHelp(THelpType AO_HelpType) */

    public:
    };/*
    template<   typename TDerive, typename TStringData
            >
    class ZtCLoadDataBlockOne //////////////////////*/


    namespace ZNsType
    {

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

        ■  class ZtCLoadDataBlockOne<>  이 상속을                         해서 사용해야 한다면,
            class ZtCTypeLoadDataBlockOne<>::TypeMain 은 기초 클래스를 지정해서 사용한다.

            -- 2011-12-18 14:35:00

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

        template<   typename TStringData ,
                    typename TTypeBase=ZNsIFace::
                        ZtCChildLoadDataBlockOne<TStringData>
                >
        class ZtCTypeLoadDataBlockOne ///////////////////////
        {
        public:

            class ZCLoadDataBlock :
                            public TTypeBase ,
                            public ZNsMain::ZtCLoadDataBlockOne
                            <
                                ZCLoadDataBlock, TStringData
            /*##########*/  > /*######################################*/
            {
            public:
                typedef          TStringData               ZCStringData;
                typedef typename ZCStringData::ZCMainChars ZCMainChars ;
                typedef typename ZCStringData::TypeChar    TypeChar    ;
                typedef typename ZCStringData::TypeLength  TypeLength  ;
            public:
            };
            /*########################################################*/

            typedef          TStringData               ZCStringData;
            typedef typename ZCStringData::ZCMainChars ZCMainChars ;
            typedef typename ZCStringData::TypeChar    TypeChar    ;
            typedef typename ZCStringData::TypeLength  TypeLength  ;
            typedef          ZCLoadDataBlock           TypeMain    ;

        public:
        };/*
        template<   typename TStringData ,
                    typename TTypeBase=ZNsIFace::
                        ZtCChildLoadDataBlockOne<TStringData>
                >
        class ZtCTypeLoadDataBlockOne /////////////////////*/

    }/*
    namespace ZNsType*/

}/*
namespace ZNsMain*/


#endif //__NSMAIN_CLOADDATABLOCK_H__