#ifndef __ZCPPMAIIN__ZTCARRAY_H__
#define __ZCPPMAIIN__ZTCARRAY_H__


#include "ZCppMain/ZMainHead.H"


namespace ZNsMain
{

    template<   typename TType               ,
                typename TTypArg=const TType&,
                typename TSize  =long
            >
    class ZtCArray  //////////////////////////
    {
    public:
        typedef TType   Type      ;
        typedef TType   TypeData  ;
        typedef TTypArg TypeArg   ;
        typedef TSize   TypeSize  ;
    public:
        class ZCNodePoint; class ZCNodePointN ;
    public:
        typedef TypeData*       IterEasy      ;
        typedef TypeData*       TypeNode      ; // ZCLinkPoint::GetNode() 의 반환형.
        typedef ZCNodePoint     TypeIter      ;
        typedef ZtCArray        TypeThis      ;

        typedef const TypeThis  TypeThisC     ;
        typedef const TypeData  TypeDataC     ;
        typedef const TypeNode  TypeNodeC     ; // ZCLinkPoint::GetNode() const 의 반환형.
        typedef const TypeIter  TypeIterC     ;
        typedef const IterEasy  IterEasyC     ;

    /**********************************************/
        typedef const ZCNodePoint ZCNodePointC;
        typedef const ZCNodePoint iteratorC   ;
    /**********************************************/
        typedef ZCNodePoint     iterator      ;
        typedef ZCNodePointN    const_iterator;
        typedef ZCNodePointN    iteratorN     ;
        typedef ZCNodePointN    TypeIterN     ;
    public:


        class ZCNodePoint
        {
        private:
            ZtCArray& mr_CArray; mutable
            TypeData* mp_Data  ; mutable
            TypeSize  ml_ElePos; // *mp_Data 가 배열에서 차지하는 위치
        public:

            static ZCNodePoint MakeTailPoint(ZtCArray & AR_CArray)
            {
                ZCNodePoint VO_ZCLinkPoint(AR_CArray);

                if(AR_CArray.size()>0) /****************************/
                {
                    VO_ZCLinkPoint.mp_Data   = &AR_CArray.mp_TypeArr[AR_CArray.size()-1] ;
                    VO_ZCLinkPoint.ml_ElePos =  AR_CArray.size()  ;
                }
                return VO_ZCLinkPoint; /****************************/
            }/*
            static ZCNodePoint MakeTailPoint(ZtCArray & AR_CArray)*/
            static ZCNodePoint MakeTailPoint(TypeIterC& AR_TypeIter)
            {
                ZCNodePoint VO_ZCLinkPoint(AR_TypeIter);

                const TypeSize VL_ArrSize = AR_TypeIter.mr_CArray.size();

                if(VL_ArrSize>0) /**********************************/
                {
                    VO_ZCLinkPoint.mp_Data   = &AR_TypeIter.mr_CArray[VL_ArrSize-1] ;
                    VO_ZCLinkPoint.ml_ElePos =  VL_ArrSize  ;
                }
                return VO_ZCLinkPoint; /****************************/
            }/*
            static ZCNodePoint MakeTailPoint(TypeIterC& AR_TypeIter)*/

        public:

            ZCNodePoint(ZtCArray& AR_CArray, Type& AR_CData, TSize AL_ElePos) :
                mr_CArray(AR_CArray)
            /*****************************************************************/
            {
                mp_Data  =&AR_CData ;
                ml_ElePos=AL_ElePos ;
            }/*
            ZCNodePoint(ZtCArray& AR_CArray, Type& AR_CData, TSize AL_ElePos)*/

            ZCNodePoint(ZtCArray& AR_CArray) : mr_CArray(AR_CArray)
            {
                mp_Data  = AR_CArray.mp_TypeArr         ;
                ml_ElePos=(AR_CArray.size()>0 ? 1 : 0 ) ;
            }/*
            ZCNodePoint(ZtCArray& AR_CArray)*/

            ZCNodePoint(const ZCNodePoint& rhs) : mr_CArray(rhs.mr_CArray)
            {
                mp_Data  = rhs.mp_Data                  ;
                ml_ElePos= (mr_CArray.size()>0 ? 1 : 0 );
            }/*
            ZCNodePoint(const ZCNodePoint& rhs)*/


            TypeThis & GetMain()      {return mr_CArray       ;}
            TypeNode   GetNode()      {return mp_Data         ;}

            TypeThisC& GetMain() const{return mr_CArray       ;}
            TypeNodeC  GetNode() const{return mp_Data         ;}

            TypeSize   GetPos () const{return ml_ElePos       ;}
            TypeSize   size   () const{return mr_CArray.size();}

            TypeData & operator* ()      {return *mp_Data;}
            TypeData * operator->()      {return  mp_Data;}
            TypeDataC& operator* () const{return *mp_Data;}
            TypeDataC* operator->() const{return  mp_Data;}

            TypeIter & operator++(   )      {++mp_Data; ++ml_ElePos; return *this;}
            TypeIter   operator++(int)      {++mp_Data; ++ml_ElePos; return *this;}
            TypeIter & operator--(   )      {--mp_Data; --ml_ElePos; return *this;}
            TypeIter   operator--(int)      {--mp_Data; --ml_ElePos; return *this;}

            ZCNodePointC& operator++(   ) const{++mp_Data; ++ml_ElePos; return *this;}
            ZCNodePointC  operator++(int) const{++mp_Data; ++ml_ElePos; return *this;}
            ZCNodePointC& operator--(   ) const{--mp_Data; --ml_ElePos; return *this;}
            ZCNodePointC  operator--(int) const{--mp_Data; --ml_ElePos; return *this;}

            TypeIter operator+(TSize AL_AddPos) const
            {
                return ZCNodePoint(*this, mp_Data+AL_AddPos, ml_ElePos+AL_AddPos);
            }/*
            TypeIter operator+(TSize AL_AddPos) const*/


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

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

        public:
        };/*
        class ZCNodePoint*/


        class ZCNodePointN
        {
        private:
            mutable TypeData* mp_Data  ;
            mutable TypeSize  ml_ElePos; // *mp_Data 가 배열에서 차지하는 위치
            const   ZtCArray& mr_CArray;
        public:

            static ZCNodePointN MakeTailPoint(ZtCArray & AR_CArray)
            {
                ZCNodePointN VO_ZCLinkPoint(AR_CArray);

                if(AR_CArray.size()>0) /****************************/
                {
                    VO_ZCLinkPoint.mp_Data   = &AR_CArray.mp_TypeArr[AR_CArray.size()-1] ;
                    VO_ZCLinkPoint.ml_ElePos =  AR_CArray.size()  ;
                }
                return VO_ZCLinkPoint; /****************************/
            }/*
            static ZCNodePointN MakeTailPoint(ZtCArray & AR_CArray)*/
            static ZCNodePointN MakeTailPoint(TypeIterC& AR_TypeIter)
            {
                ZCNodePointN VO_ZCLinkPoint(AR_TypeIter);

                const TypeSize VL_ArrSize = AR_TypeIter.mr_CArray.size();

                if(VL_ArrSize>0) /**********************************/
                {
                    VO_ZCLinkPoint.mp_Data   = &AR_TypeIter.mr_CArray[VL_ArrSize-1] ;
                    VO_ZCLinkPoint.ml_ElePos =  VL_ArrSize  ;
                }
                return VO_ZCLinkPoint; /****************************/
            }/*
            static ZCNodePointN MakeTailPoint(TypeIterC& AR_TypeIter)*/
            static ZCNodePointN MakeTailPoint(TypeIterN& AR_TypeIter)
            {
                ZCNodePointN VO_ZCLinkPoint(AR_TypeIter);

                const TypeSize VL_ArrSize = AR_TypeIter.mr_CArray.size();

                if(VL_ArrSize>0) /**********************************/
                {
                    VO_ZCLinkPoint.mp_Data   = &AR_TypeIter.mr_CArray[VL_ArrSize-1] ;
                    VO_ZCLinkPoint.ml_ElePos =  VL_ArrSize  ;
                }
                return VO_ZCLinkPoint; /****************************/
            }/*
            static ZCNodePointN MakeTailPoint(TypeIterN& AR_TypeIter)*/

        public:

            ZCNodePointN(const ZtCArray& AR_CArray, Type& AR_CData, TSize AL_ElePos) :
                mr_CArray(AR_CArray)
            /*****************************************************************/
            {
                mp_Data  =&AR_CData ;
                ml_ElePos=AL_ElePos ;
            }/*
            ZCNodePointN(ZtCArray& AR_CArray, Type& AR_CData, TSize AL_ElePos)*/

            ZCNodePointN(ZtCArray& AR_CArray) : mr_CArray(AR_CArray)
            {
                mp_Data  = AR_CArray.mp_Data            ;
                ml_ElePos=(AR_CArray.size()>0 ? 1 : 0 ) ;
            }/*
            ZCNodePointN(ZtCArray& AR_CArray)*/

            ZCNodePointN(const ZCNodePointN& rhs) : mr_CArray(rhs.mr_CArray)
            {
                mp_Data  = rhs.mp_Data                  ;
                ml_ElePos=(mr_CArray.size()>0 ? 1 : 0 ) ;
            }/*
            ZCNodePointN(const ZCNodePointN& rhs)*/
            ZCNodePointN(const ZCNodePoint & rhs) : mr_CArray(rhs.mr_CArray)
            {
                mp_Data  = rhs.mp_Data                  ;
                ml_ElePos=(mr_CArray.size()>0 ? 1 : 0 ) ;
            }/*
            ZCNodePointN(const ZCNodePoint & rhs)*/


            TypeSize   size  () const{return mr_CArray.size();}
            TypeSize   GetPos() const{return ml_ElePos       ;}

            TypeDataC& operator* () const{return *mp_Data;}
            TypeDataC* operator->() const{return  mp_Data;}


            TypeIterN& operator++(   ) const{++mp_Data; ++ml_ElePos; return *this;}
            TypeIterN  operator++(int) const{++mp_Data; ++ml_ElePos; return *this;}

            TypeIterN  operator+(TSize AL_AddPos) const
            {
                return ZCNodePointN(*this, mp_Data+AL_AddPos, ml_ElePos+AL_AddPos);
            }/*
            TypeIterN  operator+(TSize AL_AddPos) const*/


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

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

        public:
        };/*
        class ZCNodePointN*/


    public   :
        /**************************************************************************/
    protected:
        enum{ZEAddSize=20};
    protected:

        Type*    mp_TypeArr ;
        TypeSize ml_AllSize ;
        TypeSize ml_UseSize ;
        TypeSize ml_AddSize ;

        /*  TSize ml_AddSize 는  추가 메모리를 지정. 한 개의 원소가 삽입되서
            재할당해야 할 경우, ml_AddSize 개 만큼을 미리 할당한다.

    protected:*/
    public   :


        ZtCArray()
        {
            mp_TypeArr  =0;
            ml_AllSize  =0;
            ml_UseSize  =0;
            ml_AddSize  =ZEAddSize;
        }/*
        ZtCArray()*/

        ZtCArray(const ZtCArray& rhs)
        {
            mp_TypeArr  =0;
            ml_AllSize  =0;
            ml_UseSize  =0;
            ml_AddSize  =ZEAddSize;

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

        ~ZtCArray()
        {
            Delete();
        }/*
        ~ZtCArray()*/

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

            ReAlloc(rhs.ml_UseSize, false);

            ml_UseSize = rhs.ml_UseSize;
            ml_AllSize = rhs.ml_AllSize;

            for(TypeSize i=0; i<ml_UseSize; ++i)
            {
                mp_TypeArr[i] = rhs.mp_TypeArr[i];
            }/*
            for(TypeSize i=0; i<ml_UseSize; ++i)*/

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

        ZtCArray& operator()(TypeArg AR_TypeArg)
        {
            AddTail(AR_TypeArg); return *this;
        }/*
        ZtCArray& operator()(TypeArg AR_TypeArg)*/


        void Delete()
        {
            delete [] mp_TypeArr;

            mp_TypeArr  =0;
            ml_AllSize  =0;
            ml_UseSize  =0;
        }/*
        void Delete()*/

        void clear()
        {
            Delete();
        }/*
        void clear()*/


        TypeSize GetAllSize() const{return ml_AllSize;}
        TypeSize GetUseSize() const{return ml_UseSize;}
        TypeSize GetAddSize() const{return ml_AddSize;}

        TypeSize size      () const{return ml_UseSize;}
        TypeSize capacity  () const{return ml_AllSize;}


        void SetAddSize(TypeSize AL_NewAddSize)
        {
            if(AL_NewAddSize>=1) ml_AddSize=AL_NewAddSize;
        }/*
        void SetAddSize(TypeSize AL_NewAddSize)*/

        void SetUseSize(TypeSize AL_NewUseSize)
        {
            if(AL_NewUseSize>=0 && AL_NewUseSize<=ml_AllSize)
            {
                ml_UseSize = AL_NewUseSize;
            }/*
            if(AL_NewUseSize>=0 && AL_NewUseSize<=ml_AllSize)*/
        }/*
        void SetUseSize(TypeSize AL_NewUseSize)*/


        void ReAlloc(TypeSize AL_AllocSize, bool AB_DoKeep=true)
        {
            if(AL_AllocSize<1) return ;

            if(AL_AllocSize<ml_AllSize)
            {
                return ;
            }
            if(AL_AllocSize-ml_AllSize<ml_AddSize)
            {
                AL_AllocSize=ml_AllSize+ml_AddSize ;
            }/*
            if(AL_AllocSize-ml_AllSize<ml_AddSize)*/

            if(mp_TypeArr==0)
            {
                mp_TypeArr =new Type[AL_AllocSize];
                ml_AllSize =AL_AllocSize          ;

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

            if(AB_DoKeep)
            {
                Type* VP_ArrType=new Type[AL_AllocSize] ;

                memcpy(VP_ArrType, mp_TypeArr, ml_AllSize*sizeof(Type));

                delete [] mp_TypeArr;  mp_TypeArr=VP_ArrType;
            }
            else
            {
                delete [] mp_TypeArr;  mp_TypeArr=new Type[AL_AllocSize] ;
            }/*
            else*/

            ml_AllSize=AL_AllocSize;
        }/*
        void ReAlloc(TypeSize AL_AllocSize, bool AB_DoKeep=true)*/


        // cf) std::vecter<type>::assign(size_type _Count, const type&);

        void assign(TypeSize AL_AllocSize, bool AB_DoKeep=true)
        {
            this->ReAlloc(AL_AllocSize, AB_DoKeep);
            this->SetUseSize(AL_AllocSize);
        }/*
        void assign(TypeSize AL_AllocSize, bool AB_DoKeep=true)*/


        Type& operator[](TypeSize AL_Index)
        {
            return mp_TypeArr[AL_Index] ;
        }/*
        Type& operator[](TypeSize AL_Index)*/

        const Type& operator[](TypeSize AL_Index) const
        {
            return mp_TypeArr[AL_Index] ;
        }/*
        const Type& operator[](TypeSize AL_Index) const*/


        Type& GetData(TypeSize AL_Index)
        {
            return mp_TypeArr[AL_Index] ;
        }/*
        Type& GetData(TypeSize AL_Index)*/

        const Type& GetData(TypeSize AL_Index) const
        {
            return mp_TypeArr[AL_Index];
        }/*
        const Type& GetData(TypeSize AL_Index) const*/


        void AddHead(TypeArg AR_TypeArg)
        {
            ReAlloc((ml_UseSize++)+1);

            for(TypeSize i=ml_UseSize-2; i>=0; --i)
            {
                mp_TypeArr[i+1]=mp_TypeArr[i] ;
            }
            /*:::::::::::::::::::::::::::::::::::*/

            mp_TypeArr[0]=AR_TypeArg ;
        }/*
        void AddHead(TypeArg AR_TypeArg)*/

        Type& AddHead()
        {
            // 앞에 빈 원소를 삽입하고 그 원소를 반환한다.

            ReAlloc((ml_UseSize++)+1);

            for(TypeSize i=ml_UseSize-2; i>=0; --i)
            {
                mp_TypeArr[i+1]=mp_TypeArr[i] ;
            }
            /*:::::::::::::::::::::::::::::::::::*/

            return mp_TypeArr[0] ;
        }/*
        Type& AddHead()*/

        void AddTail(TypeArg AR_TypeArg)
        {
            ReAlloc((ml_UseSize++)+1);  mp_TypeArr[ml_UseSize-1]=AR_TypeArg ;
        }/*
        void AddTail(TypeArg AR_TypeArg)*/

        Type& AddTail()
        {
            // 끝에 빈 원소를 삽입하고 그 원소를 반환한다.

            ReAlloc((ml_UseSize++)+1);  return mp_TypeArr[ml_UseSize-1];
        }/*
        Type& AddTail()*/

        operator Type&()
        {
            return AddTail();
        }/*
        operator Type&()*/


        void push_front(TypeArg AR_TypeArg){AddHead(AR_TypeArg);}
        void push_back (TypeArg AR_TypeArg){AddTail(AR_TypeArg);}

        TypeData& push_front(){return AddHead();}
        TypeData& push_back (){return AddTail();}

        TypeIter  begin ()      {return ZCNodePoint (*this);}
        TypeIterN begin () const{return ZCNodePointN(*this);}

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

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


        template<typename TFunctor> void IterElement(TFunctor AO_Functor)
        {
            Type* VP_TypeArr = mp_TypeArr;

            __for0(TypeSize, i, ml_UseSize)
            {
                ZNsMain::ZtCTypeData<TFunctor>::
                    GetObjRef(AO_Functor)( *VP_TypeArr );

                ++VP_TypeArr; //////////////////
            }/*
            __for0(TypeSize, i, ml_UseSize)*/
        }/*
        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;

            Type* VP_TypeArr = mp_TypeArr;

            __for0(TypeSize, i, ml_UseSize)
            {
                ZNsMain::ZtCTypeData<TFunctor>::GetObjRef(AO_Functor)
                    (
                        *VP_TypeArr, ZCCheckRef::PassData(AO_TypeHelp)
                    );
                ++VP_TypeArr; ///////////////////////////////////////
            }/*
            __for0(TypeSize, i, ml_UseSize)*/
        }/*
        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;

            Type* VP_TypeArr = mp_TypeArr;

            __for0(TypeSize, i, ml_UseSize)
            {
                ZNsMain::ZtCTypeData<TFunctor>::GetObjRef(AO_Functor)
                (
                    *VP_TypeArr
                  , ZCCheckRef1::PassData(AO_TypeHelp1)
                  , ZCCheckRef2::PassData(AO_TypeHelp2)
                );
                ++VP_TypeArr; ///////////////////////////////////////
            }/*
            __for0(TypeSize, i, ml_UseSize)*/
        }/*
        template #########################################################
            <
                typename TFunctor   ,
                typename TTypeHelp1 ,
                typename TTypeHelp2
            >
        void IterElement
            (
                TFunctor   AO_Functor   ,
                TTypeHelp1 AO_TypeHelp1 ,
                TTypeHelp2 AO_TypeHelp2
            )
        ################################################################*/


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

        ■  IterElement() 예제.

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


            using namespace std    ;
            using namespace ZNsMain;


            int main()
            {
                typedef ZtCArray<int>    CArray  ;
                typedef CArray::IterEasy IterEasy;


                CArray VO_Array;

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

                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_Array.IterElement(StFunctor ::ShowElement);
                VO_Array.IterElement(StFunctor2::ShowElement, VO_CHelpObj );
                VO_Array.IterElement(StFunctor3::ShowElement, ZftMCR(VO_CHelpObj) );
                VO_Array.IterElement(StFunctor4::ShowElement, ZftMCP(VO_CHelpObj) );
                VO_Array.IterElement(StFunctor5::ShowElement, ZftMCP(VO_CHelpObj), ZftMCP(VO_CHelpObj) );
                VO_Array.IterElement(StFunctor6::ShowElement, ZftMCP(VO_CHelpObj),        VO_CHelpObj  );


                IterEasy VH_Iter = VO_Array.ItHEasy();

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

                return 0;
            }

        ■  -- 2025-08-07 18:03:00

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


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

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

                MoveNextIter(),  MovePrevIter()

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

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

            GetDataInIter() 를 추가했다.

            -- 2011-06-12 20:42:00

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

        TypeData *  GetHeadIterEasy  ()      {return              mp_TypeArr              ;}
        TypeData *  GetTailIterEasy  ()      {return              mp_TypeArr+ml_UseSize-1 ;}
        IterEasyID  GetHeadIterEasyID()      {return (IterEasyID) mp_TypeArr              ;}
        IterEasyID  GetTailIterEasyID()      {return (IterEasyID)(mp_TypeArr+ml_UseSize-1);}

        TypeDataC*  GetHeadIterEasy  () const{return              mp_TypeArr              ;}
        TypeDataC*  GetTailIterEasy  () const{return              mp_TypeArr+ml_UseSize-1 ;}
        IterEasyIDc GetHeadIterEasyID() const{return (IterEasyID) mp_TypeArr              ;}
        IterEasyIDc GetTailIterEasyID() const{return (IterEasyID)(mp_TypeArr+ml_UseSize-1);}

        void MoveNextIter(TypeData*  &  APR_CType    ) const{++APR_CType    ;}
        void MoveNextIter(iterator   &  ARR_CIterator) const{++ARR_CIterator;}
        void MoveNextIter(IterEasyID &  AI_IterEasyID) const
            { MoveNextIter((TypeData*&)AI_IterEasyID); }
        void MoveNextIter(TypeDataC* &  APR_CType    ) const{++APR_CType    ;}
        void MoveNextIter(iteratorC& ARR_CIterator) const{++ARR_CIterator;}
        void MoveNextIter(IterEasyIDc&  AI_IterEasyID)
            const{ MoveNextIter((TypeDataC*&)AI_IterEasyID); }

        void MovePrevIter(TypeData*  &  APR_CType    ) const{--APR_CType    ;}
        void MovePrevIter(iterator   &  ARR_CIterator) const{--ARR_CIterator;}
        void MovePrevIter(IterEasyID &  AI_IterEasyID) const
            { MovePrevIter((TypeData*&)AI_IterEasyID); }
        void MovePrevIter(TypeDataC* &  APR_CType    ) const{--APR_CType    ;}
        void MovePrevIter(iteratorC  &  ARR_CIterator) const{--ARR_CIterator;}
        void MovePrevIter(IterEasyIDc&  AI_IterEasyID)
            const{ MovePrevIter((TypeDataC*&)AI_IterEasyID); }


        TypeData& GetDataInIter(TypeData   * AP_CType     )      {return *AP_CType     ;}
        TypeData& GetDataInIter(iterator   & ARR_CIterator)      {return *ARR_CIterator;}
        TypeData& GetDataInIter(IterEasyID   AI_IterEasyID)
            { return *(TypeData *)AI_IterEasyID; }

        TypeDataC& GetDataInIter(TypeDataC * AP_CType     ) const{return *AP_CType;}
        TypeDataC& GetDataInIter(iteratorC & ARR_CIterator) const{return *ARR_CIterator;}
        TypeDataC& GetDataInIter(IterEasyIDc AI_IterEasyID) const
            { return *(TypeDataC*)AI_IterEasyID; }


        TypeData & GetDataInIter(TypeData  * AP_Type         , TypeSize AI_FarNum)
            { return *(AP_Type + AI_FarNum)     ; }
        TypeData & GetDataInIter(iterator  & ARR_CIterator   , TypeSize AI_FarNum)
            { return *(ARR_CIterator+AI_FarNum) ; }
        TypeData & GetDataInIter(IterEasyID  ARRI_IterEasyID , TypeSize AI_FarNum)
            { return GetDataInIter((TypeData*)ARRI_IterEasyID , AI_FarNum); }

        TypeDataC& GetDataInIter(TypeDataC * AP_Type         , TypeSize AI_FarNum) const
            { return *(AP_Type + AI_FarNum); }
        TypeDataC& GetDataInIter(iterator  & ARR_CIterator   , TypeSize AI_FarNum) const
            { return *(ARR_CIterator+AI_FarNum); }
        TypeDataC& GetDataInIter(IterEasyIDc  ARRI_IterEasyID , TypeSize AI_FarNum) const
            { return GetDataInIter((TypeDataC*)ARRI_IterEasyID, AI_FarNum); }


        TypeData *  ItHEasy()      {return              mp_TypeArr              ;}
        TypeData *  ItTEasy()      {return              mp_TypeArr+ml_UseSize-1 ;}
        IterEasyID  ItHID  ()      {return (IterEasyID) mp_TypeArr              ;}
        IterEasyID  ItTID  ()      {return (IterEasyID)(mp_TypeArr+ml_UseSize-1);}

        TypeDataC*  ItHEasy() const{return              mp_TypeArr              ;}
        TypeDataC*  ItTEasy() const{return              mp_TypeArr+ml_UseSize-1 ;}
        IterEasyIDc ItHID  () const{return (IterEasyID) mp_TypeArr              ;}
        IterEasyIDc ItTID  () const{return (IterEasyID)(mp_TypeArr+ml_UseSize-1);}

        void ItNext(TypeData*  & APR_CType    ) const{++APR_CType    ;}
        void ItNext(iterator   & ARR_CIterator) const{++ARR_CIterator;}
        void ItNext(IterEasyID & AI_IterEasyID) const
            { ItNext((TypeData*&)AI_IterEasyID); }
        void ItNext(TypeDataC* & APR_CType    ) const{++APR_CType    ;}
        void ItNext(iteratorC  & ARR_CIterator) const{++ARR_CIterator;}
        void ItNext(IterEasyIDc& AI_IterEasyID)
            const{ ItNext((TypeDataC*&)AI_IterEasyID); }

        void ItPrev(TypeData*  & APR_CType    ) const{--APR_CType    ;}
        void ItPrev(iterator   & ARR_CIterator) const{--ARR_CIterator;}
        void ItPrev(IterEasyID & AI_IterEasyID) const
            { ItPrev((TypeData*&)AI_IterEasyID); }
        void ItPrev(TypeDataC* & APR_CType    ) const{--APR_CType    ;}
        void ItPrev(iteratorC  & ARR_CIterator) const{--ARR_CIterator;}
        void ItPrev(IterEasyIDc& AI_IterEasyID)
            const{ ItPrev((TypeDataC*&)AI_IterEasyID); }

        TypeData & ItD(TypeData   * AP_Type                            )      {return GetDataInIter(AP_Type                   );}
        TypeData & ItD(iterator   & ARR_CIterator                      )      {return GetDataInIter(ARR_CIterator             );}
        TypeData & ItD(IterEasyID   ARRI_IterEasyID                    )      {return GetDataInIter(ARRI_IterEasyID           );}
        TypeData & ItD(TypeData   * AP_Type        , TypeSize AI_FarNum)      {return GetDataInIter(AP_Type       , AI_FarNum );}
        TypeData & ItD(iterator   & ARR_CIterator  , TypeSize AI_FarNum)      {return GetDataInIter(ARR_CIterator  , AI_FarNum);}
        TypeData & ItD(IterEasyID   ARRI_IterEasyID, TypeSize AI_FarNum)      {return GetDataInIter(ARRI_IterEasyID, AI_FarNum);}

        TypeDataC& ItD(TypeDataC  * AP_Type                            ) const{return GetDataInIter(AP_Type                   );}
        TypeDataC& ItD(iteratorC  & ARR_CIterator                      ) const{return GetDataInIter(ARR_CIterator             );}
        TypeDataC& ItD(IterEasyIDc  ARRI_IterEasyID                    ) const{return GetDataInIter(ARRI_IterEasyID           );}
        TypeDataC& ItD(TypeDataC  * AP_Type        , TypeSize AI_FarNum) const{return GetDataInIter(AP_Type                   );}
        TypeDataC& ItD(iteratorC  & ARR_CIterator  , TypeSize AI_FarNum) const{return GetDataInIter(ARR_CIterator  , AI_FarNum);}
        TypeDataC& ItD(IterEasyIDc  ARRI_IterEasyID, TypeSize AI_FarNum) const{return GetDataInIter(ARRI_IterEasyID, AI_FarNum);}

    public:
    };/*
    template<   typename TType               ,
                typename TTypArg=const TType&,
                typename TSize  =long
            >
    class ZtCArray /////////////////////////*/


    ////////////////////////////////////////////////

    ////////////// end class ZtCArray //////////////

    ////////////////////////////////////////////////



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

    ■  class ZtCArrayOut<> 는 배열 메모리를 자체 할당하지 않고,
        이미 외부에서 new 나 정적으로 선언되어 있는 배열을 사용한다.
        따라서 ZtCArrayOut<> 내부에서 임의로 배열 크기를 조절할 수 없다.

        -- 2011-08-05 20:40:00

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

    template<   typename TType,
                typename TSize=long
            >
    class ZtCArrayOut /////////////
    {
    public:
        typedef TType Type    ;
        typedef Type  TypeData;
    public:
        typedef const Type* const_iterator;
        typedef       Type*       iterator;
    private:
        Type* mp_TypeArr;
        TSize ml_UseSize;
    public:

        ZtCArrayOut()
        {
            Init(0, 0);
        }
        ZtCArrayOut(TypeData* AP_DataArr, TSize AL_ArrSize)
        {
            Init(AP_DataArr, AL_ArrSize);
        }
        void Init(TypeData* AP_DataArr, TSize AL_ArrSize)
        {
            mp_TypeArr=AP_DataArr;
            ml_UseSize=AL_ArrSize;
        }/*
        void Init(TypeData* AP_DataArr,TSize AL_ArrSize)*/

        TSize size() const{return ml_UseSize;}


        Type& operator[](TSize AL_Index)
        {
            return mp_TypeArr[AL_Index] ;
        }/*
        Type& operator[](TSize AL_Index)*/

        const Type& operator[](TSize AL_Index) const
        {
            return mp_TypeArr[AL_Index] ;
        }/*
        const Type& operator[](TSize AL_Index) const*/


        Type& GetData(TSize AL_Index)
        {
            return mp_TypeArr[AL_Index] ;
        }/*
        Type& GetData(TSize AL_Index)*/

        const Type& GetData(TSize AL_Index) const
        {
            return mp_TypeArr[AL_Index];
        }/*
        const Type& GetData(TSize AL_Index) const*/


              Type* begin()       { return mp_TypeArr; }
        const Type* begin() const { return mp_TypeArr; }


        void MoveNextIter(Type*& ARR_CIterator) const
        {
            ++ARR_CIterator;
        }/*
        void MoveNextIter(Type*& ARR_CIterator) const*/

        void MovePrevIter(iterator& ARR_CIterator)
        {
            --ARR_CIterator;
        }/*
        void MovePrevIter(iterator& ARR_CIterator)*/


        void MoveNextIter(const_iterator& ARR_CIterator) const
        {
            ++ARR_CIterator;
        }/*
        void MoveNextIter(const_iterator& ARR_CIterator) const*/

        void MovePrevIter(const_iterator& ARR_CIterator) const
        {
            --ARR_CIterator;
        }/*
        void MovePrevIter(const_iterator& ARR_CIterator) const*/

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

        위 코드를 아래로 하면 안된다.

        void MoveNextIter(const iterator& ARR_CIterator) const
        {
            ++ARR_CIterator;
        }
      //void MoveNextIter(const iterator& ARR_CIterator) const

        void MovePrevIter(const iterator& ARR_CIterator) const
        {
            --ARR_CIterator;
        }
      //void MovePrevIter(const iterator& ARR_CIterator) const

        const iterator 는 Type const * const 이지 Type const * 가 아니다.

        -- 2011-08-05 23:49:00

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


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

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


    public:
    };/*
    template<   typename TType,
                typename TSize=long
            >
    class ZtCArrayOut ///////////*/


    template< typename TTypeOjb, ZTypLong ATI_Length=1
            >
    class ZtCArrayStack //////////////////////////////
    {
    public :
        typedef TTypeOjb    TypeData  ;
        typedef ZTypLong    TypeSize  ;
    public :
        enum{ EAllSize=ATI_Length }   ;
    private:
        TypeData moa_Data[ATI_Length] ;
        TypeSize ml_UseSize           ; // moa_Data 의 실제 사용 길이
    public :

        ZtCArrayStack(TypeSize AL_StackSize)
        {
            ml_UseSize = 0;
        }/*
        ZtCArrayStack(TypeSize AL_StackSize)*/

        ZtCArrayStack& operator=(const ZtCArrayStack& rhs)
        {
            clear(); return (*this)(rhs.data(),rhs.size());
        }/*
        ZtCArrayStack& operator=(const ZtCArrayStack& rhs)*/

        ZtCArrayStack& operator()(const TypeData* AP_Data, TypeSize AL_Length)
        {
            if(AL_Length<1){ return *this; }

            if(AL_Length+ml_UseSize > EAllSize)
            {
                AL_Length = EAllSize - ml_UseSize;

                if(AL_Length<1) return *this;
            }/*
            if(AL_Length+ml_UseSize > EAllSize)*/

            TypeData* VP_Dest= moa_Data+ml_UseSize; const
            TypeData* VP_Src = AP_Data            ;

            ml_UseSize += AL_Length ;

            while(--AL_Length>=0)
                *VP_Dest++ = *VP_Src++ ;

            *VP_Dest=0; return *this;
        }/*
        ZtCArrayStack& operator()(const TypeData* AP_Data, TypeSize AL_Length)*/


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

        TypeSize GetEmptySize() const
        {
            return EAllSize - ml_UseSize ;
        }/*
        TypeSize GetEmptySize() const*/

        TypeData* GetData()
        {
            return moa_Data;
        }/*
        TypeData* GetData()*/

        const TypeData* GetData() const
        {
            return moa_Data;
        }/*
        const TypeData* GetData() const*/


        void MemCopy(TypeData* AP_Data, TypeSize AL_Length)
        {
            if(AL_Length<1 || ml_UseSize<1)
                return;
            if(AL_Length>=ml_UseSize      )
                ::memcpy(AP_Data, moa_Data, sizeof(TypeData)*ml_UseSize);
            else
                ::memcpy(AP_Data, moa_Data, sizeof(TypeData)*AL_Length );
          //else
        }/*
        void MemCopy(TypeData* AP_Data, TypeSize AL_Length)*/


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

        TypeData* data()
        {
            return moa_Data;
        }/*
        TypeData* data()*/

        const TypeData* data() const
        {
            return moa_Data;
        }/*
        const TypeData* data() const*/

        void clear()
        {
            // add codes
        }/*
        void clear()*/

    public:
    };/*
    template< typename TTypeOjb, typename ZTypLong ATI_Length=1
            >
    class ZtCArrayStack /////////////////////////////////////*/


}/*
namespace ZNsMain*/


#endif //__ZCPPMAIIN__ZTCARRAY_H__