#ifndef __ZCPPMAIN_ZMAINAVL_H__
#define __ZCPPMAIN_ZMAINAVL_H__


#include "ZCppMain/ZMainHead.H"


namespace ZNsMain
{

    namespace ZNsEnum
    {

        enum ZEAVL_INSERT
        {
            ZEAVL_INSERT_RIGHT = +1,
            ZEAVL_INSERT_OK    =  0, /* »ðÀÔ ÈÄÀÇ ÆòÇü°è¼ö°¡ 0 ÀÌ´Ù. */
            ZEAVL_INSERT_LEFT  = -1,
            ZEAVL_INSERT_NONE  = -2  /* »ðÀÔ ¾È µÊ */
        };/*
        enum ZEAVL_INSERT*/

    }/*
    namespace ZNsEnum*/


    namespace ZNsInterface
    {

        template<typename TypeArg> class ZtCAVL_BASE
        {
        protected:

            template<typename TNode> void OnEqual(TypeArg AR_Data, TNode* AP_Node)
            {
            }/*
            template<typename TNode> void OnEqual(TypeArg AR_Data, TNode* AP_Node) */

            template<typename TKey, typename TNode> void OnEqualKey(TKey AR_Key, TNode* AP_Node)
            {
            }/*
            template<typename TKey, typename TNode> void OnEqualKey(TKey AR_Key, TNode* AP_Node) */

        protected:
        };/*
        template<typename TypeArg> class ZtCAVL_BASE*/


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

        ¡á  ¾Æ·¡ ZtCAVL_NodeBase<> ÀÇ °¢ ¸â¹ö ÇÔ¼ö´Â ZtCAVL_BASE<> ÀÇ ¸â¹ö ÇÔ¼öº¸´Ù
            Àμö°¡ Çϳª ÁÙ¾îµç °ÍÀ» º¼ ¼ö ÀÖ´Ù. ZtCAVL_BASE<> ¿¡¼­ °°Àº À̸§ÀÇ ÇÔ¼ö¸¦
            ÀÚ¿¬½º·´°Ô È£ÃâÇÒ ¼ö ÀÖ°Ô ÇÑ °ÍÀÌ´Ù. µû¶ó¼­ ZtCAVL_BASE<> ÀÇ ¸â¹ö ÇÔ¼ö¿¡
            ¼­, AP_Node->OnEqual() µîÀ¸·Î ZtCAVL_NodeBase<> ÀÇ ¸â¹ö ÇÔ¼ö¸¦ È£ÃâÇØ ÁÖ
            Áö ¾ÊÀ¸¸é, ZtCAVL_NodeBase<> ÀÇ ¸â¹ö´Â ¾îµð¿¡¼­µµ È£ÃâµÇÁö ¾Ê´Â´Ù. ¿Ö ÃÖÃÊ
            ¿¡ ÀÌ·± ½ÄÀ¸·Î ¼³°èÇßÀ»±î. ÇÑÂü »ý°¢Çߴµ¥, ¾Æ¸¶ ZtCAVL_Multi_BASE<> ¿Í
            ZtCAVL_Multi_NodeBase<> ¸¦ »ç¿ëÇÒ·Á°í ±×·¨À» °ÍÀÌ´Ù.

            -- 2012-09-03 19:20:00

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

        template<typename TNodeArg> class ZtCAVL_NodeBase
        {
        protected:

            void OnEqual(TNodeArg AR_Data)
            {
            }/*
            void OnEqual(TNodeArg AR_Data)*/

            template<typename TKey> void OnEqualKey(TKey AR_Key)
            {
            }/*
            template<typename TKey> void OnEqualKey(TKey AR_Key)*/

        protected:
        };/*
        template<typename TNodeArg> class ZtCAVL_NodeBase*/


        template<typename TypeArg> class ZtCAVL_Multi_BASE
        {
        protected:

            template<typename TNode> void OnEqual(TypeArg AR_Data, TNode* AP_Node)
            {
                AP_Node->OnEqual(AR_Data);
            }/*
            template<typename TNode> void OnEqual(TypeArg AR_Data, TNode* AP_Node) */

            template<typename TKey, typename TNode> void OnEqualKey(TKey AR_Key, TNode* AP_Node)
            {
                AP_Node->OnEqualKey(AR_Key);
            }/*
            template<typename TKey, typename TNode> void OnEqualKey(TKey AR_Key, TNode* AP_Node) */

        protected:
        };/*
        template<typename TypeArg> class ZtCAVL_Multi_BASE*/


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

        ¡á  ZtCAVL_Multi_NodeBase template ·Î multi set/map À» ±¸¼ºÇÏ´Â °æ¿ì,
            ZtCAVL_Multi_NodeBase::TypeEqual ÀÚ·áÇü¿¡ Á¢±ÙÇÏ´Â ¿¹.

            class CTypeMy
            {
            public:
                typedef CLargeAVL<some param>                CLargeMap;
                typedef typename CLargeMap::ZCNode::TypeEqual TypeEqual;
            }

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

        template< typename TNodeArg, typename TEqualList
                >
        class ZtCAVL_Multi_NodeBase ////////////////////
        {
        public   :
            typedef TEqualList TypeEqual;
        protected:
            TEqualList mo_EqualList;
        public   :

            void OnEqual(TNodeArg AR_Data)
            {
                mo_EqualList.push_back(AR_Data);
            }/*
            void OnEqual(TNodeArg AR_Data)*/

            template<typename TKey> void OnEqualKey(TKey AR_Key)
            {
                mo_EqualList.push_back(AR_Key);
            }/*
            template<typename TKey> void OnEqualKey(TKey AR_Key) */

            const TEqualList& GetCEqualList() const
            {
                return mo_EqualList;
            }/*
            const TEqualList& GetCEqualList() const*/

        public:
        };/*
        template< typename TNodeArg, typename TEqualList
                >
        class ZtCAVL_Multi_NodeBase //////////////////*/



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

        ¡á  AVL Æ®¸®ÀÇ µ¥ÀÌŸ ŸÀÔÀÌ Æ÷ÀÎÅÍÀÎ °æ¿ì, Æ÷ÀÎÅ͸¦ Á¤¼öó·³ ´Ù·ç¾î¼­
            ºñ±³ ¿¬»êÀÚ¸¦ Á¤ÀÇÇϴ Ŭ·¡½º ÅÛÇø´ÀÌ´Ù.

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

        template<typename TData> class ZtCAVL_PtrLongData
        {
        public   :
            typedef TData* TypeData;
        protected:
            TData* mp_CData;
        public   :

            ZtCAVL_PtrLongData()
            {
                mp_CData=0;
            }/*
            ZtCAVL_PtrLongData()*/

            TData* GetDataPtr() const
            {
                return mp_CData;
            }/*
            TData* GetDataPtr() const*/

            void SetDataPtr(TData* AP_CData)
            {
                mp_CData=AP_CData;
            }/*
            void SetDataPtr(TData* AP_CData)*/

            operator ZNsMain::ZTypIntPtr() const
            {
                return mp_CData;
            }/*
            operator ZNsMain::ZTypIntPtr() const*/


            ZtCAVL_PtrLongData& operator=(const ZtCAVL_PtrLongData& rhs)
            {
                mp_CData=rhs.mp_CData; return *this;
            }/*
            ZtCAVL_PtrLongData& operator=(const ZtCAVL_PtrLongData& rhs)*/

            ZtCAVL_PtrLongData& operator=(const TData* AP_CData)
            {
                mp_CData=const_cast<TData*>(AP_CData); return *this;
            }/*
            ZtCAVL_PtrLongData& operator=(const TData* AP_CData)*/

            bool operator==(const ZtCAVL_PtrLongData& rhs) const{return mp_CData==rhs.mp_CData;}
            bool operator> (const ZtCAVL_PtrLongData& rhs) const{return (ZNsMain::ZTypIntPtr)mp_CData > (ZNsMain::ZTypIntPtr)rhs.mp_CData;}
            bool operator< (const ZtCAVL_PtrLongData& rhs) const{return (ZNsMain::ZTypIntPtr)mp_CData < (ZNsMain::ZTypIntPtr)rhs.mp_CData;}

            bool operator==(const TData* AP_CData) const{return mp_CData==AP_CData;}
            bool operator> (const TData* AP_CData) const{return (ZNsMain::ZTypIntPtr)mp_CData > (ZNsMain::ZTypIntPtr)AP_CData;}
            bool operator< (const TData* AP_CData) const{return (ZNsMain::ZTypIntPtr)mp_CData < (ZNsMain::ZTypIntPtr)AP_CData;}

        protected:
        };/*
        template<typename TData> class ZtCAVL_PtrLongData*/


        /*  int, long °°ÀÌ ºñ±³¿¬»êÀÌ °¡´ÉÇÑ primitive ŸÀÔÀ̳ª object ¸¦
            key ·Î °¡Áö°í ÀÖ´Â °æ¿ì¿¡, ÇØ´ç AVL Æ®¸®ÀÇ ³ëµå µ¥ÀÌŸ·Î ¹Ù·Î
            ¾µ ¼ö ÀÖµµ·Ï wrap ÇÑ Å¬·¡½º ÅÛÇø´                         */

        template<   typename TKeyData ,
                    typename TMainData,
                    typename TKeyArg =const TKeyData &,
                    typename TMainArg=const TMainData&
                >
        class ZtCAVL_KeyData //////////////////////////
        {
        public   :
            typedef TKeyData  TypeKey ;
            typedef TMainData TypeData;
        protected:
            TKeyData  mo_CKeyData ; mutable
            TMainData mo_CMainData;
        public   :

            ZtCAVL_KeyData(){}

            ZtCAVL_KeyData(TKeyArg AO_TKeyArg)
            {
                mo_CKeyData=AO_TKeyArg;
            }/*
            ZtCAVL_KeyData(TKeyArg AO_TKeyArg)*/

            ZtCAVL_KeyData(TKeyArg AO_TKeyArg, TMainArg AO_TMainArg)
            {
                mo_CKeyData =AO_TKeyArg ;
                mo_CMainData=AO_TMainArg;
            }/*
            ZtCAVL_KeyData(TKeyArg AO_TKeyArg, TMainArg AO_TMainArg)*/

            TKeyArg    GetCKeyData    () const{return mo_CKeyData ;}
            TMainArg   GetCMainData   () const{return mo_CMainData;}
            TMainData& GetCMainDataRef() const{return mo_CMainData;}

            void SetCMainData(TMainArg AO_TRealArg) const
            {
                mo_CMainData=AO_TRealArg;
            }/*
            void SetCMainData(TMainArg AO_TRealArg) const*/

            void SetKeyData(TKeyArg AO_TKeylArg)
            {
                mo_CKeyData=AO_TKeylArg;
            }/*
            void SetKeyData(TKeyArg AO_TKeylArg)*/

            bool operator==(const ZtCAVL_KeyData& rhs) const{return mo_CKeyData==rhs.mo_CKeyData;}
            bool operator> (const ZtCAVL_KeyData& rhs) const{return mo_CKeyData> rhs.mo_CKeyData;}
            bool operator< (const ZtCAVL_KeyData& rhs) const{return mo_CKeyData< rhs.mo_CKeyData;}

            bool operator==(TKeyArg AO_TPrimitive) const{return mo_CKeyData==AO_TPrimitive;}
            bool operator> (TKeyArg AO_TPrimitive) const{return mo_CKeyData> AO_TPrimitive;}
            bool operator< (TKeyArg AO_TPrimitive) const{return mo_CKeyData< AO_TPrimitive;}

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

                mo_CKeyData =rhs.mo_CKeyData ;
                mo_CMainData=rhs.mo_CMainData; return *this;
            }/*
            ZtCAVL_KeyData& operator=(const ZtCAVL_KeyData& rhs)*/

            ZtCAVL_KeyData& operator=(TKeyArg AO_TPrimitive)
            {
                mo_CKeyData=AO_TPrimitive; return *this;
            }/*
            ZtCAVL_KeyData& operator=(TKeyArg AO_TPrimitive)*/

        public:
        };/*
        template<   typename TKeyData ,
                    typename TMainData,
                    typename TKeyArg =const TKeyData &,
                    typename TMainArg=const TMainData&
                >
        class ZtCAVL_KeyData ////////////////////////*/

    }/*
    namespace ZNsInterface*/


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

    ¡á  mulit set À¸·Î È°¿ëÇÏ´Â ¿¹Á¦ÄÚµå

        ZNsMain::CLargeAVL ///////////////////////////////////
            <
                int,
                int,
                ZNsMain::ZNsInterface::ZtCAVL_Multi_BASE<int>,
                ZNsMain::ZNsInterface::ZtCAVL_Multi_NodeBase<int, ZNsMain::ZtCDoubleList<int> >
            >
        VO_CLargeAvl_Multi; //////////////////////////////////

        VO_CLargeAvl_Multi.AddData(1);
        VO_CLargeAvl_Multi.AddData(2);
        VO_CLargeAvl_Multi.AddData(2);
        VO_CLargeAvl_Multi.AddData(2);
        VO_CLargeAvl_Multi.AddData(2);

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


    namespace NsType
    {

        template<   typename TStringData, //= ZNsMain::ZtCStringBase<char>                    ,
                    typename TEnvVar    , //= ZNsMain::ZNsCGI::ZNsBase::ZtCEnvVar<TStringData>,
                    typename TEnvVarSet   //= ZNsMain::ZtCObjAVL<TEnvVar>
                >
        class ZtCTypeEnvVarSet /*############################################################*/
        {
        public:
            typedef TStringData                        ZCStringData;
            typedef TEnvVar                            ZCEnvVar    ;
            typedef TEnvVarSet                         ZCEnvVarSet ;
            typedef typename ZCEnvVarSet ::ZCNode      ZCEnvVarNode;
            typedef typename ZCStringData::ZCMainChars ZCMainChars ;
            typedef typename ZCStringData::TypeChar    TypeChar    ;
            typedef typename ZCStringData::TypeLength  TypeLength  ;
        public:
        };/*
        template<   typename TStringData, //= ZNsMain::ZtCStringBase<char>                    ,
                    typename TEnvVar    , //= ZNsMain::ZNsCGI::ZNsBase::ZtCEnvVar<TStringData>,
                    typename TEnvVarSet   //= NsCPP::ZtCObjAVL<TEnvVar>
                >
        class ZtCTypeEnvVarSet /*############################################################*/

    }/*
    namespace NsType*/

}/*
namespace ZNsMain */


#endif // __ZCPPMAIN_ZMAINAVL_H__