#ifndef __ZCPPMAIIN__ZTCMAINCHARS_H__ #define __ZCPPMAIIN__ZTCMAINCHARS_H__ #include "ZCppMain/ZMainHead.H" namespace ZNsMain { namespace ZNsChars { typedef ZNsMain::IterEasyID IterEasyID ; typedef ZNsMain::IterEasyIDc IterEasyIDc; namespace ZNsEnum { typedef ZNsMain::ZNsEnum::ZERun ZERun ; typedef ZNsMain::ZNsEnum::ZERunEx ZERunEx; enum ZESearchMax { ZESearchMax_Over, ZESearchMax_Stop };/* enum ZESearchMax*/ /*//////////////////////////////////////////////////////////////////////////// ■ ESearchMaxFind 은 ZtCMainChars<>::GetLength_Repeat_Find() 등의 함수에서, 최대 발견 횟수(AI_RepeatMax)가 유효한 값인 경우, AI_RepeatMax 만큼 발견한 시점에서 문자열 조회를 멈출 것인지, 한 번 더 조회할 것인지(그래서 해당 문 자열을 또 다시 발견하면, AI_RepeatMax+1 번 발견한 것이 되고, 이것은 조건에 맞지 않는 것으로 판단해야 한다)를 결정한다. -- 2011-07-16 03:49:00 ////////////////////////////////////////////////////////////////////////////*/ /*////////////////////////////////////////////////////// ■ 해당 표현식과 일치하는 문자열이 있으면 시작 위치값을 ZERegMatch_MoveNot 이면 이동하지 않는다. ZERegMatch_MovePos 이면 이동시킨다. //////////////////////////////////////////////////////*/ enum ZERegMatch { ZERegMatch_MoveNot, ZERegMatch_MovePos };/* enum ZERegMatch*/ /*////////////////////////////////////////////////////// ■ 해당 표현식과 일치하는 문자열이 있으면, 위치 정보를 ZERegMatchSavePos_Not 이면 저장하지 않는다. ZERegMatchSavePos_Yes 이면 저장한다. //////////////////////////////////////////////////////*/ enum ZERegMatchSavePos { ZERegMatchSavePos_Not, ZERegMatchSavePos_Yes };/* enum ZERegMatchSavePos*/ enum ZERegFlag { ZERegFlag_Nothing , ZERegFlag_Permit , // 찾는 문자열의 목록 중에 하나라도 일치해야 ... ZERegFlag_PermitRange , // 찾는 문자열의 목록 범위에 속해 있으면 ... ZERegFlag_PermitChar , // 찾는 문자열의 각 문자 중에 하나라도 일치해야 ... ZERegFlag_PermitCharRange , // 찾는 문자열의 2 개 문자단위로 허용 범위를 나타내는데, 이 범위에 문자가 있어야... ZERegFlag_NoPermit , // 찾는 문자열의 목록과 모두가 일치하지 않아야 ... ZERegFlag_NoPermitRange , // 찾는 문자열의 목록 범위에 속해 있지 않으면 ... ZERegFlag_NoPermitChar , // 찾는 문자열의 모든 문자에 일치하지 않아야 ... ZERegFlag_NoPermitCharRange, // 찾는 문자열의 2 개 문자단위로 허용하지 않는 범위를 나타내는데, 이 범위 밖에 문자가 있어야... ZERegFlag_Find , // 찾는 문자열의 목록 중에 하나라도 일치하면 그 길이까지 구해온다. ZERegFlag_FindChar , // 찾는 문자여의 각 문자 중에 하나라도 일치하면 그 길이까지 구해온다. ZERegFlag_FindSerial , // 찾는 문자열의 목록을 순서대로 찾아야 한다. ZERegFlag_FindSerialChar , // 찾는 문자열의 각 문자를 순서대로 찾아야 한다. ZERegFlag_FindEscape , // 찾는 문자열의 목록 중에 하나라도 일치하고 escape 문자열로 시작하지 않으면 그 길이까지 구한다. ZERegFlag_StartFind , // 찾는 문자열의 목록 중, 1 번 원소부터 시작하고, 2 번 원소부터 찾기 시작한다. ZERegFlag_StartFindChar , // ZERegFlag_FindSerialChar 와 비슷하나, 1 번 문자로 시작해야 하는 점이 다르다. ZERegFlag_BlockStart , // '조회 Block'의 시작 부분 ZERegFlag_BlockClose // '조회 Block'의 종료 부분 };/* enum ZERegFlag*/ /*//////////////////////////////////////////////////////////////////////////// ■ enum ZERegErr 은 class ZtCSearchCChars 에서 사용하는 에러 코드다. □ ZERegErr_CharCount : 찾은 문자 갯수가 ZtCSearchCChars::mi_SearchCharMin 와 ZtCSearchCChars::mi_SearchCharMax 사이에 있지 않다. □ ZERegErr_CharSum : ZtCSearchCChars 의 컨테이너(주로 배열)을 인수로 받아서, 연속해서 ZtCSearchCChars 와 일치하는 문자를 찾는 경우, 일치하는 문자를 특정 변수(주로 지역 변수)에 계속 더하게 되는데, 찾은 총 문자 문자 갯수가, 즉 이 변수의 값이 ZtCSearchCChars::mi_SearchSumMin 와 ZtCSearchCChars::mi_SearchSumMax 사이에 있지 않은 경우이다. □ -- ■ 조회 Block 지정된 문자열에서 특정 패턴을 찾는 조건이 복잡할 경우는, 찾는 조건 object 를 배열이나 tree 형태로 설계하게 되는데, 이때의 찾는 조건의 처음 원소와 끝 원소 의 단위를 '조회 Block'이라고 한다. 특히 tree 형태일 때 하위 노드로 내려가면 새로운 노드 리스트가 있고, 따라서 새로운 '조회 Block' 이 발생하는 것을 설명 하기 위해 필요한 용어이다. -- 2013-06-25 23:37:00 ////////////////////////////////////////////////////////////////////////////*/ enum ZERegErr // 정규 표현식 관련 에러 코드. { ZERegErr_None , // 에러 없음. ZERegErr_CharCount, // 찾은 문자 갯수 에러. ZERegErr_CharSum // 찾은 문자 누적 갯수 에러. };/* enum ZERegErr*/ enum ZETypeCharTmplChain { ZETypeCharTmplChain_No , ZETypeCharTmplChain_Char , ZETypeCharTmplChain_Char2 };/* enum ZETypeCharTmplChain*/ }/* namespace ZNsEnum*/ namespace ZNsInterface { template class ZtCStackOfTmplChain { private: TTypeLength ml_SearchSum; public : ZtCStackOfTmplChain() { ml_SearchSum=0; }/* ZtCStackOfTmplChain()*/ TTypeLength GetSearchSum() const{return ml_SearchSum;} void SetSearchSum(TTypeLength AI_Length){ml_SearchSum =AI_Length;} void AddSearchSum(TTypeLength AL_Length){ml_SearchSum+=AL_Length;} public : };/* template class ZtCStackOfTmplChain */ }/* namespace ZNsInterface*/ namespace ZNsIFace { // 이름공간 ZNsInterface 을 짧게 ZNsIFace 으로도 표기 가능하게 한다. using namespace ZNsInterface; }/* namespace ZNsIFace*/ namespace ZNsType { // 경우에 따라 TTypeChar 는 short int 나 int 가 될 수 있다. template< typename TTypeChar =char, typename TTypeLength=ZTypLength // signed 형이어야 한다. > class ZtCTypeChars /*////////////////////*/ { public: typedef TTypeChar TypeChar ; typedef TTypeLength TypeLength; // signed 형이어야 한다. public: typedef const TypeChar TypeCharC ; typedef const TypeChar* TypeCharCP; public: static TypeChar GetCharOfAnsi(char AC_AnsiChar) { return AC_AnsiChar; }/* static TypeChar GetCharOfAnsi(char AC_AnsiChar)*/ static bool IsAnsiChars(TypeCharC* APC_Char,TypeLength AI_Length) { // Ansi 7bit 문자이면 true 를 리턴. // AI_Length<1 인 경우에도 true 를 리턴 while(--AI_Length>=0) { if((*APC_Char++)<0) return false; }/* while(--AI_Length>=0)*/ return true; }/* static bool IsAnsiChars(TypeCharC* APC_Char,TypeLength AI_Length)*/ static TypeLength GetLength(TypeCharC* APC_TypeChar) { if(APC_TypeChar==0) return 0; TypeLength VL_Length=0; while(*(APC_TypeChar+VL_Length)!=ZtCTypeChars::GetCharOfAnsi('\0')) { ++VL_Length; }/* while(*(APC_TypeChar+VL_Length)!=ZtCTypeChars::GetCharOfAnsi('\0'))*/ return VL_Length; }/* static TypeLength GetLength(TypeCharC* APC_TypeChar) public:*/ public: class ZCChars { public : template friend class ZtCMainChars; public : typedef ZtCTypeChars ZCTypeChars; typedef TTypeChar TypeChar ; typedef TTypeLength TypeLength ; public: typedef const TTypeChar TypeCharC ; typedef const TTypeChar* TypeCharCP ; private: TypeChar* mp_TypeChar ; TypeLength ml_TypeLength; public : ZCChars() { mp_TypeChar =0; ml_TypeLength=0; }/* ZCChars()*/ ZCChars(TypeCharC* APC_TypeChar) { mp_TypeChar =const_cast (APC_TypeChar); ml_TypeLength=ZtCTypeChars::GetLength(mp_TypeChar ); }/* ZCChars(TypeCharC* APC_TypeChar)*/ ZCChars(TypeCharC* APC_TypeChar, TypeLength AL_Length) { mp_TypeChar = const_cast (APC_TypeChar) ; ml_TypeLength=AL_Length ; }/* ZCChars(TypeCharC* APC_TypeChar, TypeLength AL_Length)*/ void Init(TypeCharC* APC_TypeChar=0, TypeLength AL_Length=0) { mp_TypeChar =const_cast (APC_TypeChar) ; ml_TypeLength=AL_Length ; }/* void Init(TypeCharC* APC_TypeChar=0, TypeLength AL_Length=0)*/ void InitData(TypeCharC* APC_TypeChar) { mp_TypeChar=const_cast(APC_TypeChar); }/* void InitData(TypeCharC* APC_TypeChar)*/ void InitLength(TypeLength AL_Length) { ml_TypeLength=AL_Length; }/* void InitLength(TypeLength AL_Length)*/ TypeChar* data() { return mp_TypeChar; }/* TypeChar* data()*/ TypeCharC* data() const { return mp_TypeChar; }/* TypeCharC* data() const*/ TypeLength size() const { return ml_TypeLength; }/* TypeLength size() const*/ ZCChars& operator+=(TypeLength AI_MovePos) { return MoveChar(AI_MovePos); }/* ZCChars& operator+=(TypeLength AI_MovePos)*/ int operator-(const ZCChars& rhs) const { // 두 문자열이 같으면 0 // 왼쪽 문자열이 크면 0 보다 큰 어떤 수 // 오른쪽 문자열이 크면 0 보다 작은 어떤 수를 반환 TypeCharC* VP_Left = mp_TypeChar; TypeCharC* VP_Right=rhs.mp_TypeChar; #if(_CODE_OLD_) TypeChar VC_Minus=0; #else int VI_Minus=0; // 페이지 하단의 'char 의 int 확장에 따른 문제의 코드' 참고. #endif TypeLength VL_Index=0; TypeLength VL_Loop =(ml_TypeLength<=rhs.ml_TypeLength ? ml_TypeLength : rhs.ml_TypeLength) ; while(VL_Index (const ZCChars& rhs) const{return (*this)-rhs > 0 ;} bool operator< (const ZCChars& rhs) const{return (*this)-rhs < 0 ;} bool operator>=(const ZCChars& rhs) const{return (*this)-rhs >= 0 ;} bool operator<=(const ZCChars& rhs) const{return (*this)-rhs <= 0 ;} ZCChars& MoveChar(TypeLength AI_MovePos) { mp_TypeChar +=AI_MovePos; ml_TypeLength-=AI_MovePos; return *this; }/* ZCChars& MoveChar(TypeLength AI_MovePos)*/ ZTypIntI GetInt(bool AB_IsBigEndian=true) const { const ZTypIntI CI_IntByte = sizeof(ZTypIntI); const ZTypIntI CI_SearchSize = (ml_TypeLength=0; --i) { VI_Result += (ZTypIntI)(ZTypUChar)(mp_TypeChar[i]) * VI_TempInt ; VI_TempInt*= 256 ; }/* for(ZTypIntI i=CI_SearchSize-1; i>=0; --i)*/ return VI_Result; }/* if(AB_IsBigEndian)*/ for(ZTypIntI i=0; i=0; --i) { VI_Result += (ZTypIntI)(ZTypUChar)(mp_TypeChar[i]) * VI_TempInt ; VI_TempInt*= 256 ; }/* for(ZTypIntI i=CI_SearchSize-1; i>=0; --i)*/ return VI_Result; }/* if(AB_IsBigEndian)*/ for(ZTypIntI i=0; i=0; --i) { VI_Result += (ZTypIntI)(ZTypUChar)(mp_TypeChar[i]) * VI_TempInt ; VI_TempInt*= 256 ; }/* for(ZTypIntI i=CI_SearchSize-1; i>=0; --i)*/ return VI_Result; }/* if(AB_IsBigEndian)*/ for(ZTypIntI i=0; i TypeInt GetIntType(bool AB_IsBigEndian=true) const { const ZTypIntI CI_IntByte = sizeof(TypeInt); const ZTypIntI CI_SearchSize = (ml_TypeLength=0; --i) { VI_Result += (ZTypIntI)(ZTypUChar)(mp_TypeChar[i]) * VI_TempInt ; VI_TempInt*= 256 ; }/* for(ZTypIntI i=CI_SearchSize-1; i>=0; --i)*/ return VI_Result; }/* if(AB_IsBigEndian)*/ for(ZTypIntI i=0; i TypeInt GetIntType(bool AB_IsBigEndian=true) const*/ public: };/* class ZCChars*/ static TypeChar GetUpperChar(TypeChar AC_TypeChar) { const int CI_Distance='a'-'A'; return (AC_TypeChar>='a' && AC_TypeChar<='z') ? AC_TypeChar-CI_Distance : AC_TypeChar ; }/* static TypeChar GetUpperChar(TypeChar AC_TypeChar)*/ static TypeChar GetLowerChar(TypeChar AC_TypeChar) { const int CI_Distance='a'-'A'; return (AC_TypeChar>='A' && AC_TypeChar<='Z') ? AC_TypeChar-CI_Distance : AC_TypeChar ; }/* static TypeChar GetLowerChar(TypeChar AC_TypeChar)*/ public: };/* template< typename TTypeChar =char, typename TTypeLength=ZTypLength > class ZtCTypeChars //////////////////////*/ }/* namespace ZNsType*/ template< typename TTypeChars=ZNsType::ZtCTypeChars > class ZtCMainChars //////////////////////////////////////// { public: typedef TTypeChars ZCTypeChars; typedef ZtCMainChars ZCMainChars; typedef typename ZCTypeChars::ZCChars ZCChars ; typedef typename ZCTypeChars::TypeChar TypeChar ; typedef typename ZCTypeChars::TypeLength TypeLength ; public: typedef const TypeChar TypeCharC ; typedef const TypeChar* TypeCharCP; public: static int Minus(const ZCChars& AR_CChars1, const ZCChars& AR_CChars2) { return ZtCMainChars::Minus( AR_CChars1.data, AR_CChars2.data(), AR_CChars1.size(), AR_CChars2.size()); }/* static int Minus(const ZCChars& AR_CChars1, const ZCChars& AR_CChars2)*/ static int Minus( const TypeChar* APC_Left , const TypeChar* APC_Right, TypeLength AL_LeftLength, TypeLength AL_RightLength ) { // 두 문자열이 같으면 0 // 왼쪽 문자열이 크면 0 보다 큰 어떤 수 // 오른쪽 문자열이 크면 0 보다 작은 어떤 수를 반환 if(AL_LeftLength<1 || AL_RightLength<1) { return AL_LeftLength - AL_RightLength; }/* if(AL_LeftLength<1 || AL_RightLength<1)*/ const TypeChar* VP_Left =APC_Left ; const TypeChar* VP_Right=APC_Right; TypeLength VL_Index=0; TypeLength VL_Loop = (AL_LeftLength<=AL_RightLength ? AL_LeftLength : AL_RightLength) ; #if(_CODE_OLD_) TypeChar VC_Minus=0; while(VL_Index0) { // 문자를 i 개 앞으로 당긴다. for(TypeLength t=i; t0)*/ VPC_Char = APC_Char+(ARRL_Length-1); // 맨 끝을 가리킨다. for(i=ARRL_Length-1; i>=0; --i) { const bool CB_IsTrue = ( ////////////////////////////////////////// (VC_Char=*VPC_Char--)!=' ' && VC_Char!=ZCTypeChars::GetCharOfAnsi('\t') && VC_Char!=ZCTypeChars::GetCharOfAnsi('\r') && VC_Char!=ZCTypeChars::GetCharOfAnsi('\n') && VC_Char!=ZCTypeChars::GetCharOfAnsi('\0') /*/////////*/ ); ////////////////////////////////////////////////// if(CB_IsTrue) break; APC_Char[--ARRL_Length] = ZCTypeChars::GetCharOfAnsi('\0'); }/* for(i=ARRL_Length-1; i>=0; --i)*/ return APC_Char; }/* static TypeChar* Trim(TypeChar* APC_Char,TypeLength& ARRL_Length)*/ static ZCChars& Trim(ZCChars& ARR_CChars) { ZtCMainChars::Trim(ARR_CChars.mp_TypeChar, RR(ARR_CChars.ml_TypeLength)); return ARR_CChars; }/* static ZCChars& Trim(ZCChars& ARR_CChars)*/ template static int GetStartCStrObjNum( TypeCharC* APC_Origin, TypeLength AL_OriginLength, TStringArray& ARA_SearchArray) { long VL_ArrSize=ARA_SearchArray.size(); if(AL_OriginLength<1) return 0; IterEasyIDc CI_IterEasyID(ARA_SearchArray.GetHeadIterEasyID()); __for1(TypeLength, i, VL_ArrSize) { const bool CB_IsOK= ZtCMainChars::DoStart( APC_Origin , ARA_SearchArray.ItD(CI_IterEasyID).data(), AL_OriginLength, ARA_SearchArray.ItD(CI_IterEasyID).size() /*//////////*/ ); if(CB_IsOK) return i; ARA_SearchArray.MoveNextIter(RR(CI_IterEasyID)); }/* __for1(TypeLength, i, VL_ArrSize)*/ return 0; }/* template static int GetStartCStrObjNum( TypeCharC* APC_Origin, TypeLength AL_OriginLength, TStringArray& ARA_SearchArray) */ template static TypeLength GetStartCStrObjNum(const TTyChars& AR_CCharsOrigin, TStringArray& ARA_SearchArray) { return ZtCMainChars::GetStartCStrObjNum(AR_CCharsOrigin.data(), AR_CCharsOrigin.size(), ARA_SearchArray); }/* template static TypeLength GetStartCStrObjNum(const TTyChars& AR_CCharsOrigin, TStringArray& ARA_SearchArray) */ template static TypeLength GetStartCStrObjNum2( /*###############*/ TypeCharC* APC_Origin , TypeLength AL_OriginLength, TStringArray& ARA_SearchArray, TString*& APR_CStringStart /*#####*/ ) /*##########################################*/ { APR_CStringStart=0; long VL_ArrSize=ARA_SearchArray.size(); if(AL_OriginLength<1) return 0; //////////////////////////// IterEasyIDc CI_IterEasyID(ARA_SearchArray.GetHeadIterEasyID()); /* 상수 반복자 const_iterator 으로 코딩하면 APR_CStringStart 는 함수 외부에서 const TString* VP_CStringData 형태로 선언되어야 한다. */ for(TypeLength i=1; i<=VL_ArrSize; ++i) { const bool CB_IsOK=ZtCMainChars::DoStart( APC_Origin , ARA_SearchArray.ItD(CI_IterEasyID).data(), AL_OriginLength, ARA_SearchArray.ItD(CI_IterEasyID).size() /*//////////*/ ); if(CB_IsOK) { APR_CStringStart=&(ARA_SearchArray.ItD(CI_IterEasyID)); return i; }/* if(CB_IsOK)*/ ARA_SearchArray.MoveNextIter(RR(CI_IterEasyID)); }/* for(TypeLength i=1; i<=VL_ArrSize; ++i)*/ return 0; }/* template static TypeLength GetStartCStrObjNum2( TypeCharC* APC_Origin , TypeLength AL_OriginLength, TStringArray& ARA_SearchArray, TString*& APR_CStringStart ) */ template static TypeLength GetStartCStrObjNum2(const TTyChars& AR_CCharsOrigin, TStringArray& ARA_SearchArray, TString*& APR_CStringStart) { return ZtCMainChars::GetStartCStrObjNum2( AR_CCharsOrigin.data(), AR_CCharsOrigin.size(), ARA_SearchArray, RR(APR_CStringStart)); }/* template static TypeLength GetStartCStrObjNum2(const TTyChars& AR_CCharsOrigin, TStringArray& ARA_SearchArray, TString*& APR_CStringStart)*/ /*////////////////////////////////////////////////////////////////// ■ 아래 typename TTyChars 인자를 가진 템플릿 함수는 TTyChars 의 자리 에, ZCChars 클래스같이 data(), size() 멤버를 갖는 클래스가 올 수 있다. -- 2011-07-13 05:39:00 //////////////////////////////////////////////////////////////////*/ template static bool DoStart(const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch) { return ZtCMainChars::DoStart(AR_CCharsOrigin.data(), AR_CCharsSearch.data(), AR_CCharsOrigin.size(), AR_CCharsSearch.size()); }/* template static bool DoStart(const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch) */ static bool DoStart( TypeCharC* APC_Origin, TypeCharC* APC_Search, TypeLength AL_OriginLength, TypeLength AL_SearchLength) { if(AL_OriginLength<1 || AL_SearchLength<1 || AL_OriginLength static bool DoClose(const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch) { return ZtCMainChars::DoClose(AR_CCharsOrigin.data(), AR_CCharsSearch.data(), AR_CCharsOrigin.size(), AR_CCharsSearch.size()); }/* template static bool DoClose(const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch) */ static bool DoClose( TypeCharC* APC_Origin, TypeCharC* APC_Search, TypeLength AL_OriginLength, TypeLength AL_SearchLength) { const bool CB_IsBad = ( AL_OriginLength<1 || AL_SearchLength<1 || AL_OriginLength static bool DoEndLinear( const TTyChars& AR_CCharsOrigin1, const TTyChars& AR_CCharsOrigin2, const TTyChars& AR_CCharsSearch) { return ZtCMainChars::DoEndLinear( AR_CCharsOrigin1.data(), AR_CCharsOrigin2.data(), AR_CCharsSearch.data(), AR_CCharsOrigin1.size(), AR_CCharsOrigin2.size(), AR_CCharsSearch.size() ); }/* template static bool DoEndLinear( const TTyChars& AR_CCharsOrigin1, const TTyChars& AR_CCharsOrigin2, const TTyChars& AR_CCharsSearch) */ static bool DoEndLinear( TypeCharC* APC_Origin1 , TypeCharC* APC_Origin2 , TypeCharC* APC_Search, TypeLength AL_OriginLength1, TypeLength AL_OriginLength2, TypeLength AL_SearchLength ) { /* APC_Origin1 와 APC_Origin2 을 연속된 문자열로 보았을때, 전체 문자열이 APC_Search 로 끝나면 true 를 반환한다. */ const bool CB_IsBad = ( AL_SearchLength<1 || AL_OriginLength1+AL_OriginLength2AL_SearchLength APC_Origin1, APC_Origin2 ☞ ABCDEFGH IJKLMNOPQRSTU APC_Search ☞ LMNOPQRSTU ■ 경우2 : AL_OriginLength2<=AL_SearchLength APC_Origin1, APC_Origin2 ☞ ABCDEFGH IJKLMNOPQRSTU APC_Search ☞ GHIJKLMNOPQRSTU ■ -- 2011-03-09 09:49:00 /////////////////////////////////////////////////////*/ TypeCharC* VPC_OrginStart =APC_Origin2+AL_OriginLength2; TypeCharC* VPC_SearchStart=APC_Search +AL_SearchLength ; TypeLength VI_CompareCnt =( AL_OriginLength2>AL_SearchLength ? AL_SearchLength : AL_OriginLength2); for(TypeLength i=0; i=AL_SearchLength) return true ; if(AL_OriginLength1+VI_CompareCnt< AL_SearchLength) return false; VI_CompareCnt =AL_SearchLength-VI_CompareCnt; VPC_OrginStart=APC_Origin1+AL_OriginLength1; for(TypeLength i=0; iAL_OriginLen) return false; return ZtCMainChars::DoStart(APC_Origin,APC_Search,AL_OriginLen,AL_SearchLen) && ZtCMainChars::DoClose(APC_Origin,APC_Search,AL_OriginLen,AL_SearchLen) ; }/* bool DoWrap(TypeCharC* APC_Origin, TypeCharC* APC_Search, TypeLength AL_OriginLen, TypeLength AL_SearchLen) */ template static TypeLength FindPos( const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch, TypeLength AL_StartPos=0) { return ZtCMainChars::FindPos( AR_CCharsOrigin.data(), AR_CCharsSearch.data(), AR_CCharsOrigin.size(), AR_CCharsSearch.size(), AL_StartPos); }/* template static TypeLength FindPos( const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch, TypeLength AL_StartPos=0) */ static TypeLength FindPos( TypeCharC* APC_Origin , TypeCharC* APC_Search , TypeLength AL_OriginLength, TypeLength AL_SearchLength, TypeLength AL_StartPos=0) { const bool CB_IsBad = ( AL_OriginLength<1 || AL_SearchLength<1 || AL_StartPos<0 || AL_StartPos>=AL_OriginLength ); if(CB_IsBad) return -1; TypeLength VL_Loop=AL_OriginLength-AL_SearchLength; TypeLength i =AL_StartPos; TypeLength j =0 ; /*////////////////////////////////////////////////////// ■ 아래 while 문 코드에서 if(j<1) ++i; else i+=j; 부분을 주목할 것. 연속된 N 개의 문자를 찾아야 하는데, M( static TypeLength FindPosLen( const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch, TypeLength& ARRL_MatchLen, TypeLength AL_StartPos=0) { return ZtCMainChars::FindPosLen( AR_CCharsOrigin.data(), AR_CCharsSearch.data(), AR_CCharsOrigin.size(), AR_CCharsSearch.size(), RR(ARRL_MatchLen), AL_StartPos); }/* template static TypeLength FindPosLen( const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch, TypeLength& ARRL_MatchLen, TypeLength AL_StartPos=0) */ static TypeLength FindPosLen( //////////////////////////////////// TypeCharC* APC_Origin , TypeCharC* APC_Search , TypeLength AL_OriginLength , TypeLength AL_SearchLength , TypeLength& ARRL_MatchLen , TypeLength AL_StartPos=0 /*////////*/ ) /*//////////////////////////////////////////////*/ { const bool CB_IsBad = (AL_OriginLength<1 || AL_SearchLength<1 || AL_StartPos<0 || AL_StartPos>=AL_OriginLength ); if(CB_IsBad) return -1; TypeLength VL_Loop=AL_OriginLength-AL_SearchLength; TypeLength i =AL_StartPos; TypeLength j =0 ; while(i<=VL_Loop) { for(j=0; j static TypeLength FindPosEsc( const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch, const TTyChars& AR_CCharsEscape, TypeLength AL_StartPos=0) { return ZtCMainChars::FindPosEsc( AR_CCharsOrigin.data(), AR_CCharsSearch.data(), AR_CCharsEscape.data(), AR_CCharsOrigin.size(), AR_CCharsSearch.size(), AR_CCharsEscape.size(), AL_StartPos); }/* template static TypeLength FindPosEsc( const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch, const TTyChars& AR_CCharsEscape, TypeLength AL_StartPos=0) */ /* APC_Search 문자열을 찾는데 APC_WrapStart 로 시작한다면 APC_WrapClose 을 찾고 바로 다음에 APC_Search 이 있어야 그 위치를 반환한다. */ static TypeLength FindPosEscWrap( //////////////////////////////// TypeCharC* APC_Origin , TypeCharC* APC_Search , TypeCharC* APC_Escape , TypeCharC* APC_WrapStart , TypeCharC* APC_WrapClose , TypeLength AL_OriginLen , TypeLength AL_SearchLen , TypeLength AL_EscapeLen , TypeLength AL_WrapStartLen , TypeLength AL_WrapCloseLen , TypeLength AL_StartPos=0 /*//////////*/ ) ///////////////////////////////////////////////*/ { const bool CB_IsBad = (AL_OriginLen<1 || AL_SearchLen<1 || AL_OriginLen static TypeLength FindPosEscWrap( ////// const TTyChars& AR_CCharsOrigin , const TTyChars& AR_CCharsSearch , const TTyChars& AR_CCharsEscape , const TTyChars& AR_CCharsWrapStart, const TTyChars& AR_CCharsWrapClose, TypeLength AL_StartPos=0 /*//////////*/ ) ///////////////////////////////////////////////*/ { return ZtCMainChars::FindPosEscWrap( AR_CCharsOrigin.data(), AR_CCharsSearch.data(), AR_CCharsEscape.data(), AR_CCharsWrapStart.data(), AR_CCharsWrapClose.data(), AR_CCharsOrigin.size(), AR_CCharsSearch.size(), AR_CCharsEscape.size(), AR_CCharsWrapStart.size(), AR_CCharsWrapClose.size(), AL_StartPos /*/////////*/ ); }/* template static TypeLength FindPosEscWrap( ////// const TTyChars& AR_CCharsOrigin , const TTyChars& AR_CCharsSearch , const TTyChars& AR_CCharsEscape , const TTyChars& AR_CCharsWrapStart, const TTyChars& AR_CCharsWrapClose, TypeLength AL_StartPos=0 ////////////// ) ///////////////////////////////////////////////*/ /*//////////////////////////////////////////////////////////////// ■ FindPosEscWrap() 테스트. typedef std::NsChars::ZNsType::ZtCTypeChars ZCTypeChars; typedef std::NsChars::ZtCMainChars ZCMainChars; std::string CStrOrigin("{{ABC\\}}\"}},ABC"); std::string CStrSearch(","); std::string CStrEscape("\\"); std::string CStrWrapStart("{{"); std::string CStrWrapClose("}}"); cout<<"FindPosEscWrap="<"); VO_Vec.push_back("<"); cout<<"pos="<=0) { TypeLength j; for(j=0; j=0)*/ return -1; }/* static TypeLength FindPosFromEnd( TypeCharC* APC_Origin, TypeCharC* APC_Search, TypeLength AL_OriginLen, TypeLength AL_SearchLen)*/ template static TypeLength FindPosFromEnd(const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch) { return ZCMainChars::FindPosFromEnd(AR_CCharsOrigin.data(), AR_CCharsSearch.data(), AR_CCharsOrigin.size(), AR_CCharsSearch.size()); }/* template static TypeLength FindPosFromEnd(const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch) */ template static TypeLength GetMatchLenFromEnd(const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch) { return ZtCMainChars::GetMatchLenFromEnd(AR_CCharsOrigin.data(), AR_CCharsSearch.data(), AR_CCharsOrigin.size(), AR_CCharsSearch.size()); }/* template static TypeLength GetMatchLenFromEnd(const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch) */ static TypeLength GetMatchLenFromEnd( TypeCharC* APC_Origin, TypeCharC* APC_Search, TypeLength AL_OriginLength, TypeLength AL_SearchLength) { if(AL_OriginLength<1 || AL_SearchLength<1) return 0; TypeLength VL_LoopCnt = (AL_SearchLength>AL_OriginLength ? AL_OriginLength : AL_SearchLength); TypeCharC* VP_OriTemp= (AL_SearchLength>AL_OriginLength ? APC_Origin : APC_Origin+(AL_OriginLength-AL_SearchLength) ); TypeCharC* VP_OriTempIn; TypeCharC* VP_SeaTemp=APC_Search; TypeLength i=0; TypeLength j=0; for(i=VL_LoopCnt; i>0; --i) { VP_OriTempIn=VP_OriTemp++; VP_SeaTemp =APC_Search ; for(j=0; j=i) return i; }/* for(i=VL_LoopCnt; i>0; --i)*/ return 0; }/* static TypeLength GetMatchLenFromEnd( TypeCharC* APC_Origin, TypeCharC* APC_Search, TypeLength AL_OriginLength, TypeLength AL_SearchLength)*/ /* 앞에서부터 감싸는 문자열 APC_WrapStart 와 APC_WrapClose 사이에 있는 문자열이 n 회 반복된 전체 길이를 가져온다. APC_WrapStart 와 APC_WrapClose 길이를 포함한다. APC_WrapStart 와 APC_WrapClose 이 " 인 경우 "ABC""AAABBDD"ABC 라는 문자열에 대해서 "ABC""AAABBDD" 여기까지의 길이를 반환한다. */ static TypeLength GetWrapLen( //////////////////////////////////// TypeCharC* APC_OriginChar , TypeCharC* APC_WrapStart , TypeCharC* APC_WrapClose , TypeLength AL_OriginLen , TypeLength AL_WrapStartLen , TypeLength AL_WrapCloseLen /*//////////*/ ) ///////////////////////////////////////////////*/ { if(AL_OriginLen<1) return 0; TypeLength VL_SearchPos=0; TypeLength VL_SearchLen=0; TypeLength VL_FindPos =0; do //// { const bool CB_DoStart = ZtCMainChars::DoStart( APC_OriginChar+VL_SearchPos, APC_WrapStart, AL_OriginLen-VL_SearchPos, AL_WrapStartLen); if(CB_DoStart==false) return VL_SearchLen; // APC_WrapStart 로 시작하는 경우 VL_SearchPos+=AL_WrapStartLen; VL_SearchLen+=AL_WrapStartLen; VL_FindPos=ZtCMainChars::FindPos( APC_OriginChar, APC_WrapClose, AL_OriginLen, AL_WrapStartLen, VL_SearchPos); if(VL_FindPos<0) { // APC_WrapCloase 를 못 찾은 경우. return VL_SearchLen-AL_WrapStartLen; }/* if(VL_FindPos<0)*/ VL_SearchPos=VL_FindPos+AL_WrapCloseLen; VL_SearchLen=VL_FindPos+AL_WrapCloseLen; } while(VL_SearchLen static TypeLength GetWrapLen( const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsWrapStart, const TTyChars& AR_CCharsWrapClose) { return ZtCMainChars::GetWrapLen( AR_CCharsOrigin.data(), AR_CCharsWrapStart.data(), AR_CCharsWrapClose.data(), AR_CCharsOrigin.size(), AR_CCharsWrapStart.size(), AR_CCharsWrapClose.size()); }/* template static TypeLength GetWrapLen( const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsWrapStart, const TTyChars& AR_CCharsWrapClose)*/ static TypeLength FindPosLinear( ///////////////////////////////// TypeCharC* APC_Origin1 , TypeCharC* APC_Origin2 , TypeCharC* APC_Search , TypeLength AL_OriginLen1 , TypeLength AL_OriginLen2 , TypeLength AL_SearchLength , TypeLength& ARRL_SearchedPos1 , TypeLength& ARRL_SearchedPos2 , TypeLength& ARRL_SearchedLen1 , TypeLength& ARRL_SearchedLen2 /*//////////*/ ) ///////////////////////////////////////////////*/ { /* APC_Origin1 과 APC_Origin2 이 이어진 문자열로 보았을때 APC_Search 이 나오는 위치를 구한다. APC_Origin1 에서 발견된 위치는 ARRL_SearchedPos1 에 APC_Origin2 에서 발견된 위치는 ARRL_SearchedPos2 에 셋팅한다. APC_Origin1 에서 발견된 길이는 ARRL_SearchedLen1 에 APC_Origin2 에서 발견된 길이는 ARRL_SearchedLen2 에 셋팅한다. */ ARRL_SearchedPos1=-1; ARRL_SearchedPos2=-1; ARRL_SearchedLen1= 0; ARRL_SearchedLen2= 0; if(AL_SearchLength<1) return -1; TypeLength VL_MatchLen= 0; TypeLength VL_FindPos =-1; /* APC_Origin1 에서는 끝에서 최대 AL_SearchLength 개의 문자열만 비교한다. */ if(APC_Origin1=0) { ARRL_SearchedLen1=AL_SearchLength; return ARRL_SearchedPos1=VL_FindPos ; }/* if(VL_FindPos>=0)*/ if(VL_MatchLen>0) { if(AL_SearchLength-VL_MatchLen>AL_OriginLen2) return -1; //endif bool VB_IsOK=ZtCMainChars::DoStart( APC_Origin2 , APC_Search +VL_MatchLen, AL_OriginLen2 , AL_SearchLength-VL_MatchLen /*/////////*/ ); if(VB_IsOK==true) { ARRL_SearchedPos1=AL_OriginLen1-VL_MatchLen; ARRL_SearchedPos2=0 ; ARRL_SearchedLen1=VL_MatchLen; ARRL_SearchedLen2=AL_SearchLength-VL_MatchLen; return 0; }/* if(VB_IsOK==true)*/ }/* if(VL_MatchLen>0)*/ ARRL_SearchedPos2=ZtCMainChars::FindPos( APC_Origin2 , APC_Search , AL_OriginLen2 , AL_SearchLength , 0 /*/////////*/ ); /////////////////////// if(ARRL_SearchedPos2>=0) ARRL_SearchedLen2=AL_SearchLength; return ARRL_SearchedPos2; }/* static TypeLength FindPosLinear( ///////////////////////////////// TypeCharC* APC_Origin1 , TypeCharC* APC_Origin2 , TypeCharC* APC_Search , TypeLength AL_OriginLen1 , TypeLength AL_OriginLen2 , TypeLength AL_SearchLength , TypeLength& ARRL_SearchedPos1 , TypeLength& ARRL_SearchedPos2 , TypeLength& ARRL_SearchedLen1 , TypeLength& ARRL_SearchedLen2 ////////////// ) ///////////////////////////////////////////////*/ template static TypeLength FindPosLinear( ///////////////////////////////// const TTyChars& AR_CCharsOrigin1 , const TTyChars& AR_CCharsOrigin2 , const TTyChars& AR_CCharsSearch , TypeLength& ARRL_SearchedPos1, TypeLength& ARRL_SearchedPos2, TypeLength& ARRL_SearchedLen1, TypeLength& ARRL_SearchedLen2 /*//////////*/ ) ///////////////////////////////////////////////*/ { return ZtCMainChars::FindPosLinear( AR_CCharsOrigin1.data(), AR_CCharsOrigin2.data(), AR_CCharsSearch.data(), AR_CCharsOrigin1.size(), AR_CCharsOrigin2.size(), AR_CCharsSearch.size(), RR(ARRL_SearchedPos1) , RR(ARRL_SearchedPos2) , RR(ARRL_SearchedLen1) , RR(ARRL_SearchedLen2) /*//////////*/ ); }/* template static TypeLength FindPosLinear( ///////////////////////////////// const TTyChars& AR_CCharsOrigin1 , const TTyChars& AR_CCharsOrigin2 , const TTyChars& AR_CCharsSearch , TypeLength& ARRL_SearchedPos1, TypeLength& ARRL_SearchedPos2, TypeLength& ARRL_SearchedLen1, TypeLength& ARRL_SearchedLen2 ////////////// ) ///////////////////////////////////////////////*/ /*//////////////////////////////////////////////////////////////////////////////////////////// ■ template bool FindPosReady( TReadyExec AR_CReadyExec , const ZCChars& AR_CCharsOrigin , const ZCChars& AR_CCharsSearch , TString& ARR_CStrReadyBuff, TypeLength& ARRL_StartPos , // AR_CCharsOrigin.data() 의 offset 이다. ZNsEnum::ZERun& ARRE_ERun ///////////// ) 어떤 문자열에서 찾으려고 하는 데이타가 있는데, 문자열이 너무 길어서 한 번에 다 읽지 못하는 경우, 문자열을 조금씩 읽어서 찾는 문자열을 탐색할 필요가 있다. 구체적으로 아래 문자열로 예를 들어보자. abc_BOUND1_defg_BOUND2_hijkmln_BO_BOUND3_opqrstuvwxyz 이 문자열에서 찾는 문자열은 순서대로 BOUND1, BOUND2, BOUND3 이며 이 문자열을 찾을 때마다 그 이전 어떤 자료에 대하여 특정한 처리를 하고자 하는 것이다. 처음에는 abc_BOU 까지만 읽었다고 치자. 그러면 처음에 찾아야 하는 문자열 BOUND1 이 없으므로, abc_BOU 에 대하여 어떤 처리를 해줄 수 있다. 그런데 abc_BOU 는 끝나는 문자열이 찾는 문자열의 앞부분을 몇 글 자(BOU) 포함하고 있으므로, 이 부분을 제외한 abc_ 에 대해서만 처리를 해주어야 한다(다음으로 로딩하는 문자열이 ND1 으로 시작할 수 있는 것이다.) 그리고 나머지 BOU 는 버퍼에 저장해 놓는다. 그후 2 번째로 ND1_de 을 읽었다면, 먼저 버퍼에 찾는 문자열인 BOUND1 중에 BOU 는 버퍼에 이미 있으므로 그 다음 ND1_de 에서, BOU 뒤에 찾는 문자열인 ND1 을 찾아본다. 그러면 BOUND1 을 찾게 되고, 그 다음 데 이타 _de 을 얻는다. 이 이전 데이타는 모두 버린다. 버퍼도 비운다. 새로 얻은 데이타 _de 은 2 번째로 찾 는 문자열 BOUND2 를 전혀 포함하지 않거나, 찾는 문자열 앞 부분 몇 개의 문자와 동일한 문자로 끝나지도 않았다. 그래서 이 _de 에 대해서 안심하고(?) 예정된 처리를 해준다. 3 번째로 fg_BOUND2_hijkmln_BO 을 읽었다. 2 번째로 찾는 문자열 BOUND2 을 찾게 된다. 그러면 그 이전 문 자열 fg_ 에 대해서 처리를 해 주고 3 번째로 찾는 문자열 BOUND3 를 찾는다. BOUND3 는 없다. 그런데 BOUND3 의 앞 부분 BO 로 끝나고 있으므로, 이 BO 만 빼고(다음에 로딩하는 문자열이 UND3 로 시작할 수 있기 때문 에)나머지 문자열 _hijkmln_ 에 대해서 처리를 해준다. BO 는 버퍼에 저장해 놓는다. 4 번째로 _BOUND3_opqrstuvwxyz 을 읽었다. 버퍼에 있는 BO 를 생각하면 BO_BOUND3_opqrstuvwxyz 를 읽은 것 이 된다. 여기서 BOUND3 을 찾게 되고 버퍼에 있는 데이타 BO 와 그 다음 _ 에 대해서 지정된 처리를 해주면 된다. 그 다음 BOUND3 의 다음 데이타 _opqrstuvwxyz 을 처리해 주면 된다. 이 알고리즘을 구현한 것이 FindPosReady(~) 이다. FindPosReady() 은 읽어들인 문자열을 AR_CCharsSearch.data() 에 대입하여 AR_CCharsOrigin.data() 을 찾는다. 못찾았으면 다음에 읽어들인 문자열에 찾는 문자열이 존재할 수 있으므로, 일단 AR_CCharsOrigin.data() 의 뒤에서 AR_CCharsSearch.data() 의 앞부분과 일치하는 문자를 ARR_CStrReadyBuff 에 저장한다. (이 문자들은 찾는 문자열의 일부일 수 있다.) ■ TReadyExec 는 아래 두 멤버를 가져야 하며 참조형일 수 있다. std::ZNsEnum::ZERun TReadyExec::OnMeetNormal(TypeCharC*,TypeLength); std::ZNsEnum::ZERun TReadyExec::OnMeetReady (TypeCharC*,TypeLength,std::ZNsEnum::ZERun); 찾는 문자열은 ARR_CStrReadyBuff 와 AR_CCharsOrigin.data() 에 동시에 갈라져 있을 수 있는데, 찾는 문자열을 완전히 찾은 경우는 OnMeetReady() 멤버의 3 번 인수가 ZNsMain::ZNsEnum::ZERun_NO 이고 못찾은 경우는 3 번 인수가 ZNsMain::ZNsEnum::ZERun_OK 이다. ■ 인수 TString& ARR_CStrReadyBuff 을 빼고 좀 더 최적화할 수 있는 여지는 있다. ////////////////////////////////////////////////////////////////////////////////////////////*/ template< typename TReadyExec, typename TTyChars, typename TString> static bool FindPosReady( TReadyExec AR_CReadyExec , const TTyChars& AR_CCharsOrigin , const TTyChars& AR_CCharsSearch , TString& ARR_CStrReadyBuff, TypeLength& ARRL_StartPos , // AR_CCharsOrigin.data() 의 offset 이다. ZNsEnum::ZERun& ARRE_ERun /*//////////*/ ) ////////////////////////////////////////*/ { /*########################################################################################### ■ ARR_CStrReadyBuff 에는 AR_CCharsSearch.data() 의 앞부분과 일치하는 문자열이 들어 있다. 다른 엉뚱한 데이타가 들어있지 않도록 만전을 기해야 한다. ■ ARRL_StartPos 는 이 함수가 true 를 반환할 때는 (즉 AR_CCharsSearch.data() 를 찾았으면) AR_CCharsOrigin.data() 에서 다시 조회를 시작해야 하는 위치로 셋팅된다. 그래서 다음 번 조회시에는 AR_CCharsOrigin.data()+ARRL_StartPos 부터 조회하면 된다. ###########################################################################################*/ ZCChars VO_CCharsOrigin(AR_CCharsOrigin.data(), AR_CCharsOrigin.size()); VO_CCharsOrigin += ARRL_StartPos; if(VO_CCharsOrigin.size()<1 || AR_CCharsSearch.size()<1) { return false; } //////////////////////////////////////////////////////// TypeLength VL_ReadyBuffSize=ARR_CStrReadyBuff.size(); TypeLength VL_MatchLen =0; if(VL_ReadyBuffSize+VO_CCharsOrigin.size()0) { ARRE_ERun=AR_CReadyExec. OnMeetNormal(ARR_CStrReadyBuff.data(), VL_ReadyBuffSize); ARR_CStrReadyBuff=""; if(ARRE_ERun==ZNsMain::ZNsEnum::ZERun_NO) return false; }/* if(VL_ReadyBuffSize>0)*/ VL_MatchLen=ZtCMainChars::GetMatchLenFromEnd( VO_CCharsOrigin.data(), AR_CCharsSearch.data(), VO_CCharsOrigin.size(), VO_CCharsOrigin.size() /*/////////*/ ); //////////////////////////// TypeLength VL_ValidLen=VO_CCharsOrigin.size()-VL_MatchLen; if(VL_MatchLen>0) ARR_CStrReadyBuff.append(VO_CCharsOrigin.data()+VL_ValidLen, VL_MatchLen); if(VL_ValidLen>0) ARRE_ERun=AR_CReadyExec.OnMeetNormal(VO_CCharsOrigin.data(), VL_ValidLen); //endif return false; }/* if(VL_ReadyBuffSize+AR_CCharsOrigin.size()0) { ARRE_ERun=AR_CReadyExec.OnMeetReady( /////////// ARR_CStrReadyBuff.data(), VL_ReadyBuffSize , ZNsMain::ZNsEnum::ZERun_OK /*/////////*/ ); /////////////////////////////// if(ARRE_ERun==ZNsMain::ZNsEnum::ZERun_NO) return true; }/* if(VL_ReadyBuffSize>0)*/ ARRE_ERun=AR_CReadyExec.OnMeetReady( VO_CCharsOrigin.data(), VL_ReadyLen, ZNsMain::ZNsEnum::ZERun_NO); ARRL_StartPos +=VL_ReadyLen; ARR_CStrReadyBuff="" ; return true; }/* if(VB_IsOK==true)*/ if(VL_ReadyBuffSize>0) { ARRE_ERun=AR_CReadyExec.OnMeetNormal( ARR_CStrReadyBuff.data(), VL_ReadyBuffSize); ARR_CStrReadyBuff=""; if(ARRE_ERun==ZNsMain::ZNsEnum::ZERun_NO) return false; }/* if(VL_ReadyBuffSize>0)*/ VL_MatchLen=0; TypeLength VL_FindPos=ZtCMainChars::FindPosLen( VO_CCharsOrigin.data(), AR_CCharsSearch.data(), VO_CCharsOrigin.size(), AR_CCharsSearch.size(), RR(VL_MatchLen) /*/////////*/ ); ///////////////////////////////////////////// if(VL_FindPos<0) { ARRL_StartPos = -1; ARRE_ERun=AR_CReadyExec.OnMeetNormal( VO_CCharsOrigin.data(), VO_CCharsOrigin.size()-VL_MatchLen ); ARR_CStrReadyBuff.append( VO_CCharsOrigin.data()+VO_CCharsOrigin.size()-VL_MatchLen, VL_MatchLen ); return false; }/* if(VL_FindPos<0)*/ if(VL_FindPos>0) { ARRE_ERun=AR_CReadyExec. OnMeetNormal(VO_CCharsOrigin.data(), VL_FindPos); if(ARRE_ERun==ZNsMain::ZNsEnum::ZERun_NO) return true; }/* if(VL_FindPos>0)*/ ARRE_ERun =AR_CReadyExec.OnMeetReady( VO_CCharsOrigin.data()+VL_FindPos, AR_CCharsSearch.size(), ZNsMain::ZNsEnum::ZERun_NO); ARRL_StartPos+=(VL_FindPos+AR_CCharsSearch.size()); return true; }/* template< typename TReadyExec, typename TTyChars, typename TString> static bool FindPosReady( TReadyExec AR_CReadyExec , const TTyChars& AR_CCharsOrigin , const TTyChars& AR_CCharsSearch , TString& ARR_CStrReadyBuff, TypeLength& ARRL_StartPos , // AR_CCharsOrigin.data() 의 offset 이다. ZNsEnum::ZERun& ARRE_ERun ////////////// ) ////////////////////////////////////////*/ template< typename TReadyExec, typename TStringData> ////////////// static bool FindPosReady( TReadyExec AR_CReadyExec , TypeCharC* AP_OriginData , TypeCharC* AP_SearchData , TypeLength AL_OriginLen , TypeLength AL_SearchLen , TStringData& ARR_CStrReadyBuff, TypeLength& ARRL_StartPos , // AP_OriginData 의 offset 이다. ZNsEnum::ZERun& ARRE_ERun /*//////////*/ ) //////////////////////////////////////////*/ { return FindPosReady( AR_CReadyExec , ZCChars(AP_OriginData, AL_OriginLen), ZCChars(AP_SearchData, AL_SearchLen), ARR_CStrReadyBuff , ARRL_StartPos , // AP_OriginData 의 offset 이다. ARRE_ERun /*/////*/ ); ///////////////////////////////////////// }/* template< typename TReadyExec, typename TStringData> ////////////// static bool FindPosReady( TReadyExec AR_CReadyExec , TypeCharC* AP_OriginData , TypeCharC* AP_SearchData , TypeLength AL_OriginLen , TypeLength AL_SearchLen , TStringData& ARR_CStrReadyBuff, TypeLength& ARRL_StartPos , // AP_OriginData 의 offset 이다. ZNsEnum::ZERun& ARRE_ERun ////////////// ) //////////////////////////////////////////*/ /*//////////////////////////////////////////////////////////////////////////////// ■ 일종의 Call Back 함수인 TReadyExec::OnMeetNormal() 이나 TReadyExec::OnMeetReady() 에서 더 자세한 정보를 받을 수 있도록 AO_CHelpType 인수를 추가로 갖는 함수를 설계한다. 참조형이 아닌 값으로 넘기고 있다(THelpType AO_CHelpType). 따라서 THelpType 이 크기가 큰 object 일 경우는 포인터나, 포인터를 멤버로 갖는 object 로 포장해서 넘겨야 한다. ////////////////////////////////////////////////////////////////////////////////*/ template< typename TReadyExec , typename TTyChars, typename TStringData, typename THelpType> //////////// static bool FindPosReady( TReadyExec AR_CReadyExec , THelpType AO_CHelpType , const TTyChars& AR_CCharsOrigin , const TTyChars& AR_CCharsSearch , TStringData& ARR_CStrReadyBuff, TypeLength& ARRL_StartPos , // AR_CCharsOrigin.data() 의 offset 이다. ZNsEnum::ZERun& ARRE_ERun /*//////////*/ ) ///////////////////////////////////////////////*/ { /*######################################################################################## ■ ARR_CStrReadyBuff 에는 AR_CCharsSearch.data() 의 앞부분과 일치하는 문자열이 들어 있다. 다른 엉뚱한 데이타가 들어있지 않도록 만전을 기해야 한다. ■ ARRL_StartPos 는 이 함수가 true 를 반환할 때는 (즉 AR_CCharsSearch.data() 를 찾았으면) AR_CCharsOrigin.data() 에서 다시 조회를 시작해야 하는 위치로 셋팅된다. 그래서 다음 번 조회시에는 AR_CCharsOrigin.data()+ARRL_StartPos 부터 조회하면 된다. ########################################################################################*/ typedef ZNsMain::ZtCCheckRef ZCCheckRef ; typedef ZCCheckRef::TypeData TypeObject ; ZCChars VO_CCharsOrigin( AR_CCharsOrigin.data(), AR_CCharsOrigin.size() ) ; VO_CCharsOrigin += ARRL_StartPos ; if(VO_CCharsOrigin.size()<1 || AR_CCharsSearch.size()<1) { return false; } TypeLength VL_ReadyBuffSize=ARR_CStrReadyBuff.size(); TypeLength VL_MatchLen =0; if(VL_ReadyBuffSize+AR_CCharsOrigin.size()0) { ARRE_ERun= AR_CReadyExec.template OnMeetNormal ( ARR_CStrReadyBuff.data(), VL_ReadyBuffSize , ZCCheckRef::PassData(AO_CHelpType) ); ARR_CStrReadyBuff = ""; ////////////////////////////////// if(ARRE_ERun==ZNsMain::ZNsEnum::ZERun_NO) return false; }/* if(VL_ReadyBuffSize>0)*/ VL_MatchLen=ZtCMainChars::GetMatchLenFromEnd( VO_CCharsOrigin.data(), AR_CCharsSearch.data(), VO_CCharsOrigin.size(), VO_CCharsOrigin.size() /*/////////*/ ); //////////////////////////// TypeLength VL_ValidLen=VO_CCharsOrigin.size()-VL_MatchLen; if(VL_MatchLen>0) { ARR_CStrReadyBuff.append(VO_CCharsOrigin.data()+VL_ValidLen, VL_MatchLen); } if(VL_ValidLen>0) { ARRE_ERun=AR_CReadyExec.template OnMeetNormal ( VO_CCharsOrigin.data(), VL_ValidLen , ZCCheckRef::PassData(AO_CHelpType) ); ///////////////////////////////////////////////////////// }/* if(VL_ValidLen>0)*/ return false; }/* if(VL_ReadyBuffSize+AR_CCharsOrigin.size()0) { ARRE_ERun=AR_CReadyExec.template OnMeetReady ( ARR_CStrReadyBuff.data() , VL_ReadyBuffSize, ZNsMain::ZNsEnum::ZERun_OK, ZCCheckRef::PassData(AO_CHelpType) ); //////////////////////////////////////////////////////// if(ARRE_ERun==ZNsMain::ZNsEnum::ZERun_NO) return true; } //if(VL_ReadyBuffSize>0) ARRE_ERun=AR_CReadyExec.template OnMeetReady ( VO_CCharsOrigin.data() , VL_ReadyLen , ZNsMain::ZNsEnum::ZERun_NO, ZCCheckRef::PassData(AO_CHelpType) ); //////////////////////////////////////////////////////// ARRL_StartPos +=VL_ReadyLen; ARR_CStrReadyBuff=""; return true; }/* if(VB_IsOK==true)*/ if(VL_ReadyBuffSize>0) { ARRE_ERun=AR_CReadyExec.template OnMeetNormal ( ARR_CStrReadyBuff.data(), VL_ReadyBuffSize , ZCCheckRef::PassData(AO_CHelpType) ); ///////////////////////////////////////////////////////// ARR_CStrReadyBuff = ""; if(ARRE_ERun==ZNsMain::ZNsEnum::ZERun_NO) { return false; } }/* if(VL_ReadyBuffSize>0)*/ VL_MatchLen=0; TypeLength VL_FindPos=ZtCMainChars::FindPosLen( VO_CCharsOrigin.data(), AR_CCharsSearch.data(), VO_CCharsOrigin.size(), AR_CCharsSearch.size(), RR(VL_MatchLen) /*/////////*/ ); ///////////////////////////////////////////// if(VL_FindPos<0) { ARRL_StartPos=-1; ARRE_ERun=AR_CReadyExec.template OnMeetNormal ( VO_CCharsOrigin.data() , VO_CCharsOrigin.size()-VL_MatchLen, ZCCheckRef::PassData(AO_CHelpType) ); ///////////////////////////////////////////////////////// ARR_CStrReadyBuff.append ( VO_CCharsOrigin.data() + VO_CCharsOrigin.size() - VL_MatchLen, VL_MatchLen ); //////////////////////// return false; }/* if(VL_FindPos<0)*/ if(VL_FindPos>0) { ARRE_ERun=AR_CReadyExec.template OnMeetNormal ( VO_CCharsOrigin.data(), VL_FindPos , ZCCheckRef::PassData(AO_CHelpType) ); ///////////////////////////////////////////////////////// if(ARRE_ERun==ZNsMain::ZNsEnum::ZERun_NO) return true; }/* if(VL_FindPos>0)*/ ARRE_ERun=AR_CReadyExec.template OnMeetReady ( VO_CCharsOrigin.data()+VL_FindPos, AR_CCharsSearch.size(), ZNsMain::ZNsEnum::ZERun_NO , ZCCheckRef::PassData(AO_CHelpType) ); ARRL_StartPos+=(VL_FindPos+AR_CCharsSearch.size()); return true; }/* template< typename TReadyExec , typename TTyChars, typename TStringData, typename THelpType> //////////// static bool FindPosReady( TReadyExec AR_CReadyExec , THelpType AO_CHelpType , const TTyChars& AR_CCharsOrigin , const TTyChars& AR_CCharsSearch , TStringData& ARR_CStrReadyBuff, TypeLength& ARRL_StartPos , // AR_CCharsOrigin.data() 의 offset 이다. ZNsEnum::ZERun& ARRE_ERun ////////////// ) ///////////////////////////////////////////////*/ template static bool FindPosReady ( TReadyExec AR_CReadyExec , THelpType AO_CHelpType , TypeCharC* AP_OriginData , TypeCharC* AP_SearchData , TypeLength AL_OriginLen , TypeLength AL_SearchLen , TStringData& ARR_CStrReadyBuff, TypeLength& ARRL_StartPos , // AP_OriginData 의 offset 이다. ZNsEnum::ZERun& ARRE_ERun ) /////////////////////////////////////////////////////////////////*/ { typedef ZNsMain::ZtCCheckRef ZCCheckRef ; typedef ZCCheckRef::TypeData TypeObject ; return FindPosReady( AR_CReadyExec , ZCCheckRef::PassData(AO_CHelpType) , ZCChars(AP_OriginData, AL_OriginLen), ZCChars(AP_SearchData, AL_SearchLen), ARR_CStrReadyBuff , ARRL_StartPos , // AP_OriginData 의 offset 이다. ARRE_ERun /*/////*/ ); ///////////////////////////////////////////////////// }/* template static bool FindPosReady ( TReadyExec AR_CReadyExec , THelpType AO_CHelpType , TypeCharC* AP_OriginData , TypeCharC* AP_SearchData , TypeLength AL_OriginLen , TypeLength AL_SearchLen , TStringData& ARR_CStrReadyBuff, TypeLength& ARRL_StartPos , // AP_OriginData 의 offset 이다. ZNsEnum::ZERun& ARRE_ERun ) ///////////////////////////////////////////////////////////////////*/ template ////////////////// static bool FindPosReadyValid( const TTyChars& AR_CCharsOrigin , const TTyChars& AR_CCharsSearch , TStringData& ARR_CStrReadyBuff, TypeLength& ARRL_StartPos , TypeLength& ARRL_ValidReady , // ARR_CStrReadyBuff 의 유효길이 TypeLength& ARRL_ValidLen /*//////////*/ ) /////////////////////////////////////////////////*/ { // ARRL_ValidReady 은 0 이나 ARR_CStrReadyBuff.size() 중 한 값이다. if(ARRL_StartPos<0) ARRL_StartPos=0; ZCChars VO_CCharsOrigin( AR_CCharsOrigin.data(), AR_CCharsOrigin.size()); VO_CCharsOrigin+=ARRL_StartPos; /*///////////////////////////////////////////////////////////////////////////////////////// ■ FindPosReady() 함수와 비슷한 기능을 하는데, AR_CReadyExec 인수가 없는 대신 FindPosReady() 에서 쓰인 지역변수 VL_ValidLen 와 같은 의미를 가진 길이를 참조 인수 ARRL_ValidLen 에 전달한다. ARRL_ValidLen 은 AR_CCharsOrigin.data() 의 길이 중에서 찾는 문자열 영역에 포함되지 않는 길이를 나타내며, AR_CCharsOrigin.data() 의 앞에서부터 이 길이의 문자열 영역은 어떤 처리의 대상이 된다. ARR_CStrReadyBuff 가 가진 문자열이 AR_CCharsSearch.data() 와 match 되는 문자열이 없어서 ARR_CStrReadyBuff 이 찾는 대상의 일부가 아니라 어떤 처리의 대상이 되는 경우, ARR_CStrReadyBuff 의 길이를 참조 인수 ARRL_ValidReady 에 전달한다. ARR_CStrReadyBuff 는 AR_CCharsSearch.data() 의 일부분이므로 ARRL_ValidLen 데이타를 처리하기 앞서, AR_CCharsSearch.data() 에서 ARRL_ValidReady 만큼의 데이타를 먼저 처리를 해주어야 한다. ARRL_ValidReady 은 0 이나 ARR_CStrReadyBuff.size() 중 한 값이다. /////////////////////////////////////////////////////////////////////////////////////////*/ if(VO_CCharsOrigin.size()<1 || AR_CCharsSearch.size()<1) { ARRL_StartPos =-1; ARRL_ValidReady = 0; ARRL_ValidLen = 0; return false; }/* if(VO_CCharsOrigin.size()<1 || AR_CCharsSearch.size()<1)*/ TypeLength VL_ReadyBuffSize=ARR_CStrReadyBuff.size(); TypeLength VL_MatchLen =0; if(VL_ReadyBuffSize+VO_CCharsOrigin.size()0) ARR_CStrReadyBuff. append(VO_CCharsOrigin.data()+ARRL_ValidLen, VL_MatchLen); return false; }/* if(VL_ReadyBuffSize+AR_CCharsOrigin.size() ////////////////// static bool FindPosReadyValid( const TTyChars& AR_CCharsOrigin , const TTyChars& AR_CCharsSearch , TStringData& ARR_CStrReadyBuff, TypeLength& ARRL_StartPos , TypeLength& ARRL_ValidReady , // ARR_CStrReadyBuff 의 유효길이 TypeLength& ARRL_ValidLen ////////////// ) /////////////////////////////////////////////////*/ template static bool FindPosReadyValid( /////////////////////////////////// TypeCharC* AP_CharOrigin , TypeCharC* AP_CharSearch , TypeLength AL_OriginLen , TypeLength AL_SearchLen , TString& ARR_CStrReadyBuff, TypeLength& ARRL_StartPos , TypeLength& ARRL_ValidReady , // ARR_CStrReadyBuff 의 유효길이 TypeLength& ARRL_ValidLen /*//////////*/ ) ///////////////////////////////////////////////*/ { return FindPosReadyValid( ///////////////////////////////// ZCChars(AP_CharOrigin, AL_OriginLen), ZCChars(AP_CharSearch, AL_SearchLen), RR(ARR_CStrReadyBuff) , ARRL_StartPos , ARRL_ValidReady , ARRL_ValidLen /*/////////*/ ); ////////////////////////////////////////// }/* template static bool FindPosReadyValid( /////////////////////////////////// TypeCharC* AP_CharOrigin , TypeCharC* AP_CharSearch , TypeLength AL_OriginLen , TypeLength AL_SearchLen , TString& ARR_CStrReadyBuff, TypeLength& ARRL_StartPos , TypeLength& ARRL_ValidReady , // ARR_CStrReadyBuff 의 유효길이 TypeLength& ARRL_ValidLen ////////////// ) ///////////////////////////////////////////////*/ static TypeLength GetFindCnt( TypeCharC* APC_Origin , TypeCharC* APC_Search, TypeLength AL_OriginLen, TypeLength AL_SearchLen ) { const bool CB_IsBad = (AL_OriginLen<1 || AL_SearchLen<1 || AL_OriginLen static TypeLength GetFindCnt( const TTyChars& AR_CCharsOrigin, const TTyChars& APC_CCharsSearch) { return ZtCMainChars::GetFindCnt( AR_CCharsOrigin.data(), APC_CCharsSearch.data(), AR_CCharsOrigin.size(), APC_CCharsSearch.size() ) ; }/* template static TypeLength GetFindCnt( const TTyChars& AR_CCharsOrigin, const TTyChars& APC_CCharsSearch) */ /*////////////////////////////////////////////////////////////////////////////// ■ APC_Origin 이 APC_Search+AL_SearchOffset 으로 시작하는지를 판단한다. AL_OriginLen static TypeLength GetStartLength( const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch, TypeLength AL_SearchOffset=0) { return ZtCMainChars::GetStartLength( AR_CCharsOrigin.data(), AR_CCharsSearch.data(), AR_CCharsOrigin.size(), AR_CCharsSearch.size(), AL_SearchOffset); }/* template static TypeLength GetStartLength( const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch, TypeLength AL_SearchOffset=0) */ template static void SplitEach( /////////////// TFunctor AR_TFunctor , TypeCharC* APC_OriginChar , TypeCharC* APC_SearchChar , TypeLength AL_OriginLen , TypeLength AL_SearchLen , bool AB_DoExecNull=true // 구분 문자로 잘린 문자열 길이가 0 인 경우에도 펑크터를 수행한다. /*//////////*/ ) ///////////////////////////////////////////////*/ { if(AL_OriginLen<1 || AL_OriginLenVL_CopyStartPos) { AR_TFunctor( APC_OriginChar+VL_CopyStartPos, VL_Index-VL_CopyStartPos, ++VI_SearchCount) ; } else if(AB_DoExecNull==true) { AR_TFunctor(0, 0, ++VI_SearchCount) ; }/* else if(AB_DoExecNull==true)*/ VL_CopyStartPos=VL_Index+=AL_SearchLen; }/* while(VL_Index<=VL_Loop)*/ if(VL_CopyStartPos>=AL_OriginLen) return; if(VI_SearchCount==0 && VL_CopyStartPos==0) { AR_TFunctor(APC_OriginChar, AL_OriginLen, ++VI_SearchCount) ; } else { AR_TFunctor( APC_OriginChar+VL_CopyStartPos, AL_OriginLen-VL_CopyStartPos, ++VI_SearchCount) ; }/* else*/ }/* template static void SplitEach( /////////////// TFunctor AR_TFunctor , TypeCharC* APC_OriginChar , TypeCharC* APC_SearchChar , TypeLength AL_OriginLen , TypeLength AL_SearchLen , bool AB_DoExecNull=true ////////////// ) ///////////////////////////////////////////////*/ template static void SplitEach( TFunctor AR_TFunctor, const TTyChars& AR_CCharsOrigin , const TTyChars& AR_CCharsSearch, bool AB_DoExecNull=true) { ZtCMainChars::template SplitEach( AR_TFunctor, AR_CCharsOrigin.data(), AR_CCharsSearch.data(), AR_CCharsOrigin.size(), AR_CCharsSearch.size(), AB_DoExecNull /*/////////*/ ); ////////////////////////////////////////////// }/* template static void SplitEach( TFunctor AR_TFunctor, const TTyChars& AR_CCharsOrigin , const TTyChars& AR_CCharsSearch, bool AB_DoExecNull=true) */ template static bool SplitTwo( ///////////////// TypeCharC* APC_OriginChar , TypeCharC* APC_SearchChar , TypeLength AL_OriginLen , TypeLength AL_SearchLen , TString& ARR_CString1 , TString& ARR_CString2 /*//////////*/ ) ///////////////////////////////////////////////*/ { TypeLength VL_FindPos=ZtCMainChars:: FindPos(APC_OriginChar, APC_SearchChar, AL_OriginLen, AL_SearchLen); if(VL_FindPos<0) return false; ARR_CString1(APC_OriginChar, VL_FindPos); ARR_CString2( APC_OriginChar+VL_FindPos+AL_SearchLen, AL_OriginLen -VL_FindPos-AL_SearchLen ); return true; }/* template static bool SplitTwo( ///////////////// TypeCharC* APC_OriginChar , TypeCharC* APC_SearchChar , TypeLength AL_OriginLen , TypeLength AL_SearchLen , TString& ARR_CString1 , TString& ARR_CString2 ////////////// ) ///////////////////////////////////////////////*/ template static bool SplitTwo( const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch, TString& ARR_CString1, TString& ARR_CString2) { return ZtCMainChars::SplitTwo( AR_CCharsOrigin.data(), AR_CCharsSearch.data(), AR_CCharsOrigin.size(), AR_CCharsSearch.size(), RR(ARR_CString1), RR(ARR_CString2)); }/* template static bool SplitTwo( const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch, TString& ARR_CString1, TString& ARR_CString2) */ template static TStringList& SplitToList( /*######*/ TStringList& ARR_SaveList , TypeCharC* APC_OriginChar, TypeCharC* APC_SearchChar, TypeLength AL_OriginLen , TypeLength AL_SearchLen , bool AB_DoEndWhenNoMatch=true , bool AB_DoAppendEachLink=false, bool AB_DoAppendEmpty =false /*############*/ ) /*###################################################*/ { /*////////////////////////////////////////////////////////////////////////// ■ AB_DoEndWhenNoMatch==true 이면 구분문자열을 하나도 찾지 못한 경우 전체 원본 문자열 APC_OriginChar 을 ARR_SaveList 에 저장하지 않고 종료한다. ■ 연속된 APC_SearchChar 사이에 다른 문자가 없어도 비어 있는 TString object 를 ARR_SaveList 에 저장한다. //////////////////////////////////////////////////////////////////////////*/ if(AL_OriginLen<1 || AL_OriginLenVL_CopyStartPos) { if(AB_DoAppendEachLink==true) { ((CStringData&)ARR_SaveList). append(APC_OriginChar+VL_CopyStartPos, VL_Index-VL_CopyStartPos) ; } else { ((CStringData&)ARR_SaveList).Invalidate(). append(APC_OriginChar+VL_CopyStartPos, VL_Index-VL_CopyStartPos) ; }/* else*/ } else if(AB_DoAppendEmpty==true) { (CStringData&)ARR_SaveList; }/* else if(AB_DoAppendEmpty==true)*/ VL_CopyStartPos=VL_Index+=AL_SearchLen; }/* while(VL_Index<=VL_Loop)*/ if(VL_CopyStartPos>=AL_OriginLen) { return ARR_SaveList; }/* if(VL_CopyStartPos>=AL_OriginLen)*/ if(VL_PrevSize static TStringList& SplitToList( ########## TStringList& ARR_SaveList , TypeCharC* APC_OriginChar, TypeCharC* APC_SearchChar, TypeLength AL_OriginLen , TypeLength AL_SearchLen , bool AB_DoEndWhenNoMatch=true , bool AB_DoAppendEachLink=false, bool AB_DoAppendEmpty =false ################# ) ####################################################*/ template< typename TTyChars, typename TStringList> static TStringList& SplitToList( TStringList& ARR_SaveList , const TTyChars& AR_CCharsOrigin , const TTyChars& AR_CCharsSearch , bool AB_DoEndWhenNoMatch=true , bool AB_DoAppendEachLink=false, bool AB_DoAppendEmpty =false /*/////////////*/ ) { return ZtCMainChars::SplitToList( RR(ARR_SaveList), AR_CCharsOrigin.data(), AR_CCharsSearch.data(), AR_CCharsOrigin.size(), AR_CCharsSearch.size(), AB_DoEndWhenNoMatch , AB_DoAppendEachLink , AB_DoAppendEmpty /*//////////*/ ); }/* template< typename TTyChars, typename TStringList> static TStringList& SplitToList( TStringList& ARR_SaveList , const TTyChars& AR_CCharsOrigin , const TTyChars& AR_CCharsSearch , bool AB_DoEndWhenNoMatch=true , bool AB_DoAppendEachLink=false, bool AB_DoAppendEmpty =false ///////////////// ) */ /*////////////////////////////////////////////////////////////////////////// ■ APC_SearchChar 로 APC_OriginChar 을 자르는데 자르는 단위의 문자열은 앞뒤에 APC_EscapeChar 으로 감쌀 수도 있다. APC_EscapeChar 으로 감싸는 문자열 안에는 APC_SearchChar 이 들어갈 수 있다. APC_EscapeChar 으로 감싸는 문자열 안에는 APC_EscapeChar 문자열이 짝수개가 나와야 한다. APC_SearchChar 이 "," 이고 APC_EscapeChar 가 "\"" 이라면 문자열 1,2,"My, Data=""Love""",10 은 아래 4 개로 나뉘어 진다. 1 2 My, Data=""Love"" 10 ■ -- //////////////////////////////////////////////////////////////////////*/ template static TStringList& SplitToListWrap( ///////////////////////////// TStringList& ARR_SaveList , TypeCharC* APC_OriginChar , TypeCharC* APC_SearchChar , TypeCharC* APC_WrapStart , TypeCharC* APC_WrapClose , TypeLength AL_OriginLen , TypeLength AL_SearchLen , TypeLength AL_WrapStartLen , TypeLength AL_WrapCloseLen , bool AB_DoEndWhenNoMatch=true , bool AB_DoAppendEachLink=false /*//////////*/ ) ///////////////////////////////////////////////*/ { // AB_DoEndWhenNoMatch==true 이면 구분 문자열을 하나도 찾지 못한 경우 // 전체 원본 문자열 APC_OriginChar 을 ARR_SaveList 에 저장하지 않고 종료한다. if(AL_WrapStartLen<1 && AL_WrapCloseLen<1) { ZtCMainChars::SplitToList( ARR_SaveList , APC_OriginChar , APC_SearchChar , AL_OriginLen , AL_SearchLen , AB_DoEndWhenNoMatch , AB_DoAppendEachLink /*/////////*/ ); return ARR_SaveList; } if(AL_OriginLen<1 || AL_OriginLen0 && ( VL_PrevSizeGetData(). append(APC_OriginChar+VL_SearchPos, VL_SearchLen) ; } else { ARR_SaveList.AddTailDefault()->GetData().Invalidate(). append(APC_OriginChar+VL_SearchPos, VL_SearchLen) ; }/* else*/ }/* if(VL_SearchLen>0 && ( VL_PrevSize0) { if(AB_DoAppendEachLink==true) { ARR_SaveList.AddTailDefault()->GetData(). append(APC_OriginChar+VL_SearchPos, VL_SearchLen) ; } else { ARR_SaveList.AddTailDefault()->GetData().Invalidate(). append(APC_OriginChar+VL_SearchPos, VL_SearchLen) ; }/* else*/ }/* if(VL_SearchLen>0)*/ VL_SearchLen=0; VL_SearchPos=VL_FindPos+AL_SearchLen; }/* while(VL_SearchPos static TStringList& SplitToListWrap( ///////////////////////////// TStringList& ARR_SaveList , TypeCharC* APC_OriginChar , TypeCharC* APC_SearchChar , TypeCharC* APC_WrapStart , TypeCharC* APC_WrapClose , TypeLength AL_OriginLen , TypeLength AL_SearchLen , TypeLength AL_WrapStartLen , TypeLength AL_WrapCloseLen , bool AB_DoEndWhenNoMatch=true , bool AB_DoAppendEachLink=false ////////////// ) ///////////////////////////////////////////////*/ template ////////////////// static TStringList& SplitToListWrap( TStringList& ARR_SaveList , const TTyChars& AR_CCharsOrigin , const TTyChars& AR_CCharsSearch , const TTyChars& AR_CCharsWrapStart, const TTyChars& AR_CCharsWrapClose, bool AB_DoEndWhenNoMatch=true , bool AB_DoAppendEachLink=false /*//////////*/ ) ///////////////////////////////////////////////*/ { return ZtCMainChars::SplitToListWrap( ARR_SaveList, AR_CCharsOrigin.data(), AR_CCharsSearch.data(), AR_CCharsWrapStart.data(), AR_CCharsWrapClose.data(), AR_CCharsOrigin.size(), AR_CCharsSearch.size(), AR_CCharsWrapStart.size(), AR_CCharsWrapClose.size(), AB_DoEndWhenNoMatch, AB_DoAppendEachLink /*//////////*/ ); }/* template ////////////////// static TStringList& SplitToListWrap( TStringList& ARR_SaveList , const TTyChars& AR_CCharsOrigin , const TTyChars& AR_CCharsSearch , const TTyChars& AR_CCharsWrapStart, const TTyChars& AR_CCharsWrapClose, bool AB_DoEndWhenNoMatch=true , bool AB_DoAppendEachLink=false ////////////// ) ///////////////////////////////////////////////*/ template //////////// static TStringList& SplitToListWrap2( TStringList& ARR_CStrListSave, TypeCharC* APC_Origin , TypeCharC* APC_Escape , TypeCharC* APC_WrapStart , TypeCharC* APC_WrapClose , TypeLength AL_OriginLen , TypeLength AL_EscapeLen , TypeLength AL_WrapStartLen , TypeLength AL_WrapCloseLen , TStringArray& ARA_SearchArray /*//////////*/ ) ///////////////////////////////////////////////*/ { typedef typename TStringList::TypeData CStringData; CStringData* VP_CStringStart=0; long VL_SearchPos= 0 ; long VL_FindPos =-1 ; long VL_PrevSize =ARR_CStrListSave.size(); while(VL_SearchPosVL_PrevSize) { ARR_CStrListSave.AddTailDefault()->GetData(). append(APC_Origin+VL_SearchPos, AL_OriginLen-VL_SearchPos) ; }/* if(ARR_CStrListSave.size()>VL_PrevSize)*/ return ARR_CStrListSave; }/* if(VL_FindPos<0)*/ if(VL_FindPos>0) { ARR_CStrListSave.AddTailDefault()->GetData()(APC_Origin+VL_SearchPos, VL_FindPos); ARR_CStrListSave.AddTailDefault()->GetData()=(*VP_CStringStart); }/* if(VL_FindPos>0)*/ VL_SearchPos+=VL_FindPos+VP_CStringStart->size(); }/* while(VL_SearchPos //////////// static TStringList& SplitToListWrap2( TStringList& ARR_CStrListSave, TypeCharC* APC_Origin , TypeCharC* APC_Escape , TypeCharC* APC_WrapStart , TypeCharC* APC_WrapClose , TypeLength AL_OriginLen , TypeLength AL_EscapeLen , TypeLength AL_WrapStartLen , TypeLength AL_WrapCloseLen , TStringArray& ARA_SearchArray ////////////// ) ///////////////////////////////////////////////*/ template TStringList& SplitToListWrap2( TStringList& ARR_CStrListSave , const TTyChars& AR_CCharsOrigin , const TTyChars& AR_CCharsEscape , const TTyChars& AR_CCharsWrapStart, const TTyChars& AR_CCharsWrapClose, TStringArray& ARA_SearchArray /*//////////*/ ) ///////////////////////////////////////////////////*/ { return ZtCMainChars::SplitToListWrap2( RR(ARR_CStrListSave), AR_CCharsOrigin.data(), AR_CCharsEscape.data(), AR_CCharsWrapStart.data(), AR_CCharsWrapClose.data(), AR_CCharsOrigin.size(), AR_CCharsEscape.size(), AR_CCharsWrapStart.size(), AR_CCharsWrapClose.size(), ARA_SearchArray /*//////////*/ ); }/* template TStringList& SplitToListWrap2( TStringList& ARR_CStrListSave , const TTyChars& AR_CCharsOrigin , const TTyChars& AR_CCharsEscape , const TTyChars& AR_CCharsWrapStart, const TTyChars& AR_CCharsWrapClose, TStringArray& ARA_SearchArray ////////////// ) ///////////////////////////////////////////////////*/ /* APC_OriginChar 에서 APC_Search 을 찾았으면 찾은 정보를 TSearchInfoList 에 입력한다. TSearchPosList 는 정수 컨테이너이다. */ template static void MakeInfoList( TypeCharC* APC_OriginChar, TypeCharC* APC_Search , TypeLength AL_OriginLen , TypeLength AL_SearchLen , TypeLength AL_StartPos , TSearchPosList& ARR_InfoList /*//////////*/ ) ////////////////////////////////////////*/ { if(AL_OriginLen<1 || AL_SearchLen<1 || AL_OriginLen static void MakeInfoList( TypeCharC* APC_OriginChar, TypeCharC* APC_Search , TypeLength AL_OriginLen , TypeLength AL_SearchLen , TypeLength AL_StartPos , TSearchPosList& ARR_InfoList ////////////// ) ////////////////////////////////////////*/ template static void MakeInfoList ( const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch, TypeLength AL_StartPos , TSearchPosList& ARR_InfoList ) ///////////////////////////////////////////////////////////////////////////// { ZtCMainChars::MakeInfoList( AR_CCharsOrigin.data(), AR_CCharsSearch.data(), AR_CCharsOrigin.size(), AR_CCharsSearch.size(), AL_StartPos, RR(ARR_InfoList) /*//////////*/ ); }/* template static void MakeInfoList ( const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch, TypeLength AL_StartPos , TSearchPosList& ARR_InfoList ) ///////////////////////////////////////////////////////////////////////////*/ /*///////////////////////////////////////////////////////////////////////// ■ TSearchInfo 클래스는 (const TypeChar* StartPos, long Pos, long Length) 의 인수를 갖는 생성자를 가져야 한다. ■ void MakeInfoList 함수와는 달리 APC_Search 문자열로 나뉘어지는 각 구간의 문자열 정보 리스트를 얻는다. /////////////////////////////////////////////////////////////////////////*/ template static void MakeSplitInfoList( TypeCharC* APC_OriginChar, TypeCharC* APC_Search , TypeLength AL_OriginLen , TypeLength AL_SearchLen , TypeLength AL_StartPos , TSearchInfoList& ARR_InfoList /*//////////*/ ) //////////////////////////////////////////////*/ { typedef typename TSearchInfoList::TypeData ZCSearchInfo; if(AL_OriginLen<1 || AL_SearchLen<1) return ; TypeCharC* VP_Origin=APC_OriginChar ; TypeLength i =AL_StartPos; TypeLength VL_PrevPos=AL_StartPos; TypeLength VL_Loop =AL_OriginLen-AL_SearchLen ; while(i<=VL_Loop) { TypeLength j=0; for(; j0) { ZCSearchInfo VO_CSearchInfo( VP_Origin+VL_PrevPos, VL_PrevPos, i-VL_PrevPos); ARR_InfoList.push_back(VO_CSearchInfo); }/* if(i-VL_PrevPos>0)*/ VL_PrevPos = i += AL_SearchLen ; }/* while(i<=VL_Loop)*/ if(VL_PrevPos static void MakeSplitInfoList( TypeCharC* APC_OriginChar, TypeCharC* APC_Search , TypeLength AL_OriginLen , TypeLength AL_SearchLen , TypeLength AL_StartPos , TSearchInfoList& ARR_InfoList ////////////// ) //////////////////////////////////////////////*/ template static void MakeSplitInfoList ( const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch, TypeLength AL_StartPos , TSearchInfoList& ARR_InfoList ) { ZtCMainChars::MakeSplitInfoList( AR_CCharsOrigin.data(), AR_CCharsSearch.data(), AR_CCharsOrigin.size(), AR_CCharsSearch.size(), AL_StartPos, RR(ARR_InfoList) /*//////////*/ ); }/* template static void MakeSplitInfoList ( const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch, TypeLength AL_StartPos , TSearchInfoList& ARR_InfoList ) /////////////////////////////////////////////////////////////////////////////////*/ // APC_Search 문자열을 찾아서, 있으면 그 문자열 길이까지 구한다. static TypeLength GetLength_Find( TypeCharC* APC_Origin, TypeLength AL_OriginLen, TypeCharC* APC_Search, TypeLength AL_SearchLen /*//////////*/ ) { if(AL_OriginLen<1 || AL_SearchLen<1 || AL_OriginLen=AL_SearchLen TypeLength j=0; TypeLength VL_MaxLoop=AL_OriginLen-AL_SearchLen; TypeCharC* VP_Origin =APC_Origin; TypeCharC* VP_Left ; TypeCharC* VP_Right; for(TypeLength i=0; i<=VL_MaxLoop; ++i) { VP_Left =VP_Origin; VP_Right=APC_Search ; for(j=0; j=AL_SearchLen) return i+AL_SearchLen; ++VP_Origin; ///////////////////////////// }/* for(TypeLength i=0; i<=VL_MaxLoop; ++i)*/ return 0; }/* static TypeLength GetLength_Find( TypeCharC* APC_Origin, TypeLength AL_OriginLen, TypeCharC* APC_Search, TypeLength AL_SearchLen ////////////// ) */ template static TypeLength GetLength_Find(const TTyChars& CCharsOrigin, const TTyChars& CCharsSearch) { return ZtCMainChars::GetLength_Find( CCharsOrigin.data(), CCharsOrigin.size(), CCharsSearch.data(), CCharsSearch.size() /*//////////*/ ); }/* template static TypeLength GetLength_Find(const TTyChars& CCharsOrigin, const TTyChars& CCharsSearch) */ /* ARA_SearchArray 의 앞 원소인 문자열부터 찾기 시작하므로, 먼저 찾아야 하는 문자열은 ARA_SearchArray 의 앞에 있는 것이 좋다. */ template static TypeLength GetLength_Find2( TypeCharC* APC_Origin, TypeLength AL_OriginLen, const TStringArray& ARA_SearchArray) { TypeLength VL_ArrSize=ARA_SearchArray.size(); TypeLength VL_NowSize; if(VL_ArrSize<1) return 0; IterEasyIDc CI_IterEasyID(ARA_SearchArray.GetHeadIterEasyID()); for(TypeLength i=0; i0) return VL_NowSize; ARA_SearchArray.MoveNextIter(RR(CI_IterEasyID)); }/* for(TypeLength i=0; i static TypeLength GetLength_Find2( TypeCharC* APC_Origin, TypeLength AL_OriginLen, const TStringArray& ARA_SearchArray) */ template static TypeLength GetLength_Find2(const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) { return ZtCMainChars::GetLength_Find2(AR_CCharsOrigin.data(), AR_CCharsOrigin.size(), ARA_SearchArray); }/* template static TypeLength GetLength_Find2(const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) */ // APC_Search 문자열의 문자 중에 하나라도 일치하면 그 길이까지 구해온다. static TypeLength GetLength_FindChar( TypeCharC* APC_Origin, TypeLength AL_OriginLen, TypeCharC* APC_Search, TypeLength AL_SearchLen /*//////////*/ ) { if(AL_OriginLen<1 || AL_SearchLen<1) return 0; TypeLength j =0 ; TypeCharC* VP_Origin =APC_Origin; TypeCharC* VP_Left ; TypeCharC* VP_Right; for(TypeLength i=0; i static TypeLength GetLength_FindChar(const TTyChars& CCharsOrigin, const TTyChars& CCharsSearch) { return ZtCMainChars::GetLength_FindChar( CCharsOrigin.data(), CCharsOrigin.size(), CCharsSearch.data(), CCharsSearch.size() /*//////////*/ ); }/* template static TypeLength GetLength_FindChar(const TTyChars& CCharsOrigin, const TTyChars& CCharsSearch) */ template static TypeLength GetLength_FindChar2( TypeCharC* APC_Origin, TypeLength AL_OriginLen, const TStringArray& ARA_SearchArray) { TypeLength VL_ArrSize=ARA_SearchArray.size(); TypeLength VL_NowSize=0; TypeLength VL_SumSize=0; if(VL_ArrSize<1) return 0; IterEasyIDc CI_IterEasyID(ARA_SearchArray.GetHeadIterEasyID()); for(TypeLength i=0; i static TypeLength GetLength_FindChar2( TypeCharC* APC_Origin, TypeLength AL_OriginLen, const TStringArray& ARA_SearchArray) */ template static TypeLength GetLength_FindChar2(const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) { return ZtCMainChars::GetLength_FindChar2(AR_CCharsOrigin.data(), AR_CCharsOrigin.size(), ARA_SearchArray); }/* template static TypeLength GetLength_FindChar2(const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) */ /* APC_Search 문자열을 찾아서, 있으면 그 문자열 길이까지 구한다. 단 찾는 문자열 앞에 APC_Escape 문자열이 없어야 한다. */ static TypeLength GetLength_FindEscape( TypeCharC* APC_Origin, TypeLength AL_OriginLen, TypeCharC* APC_Search, TypeLength AL_SearchLen, TypeCharC* APC_Escape, TypeLength AL_EscapeLen /*//////////*/ ) { if(AL_EscapeLen<1) return ZtCMainChars:: GetLength_Find(APC_Origin, AL_OriginLen, APC_Search,AL_SearchLen); if(AL_OriginLen<1 || AL_SearchLen<1 || AL_OriginLen static TypeLength GetLength_FindEscape( const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch, const TTyChars& AR_CCharsEscape) { return ZtCMainChars::GetLength_FindEscape( AR_CCharsOrigin.data(), AR_CCharsOrigin.size(), AR_CCharsSearch.data(), AR_CCharsSearch.size(), AR_CCharsEscape.data(), AR_CCharsEscape.size() /*//////////*/ ) ; }/* template static TypeLength GetLength_FindEscape( const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch, const TTyChars& AR_CCharsEscape) */ template static TypeLength GetLength_FindEscape2( TypeCharC* APC_Origin, TypeLength AL_OriginLen, const TStringArray& ARA_SearchArray) { /* ARA_SearchArray 의 첫번째 원소를 escape 문자열로 쓴다. 따라서 ARA_SearchArray 의 배열 갯수는 2 이상이어야 한다. */ const int CI_MinArrSize=2; TypeLength VL_ArrSize=ARA_SearchArray.size(); TypeLength VL_NowSize; if(VL_ArrSize0) return VL_NowSize; ARA_SearchArray.MoveNextIter(RR(CI_IterEasyID)); }/* for(TypeLength i=1; i static TypeLength GetLength_FindEscape2( TypeCharC* APC_Origin, TypeLength AL_OriginLen, const TStringArray& ARA_SearchArray) */ template static TypeLength GetLength_FindEscape2(const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) { return ZtCMainChars::GetLength_FindEscape2(AR_CCharsOrigin.data(), AR_CCharsOrigin.size(), ARA_SearchArray); }/* template static TypeLength GetLength_FindEscape2(const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) */ template static TypeLength GetLength_FindSerial( TypeCharC* APC_Origin, TypeLength AL_Length, const TStringArray& ARA_SearchArray) { /*////////////////////////////////////////////////// ■ ZtCMainChars::GetLength_Find() 함수를 이용하여, ARA_SearchArray 의 1번 원소부터 순서대로 찾는다. -- 2011-08-09 03:44:00 //////////////////////////////////////////////////*/ TypeLength VL_ArrSize=ARA_SearchArray.size(); TypeLength VL_NowSize=0; TypeLength VL_SumSize=0; if(VL_ArrSize<1) return 0; IterEasyIDc CI_IterEasyID(ARA_SearchArray.GetHeadIterEasyID()); for(TypeLength i=0; i static TypeLength GetLength_FindSerial( TypeCharC* APC_Origin, TypeLength AL_Length, const TStringArray& ARA_SearchArray) */ template static TypeLength GetLength_FindSerial(const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) { return ZtCMainChars::GetLength_FindSerial(AR_CCharsOrigin.data(), AR_CCharsOrigin.size(), ARA_SearchArray); }/* template static TypeLength GetLength_FindSerial(const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) */ static TypeLength GetLength_FindSerialChar( TypeCharC* APC_Origin, TypeLength AL_OriginLen, TypeCharC* APC_Search, TypeLength AL_SearchLen /*//////////*/ ) { // APC_Search 의 각 문자가 APC_Origin 에 순서대로 있어야 한다. if(AL_OriginLen<1 || AL_SearchLen<1 || AL_OriginLen static TypeLength GetLength_FindSerialChar(const TTyChars& CCharsOrigin, const TTyChars& CCharsSearch) { return ZtCMainChars::GetLength_FindSerialChar( CCharsOrigin.data(), CCharsOrigin.size(), CCharsSearch.data(), CCharsSearch.size() /*//////////*/ ); }/* template static TypeLength GetLength_FindSerialChar(const TTyChars& CCharsOrigin, const TTyChars& CCharsSearch) */ template static TypeLength GetLength_FindSerialChar2( TypeCharC* APC_Origin, TypeLength AL_OriginLen, const TStringArray& ARA_SearchArray) { TypeLength VL_ArrSize=ARA_SearchArray.size(); TypeLength VL_NowSize=0; TypeLength VL_SumSize=0; if(VL_ArrSize<1) return 0; IterEasyIDc CI_IterEasyID(ARA_SearchArray.GetHeadIterEasyID()); for(TypeLength i=0; i static TypeLength GetLength_FindSerialChar2( TypeCharC* APC_Origin, TypeLength AL_OriginLen, const TStringArray& ARA_SearchArray) */ template static TypeLength GetLength_FindSerialChar2(const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) { return ZtCMainChars::GetLength_FindSerialChar2(AR_CCharsOrigin.data(), AR_CCharsOrigin.size(), ARA_SearchArray); }/* template static TypeLength GetLength_FindSerialChar2(const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) */ template static TypeLength GetLength_StartFind( TypeCharC* APC_Origin, TypeLength AL_Length, const TStringArray& ARA_SearchArray) { /*////////////////////////////////////////////////// ■ ARA_SearchArray 의 1번 원소부터 시작하면, 그 다음부터는 ZtCMainChars::GetLength_Find() 함수를 이용하여, ARA_SearchArray 의 2번 원소부터 순서대로 찾는다. -- 2011-08-09 04:19:00 //////////////////////////////////////////////////*/ TypeLength VL_ArrSize=ARA_SearchArray.size(); TypeLength VL_NowSize=0; TypeLength VL_SumSize=0; if(VL_ArrSize<2) return 0; IterEasyIDc CI_IterEasyID(ARA_SearchArray.GetHeadIterEasyID()); const bool CB_IsOK=ZtCMainChars::DoStart( APC_Origin, ARA_SearchArray.ItD(CI_IterEasyID).data(), AL_Length , ARA_SearchArray.ItD(CI_IterEasyID).size() /*/////////*/ ); if(!CB_IsOK) return 0; VL_SumSize=ARA_SearchArray.ItD(CI_IterEasyID).size(); ARA_SearchArray.MoveNextIter(RR(CI_IterEasyID)); for(TypeLength i=1; i static TypeLength GetLength_StartFind( TypeCharC* APC_Origin, TypeLength AL_Length, const TStringArray& ARA_SearchArray) */ template static TypeLength GetLength_StartFind(const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) { return ZtCMainChars::GetLength_StartFind(AR_CCharsOrigin.data(), AR_CCharsOrigin.size(), ARA_SearchArray); }/* template static TypeLength GetLength_StartFind(const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) */ // GetLength_FindSerialChar() 와 비슷하나, 1 번 원소의 1 번 문자로 시작해야 하는 점이 다르다. static TypeLength GetLength_StartFindChar( TypeCharC* APC_Origin, TypeLength AL_OriginLen, TypeCharC* APC_Search, TypeLength AL_SearchLen /*//////////*/ ) { // APC_Search 의 각 문자가 APC_Origin 에 순서대로 있어야 한다. const bool CB_IsBad = ( AL_OriginLen<1 || AL_SearchLen<1 || AL_OriginLen static TypeLength GetLength_StartFindChar(const TTyChars& CCharsOrigin, const TTyChars& CCharsSearch) { return ZtCMainChars::GetLength_StartFindChar( CCharsOrigin.data(), CCharsOrigin.size(), CCharsSearch.data(), CCharsSearch.size() /*//////////*/ ); }/* template static TypeLength GetLength_StartFindChar(const TTyChars& CCharsOrigin, const TTyChars& CCharsSearch) */ template static TypeLength GetLength_StartFindChar2( TypeCharC* APC_Origin, TypeLength AL_OriginLen, const TStringArray& ARA_SearchArray) { TypeLength VL_ArrSize=ARA_SearchArray.size(); TypeLength VL_NowSize=0; TypeLength VL_SumSize=0; if(VL_ArrSize<1) return 0; IterEasyIDc CI_IterEasyID(ARA_SearchArray.GetHeadIterEasyID()); for(TypeLength i=0; i static TypeLength GetLength_StartFindChar2( TypeCharC* APC_Origin, TypeLength AL_OriginLen, const TStringArray& ARA_SearchArray) */ template static TypeLength GetLength_StartFindChar2(const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) { return ZtCMainChars::GetLength_FindSerialChar2(AR_CCharsOrigin.data(), AR_CCharsOrigin.size(), ARA_SearchArray); }/* template static TypeLength GetLength_StartFindChar2(const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) */ template static TypeLength GetLength_Permit( TypeCharC* APC_Origin, TypeLength AL_Length, const TStringArray& ARA_SearchArray) { TypeLength VL_ArrSize=ARA_SearchArray.size(); if(AL_Length<1 || VL_ArrSize<1) return 0; IterEasyIDc CI_IterEasyID(ARA_SearchArray.GetHeadIterEasyID()); for(TypeLength i=0; i static TypeLength GetLength_Permit( TypeCharC* APC_Origin, TypeLength AL_Length, const TStringArray& ARA_SearchArray) */ template static TypeLength GetLength_Permit(const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) { return ZtCMainChars::GetLength_Permit(AR_CCharsOrigin.data(), AR_CCharsOrigin.size(), ARA_SearchArray) ; }/* template static TypeLength GetLength_Permit(const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) */ /*////////////////////////////////////////////////////////////////////// ■ TStringArray 배열(혹은 어떤 containter)의 각 홀수 번째 원소 이상이고 그 다음 원소 이하인 데이타를 구한다. 따라서 TStringArray 배열원소수/2 번 순환한다. 찾은 데이타의 길이는 길이가 작은 쪽을 반환한다. 예를 들어 어떤 데이타 가 "ab" 와 "def" 사이에 있다면 찾은 길이는 작은 쪽 "ab" 에 맞추어 2 로 한다. //////////////////////////////////////////////////////////////////////*/ template static TypeLength GetLength_PermitRange( TypeCharC* APC_Origin, TypeLength AL_Length, const TStringArray& ARA_SearchArray) { TypeLength VL_ArrSize=ARA_SearchArray.size()/2; TypeLength VL_NowSize=0; TypeLength VL_Result =0; TypeLength i =0; if(AL_Length<1 || VL_ArrSize<1) return 0; IterEasyIDc CI_IterEasyID(ARA_SearchArray.GetHeadIterEasyID()); for(; i0) { VL_NowSize = ARA_SearchArray.ItD(CI_IterEasyID).size()>AL_Length ? AL_Length : ARA_SearchArray.ItD(CI_IterEasyID).size() ; if (VL_Result==0 ) VL_Result=VL_NowSize; else if(VL_Result> VL_NowSize) VL_Result=VL_NowSize; if(ZtCMainChars::Minus(APC_Origin, ARA_SearchArray.ItD(CI_IterEasyID).data(), VL_NowSize, ARA_SearchArray.ItD(CI_IterEasyID).size())<0) { ARA_SearchArray.MoveNextIter(RR(CI_IterEasyID)); ARA_SearchArray.MoveNextIter(RR(CI_IterEasyID)); continue; // 최소 범위를 벗어났다면 }/* if(ZtCMainChars::Minus(APC_Origin, ARA_SearchArray.ItD(CI_IterEasyID).data(), VL_NowSize, ARA_SearchArray.ItD(CI_IterEasyID).size())<0)*/ }/* if(ARA_SearchArray.ItD(CI_IterEasyID).size()>0)*/ ARA_SearchArray.MoveNextIter(RR(CI_IterEasyID)); if(ARA_SearchArray.ItD(CI_IterEasyID).size()>0) { VL_NowSize = ARA_SearchArray.ItD(CI_IterEasyID).size()>AL_Length ? AL_Length : ARA_SearchArray.ItD(CI_IterEasyID).size() ; if(VL_Result>VL_NowSize) VL_Result=VL_NowSize; if(ZtCMainChars::Minus(APC_Origin, ARA_SearchArray.ItD(CI_IterEasyID).data(), VL_NowSize, ARA_SearchArray.ItD(CI_IterEasyID).size())>0) { ARA_SearchArray.MoveNextIter(RR(CI_IterEasyID)); continue; // 최대 범위를 벗어났다면 }/* if(ZtCMainChars::Minus(APC_Origin, ARA_SearchArray.ItD(CI_IterEasyID).data(), VL_NowSize, ARA_SearchArray.ItD(CI_IterEasyID).size())>0)*/ break; }/* if(ARA_SearchArray.ItD(CI_IterEasyID).size()>0)*/ ARA_SearchArray.MoveNextIter(RR(CI_IterEasyID)); }/* for(; i=VL_ArrSize) return 0; return VL_Result; }/* template static TypeLength GetLength_PermitRange( TypeCharC* APC_Origin, TypeLength AL_Length, const TStringArray& ARA_SearchArray) */ template static TypeLength GetLength_PermitRange(const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray) { return ZtCMainChars::GetLength_PermitRange(AR_CChars.data(), AR_CChars.size(), ARA_SearchArray); }/* template static TypeLength GetLength_PermitRange(const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray) */ static TypeLength GetLength_PermitChar( TypeCharC* APC_Origin, TypeLength AL_Length, TypeCharC* APC_Permit, TypeLength AL_PermitLength) { if(AL_Length<1 || AL_PermitLength<1) return 0; TypeCharC* VPC_Origin=APC_Origin; TypeCharC* VPC_Permit=APC_Permit; TypeLength VL_SearchLen=0; TypeLength j =0; for(TypeLength i=0; i=AL_PermitLength) return VL_SearchLen; VPC_Origin++; VPC_Permit=APC_Permit; j=0; }/* for(TypeLength i=0; i static TypeLength GetLength_PermitChar(const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch) { return ZtCMainChars::GetLength_PermitChar( AR_CCharsOrigin.data(), AR_CCharsOrigin.size(), AR_CCharsSearch.data(), AR_CCharsSearch.size()); }/* template static TypeLength GetLength_PermitChar(const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch) */ static TypeLength GetLength_PermitCharRange( TypeCharC* APC_Origin, TypeLength AL_Length, TypeCharC* APC_Permit, TypeLength AL_PermitLength) { /*//////////////////////////////////////////////// ■ AL_PermitLength 은 2 의 배수로서, 2개의 문자가, 허용하는 문자의 범위를 나타낸다. -- 2011-08-12 00:53:00 ////////////////////////////////////////////////*/ if(AL_Length<1 || AL_PermitLength<2) return 0; TypeCharC* VPC_Origin=APC_Origin; TypeCharC* VPC_Permit=APC_Permit; TypeLength VL_SearchLen =0; TypeLength VL_PermitLength=AL_PermitLength/2; TypeLength j =0; for(TypeLength i=0;i=*VPC_Permit && *VPC_Origin<=*(VPC_Permit+1)) { ++VL_SearchLen; break; }/* if(*VPC_Origin>=*VPC_Permit && *VPC_Origin<=*(VPC_Permit+1))*/ VPC_Permit+=2; }/* for(; j=VL_PermitLength) return VL_SearchLen; VPC_Origin++; VPC_Permit=APC_Permit; j=0; }/* for(TypeLength i=0; i static TypeLength GetLength_PermitCharRange(const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch) { return ZtCMainChars::GetLength_PermitCharRange( AR_CCharsOrigin.data(), AR_CCharsOrigin.size(), AR_CCharsSearch.data(), AR_CCharsSearch.size()); }/* template static TypeLength GetLength_PermitCharRange(const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch) */ template static TypeLength GetLength_PermitCharRange2( TypeCharC* APC_Origin, TypeLength AL_Length, const TStringArray& ARA_SearchArray) { // ARA_SearchArray 의 각 문자열 원소를 순서대로 찾는다. TypeLength VL_ArrSize =ARA_SearchArray.size(); TypeLength VL_SearchNow=0; TypeLength VL_SearchSum=0; if(AL_Length<1 || VL_ArrSize<1) return 0; IterEasyIDc CI_IterEasyID(ARA_SearchArray.GetHeadIterEasyID()); for(TypeLength i=0; i static TypeLength GetLength_PermitCharRange2( TypeCharC* APC_Origin, TypeLength AL_Length, const TStringArray& ARA_SearchArray) */ template static TypeLength GetLength_PermitCharRange2( const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) { return ZtCMainChars::GetLength_PermitCharRange2( AR_CCharsOrigin.data(), AR_CCharsOrigin.size(), ARA_SearchArray ); }/* template static TypeLength GetLength_PermitCharRange2( const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) */ template static TypeLength GetLength_PermitChar2( TypeCharC* APC_Origin, TypeLength AL_Length, const TStringArray& ARA_SearchArray) { // ARA_SearchArray 의 각 문자열 원소를 순서대로 찾는다. TypeLength VL_ArrSize =ARA_SearchArray.size(); TypeLength VL_SearchNow=0; TypeLength VL_SearchSum=0; if(AL_Length<1 || VL_ArrSize<1) return 0; IterEasyIDc CI_IterEasyID(ARA_SearchArray.GetHeadIterEasyID()); for(TypeLength i=0; i static TypeLength GetLength_PermitChar2( TypeCharC* APC_Origin, TypeLength AL_Length, const TStringArray& ARA_SearchArray)*/ template static TypeLength GetLength_PermitChar2( const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) { return ZtCMainChars::GetLength_PermitChar2( AR_CCharsOrigin.data(), AR_CCharsOrigin.size(), ARA_SearchArray); }/* template static TypeLength GetLength_PermitChar2( const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) */ /* 특정 문자열이 특정 문자열을 가지고 있지 않으면, 해당 길이를 1 로 반환한다. 그 다음 문자부터는 '불허용 문자열'일 수 있기 때문이다. */ template static TypeLength GetLength_NoPermit( TypeCharC* APC_Origin, TypeLength AL_Length, const TStringArray& ARA_SearchArray) { TypeLength VL_ArrSize=ARA_SearchArray.size(); TypeLength VL_NowSize=0; if(AL_Length<1 || VL_ArrSize<1) return 0; IterEasyIDc CI_IterEasyID(ARA_SearchArray.GetHeadIterEasyID()); for(TypeLength i=0; iARA_SearchArray.ItD(CI_IterEasyID).size() ? ARA_SearchArray.ItD(CI_IterEasyID).size() : AL_Length ); const bool CB_IsOK=ZtCMainChars::DoStart( APC_Origin, ARA_SearchArray.ItD(CI_IterEasyID).data(), AL_Length , ARA_SearchArray.ItD(CI_IterEasyID).size() /*//////////*/ ); if(CB_IsOK) return 0; ARA_SearchArray.MoveNextIter(RR(CI_IterEasyID)); }/* for(TypeLength i=0; i static TypeLength GetLength_NoPermit( TypeCharC* APC_Origin, TypeLength AL_Length, const TStringArray& ARA_SearchArray) */ template static TypeLength GetLength_NoPermit(const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) { return ZtCMainChars::GetLength_NoPermit(AR_CCharsOrigin.data(), AR_CCharsOrigin.size(), ARA_SearchArray); }/* template static TypeLength GetLength_NoPermit(const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) */ template static TypeLength GetLength_NoPermitRange( TypeCharC* APC_Origin, TypeLength AL_Length, const TStringArray& ARA_SearchArray) { TypeLength VL_ArrSize=ARA_SearchArray.size()/2; TypeLength VL_NowSize=0; TypeLength i =0; int VI_Compare=0; if(AL_Length<1 || VL_ArrSize<1) return 0; IterEasyIDc CI_IterEasyID(ARA_SearchArray.GetHeadIterEasyID()); for(; i0) { VL_NowSize= ARA_SearchArray.ItD(CI_IterEasyID).size()>AL_Length ? AL_Length : ARA_SearchArray.ItD(CI_IterEasyID).size() ; VI_Compare=ZtCMainChars::Minus( APC_Origin, ARA_SearchArray.ItD(CI_IterEasyID).data(), VL_NowSize, ARA_SearchArray.ItD(CI_IterEasyID).size() ); }/* if(ARA_SearchArray.ItD(CI_IterEasyID).size()>0)*/ ARA_SearchArray.MoveNextIter(RR(CI_IterEasyID)); if(VI_Compare>=0 && ARA_SearchArray.ItD(CI_IterEasyID).size()>0) { VL_NowSize = ( ARA_SearchArray.ItD(CI_IterEasyID).size()>AL_Length ? AL_Length : ARA_SearchArray.ItD(CI_IterEasyID).size() ) ; if(ZtCMainChars::Minus( APC_Origin, ARA_SearchArray.ItD(CI_IterEasyID).data(), VL_NowSize, ARA_SearchArray.ItD(CI_IterEasyID).size())<=0) { return 0; }/* if(ZtCMainChars::Minus( APC_Origin, ARA_SearchArray.ItD(CI_IterEasyID).data(), VL_NowSize, ARA_SearchArray.ItD(CI_IterEasyID).size())<=0) */ }/* if(VI_Compare>=0 && ARA_SearchArray.ItD(CI_IterEasyID).size()>0)*/ ARA_SearchArray.MoveNextIter(RR(CI_IterEasyID)); }/* for(; i static TypeLength GetLength_NoPermitRange( TypeCharC* APC_Origin, TypeLength AL_Length, const TStringArray& ARA_SearchArray) */ template static TypeLength GetLength_NoPermitRange( const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray) { return ZtCMainChars::GetLength_NoPermitRange( AR_CChars.data(), AR_CChars.size(), ARA_SearchArray ); }/* template static TypeLength GetLength_NoPermitRange( const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray) */ static TypeLength GetLength_NoPermitChar ( TypeCharC* APC_Origin , TypeLength AL_Length, TypeCharC* APC_NoPermit, TypeLength AL_NoPermitLength ) //////////////////////////////////////// { if(AL_Length<1 || AL_NoPermitLength<1) return 0; TypeCharC* VPC_Origin =APC_Origin ; TypeCharC* VPC_NoPermit=APC_NoPermit; TypeLength VL_SearchLen=0; TypeLength j =0; for(TypeLength i=0; i static TypeLength GetLength_NoPermitChar( const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch) { return ZtCMainChars::GetLength_NoPermitChar( AR_CCharsOrigin.data(), AR_CCharsOrigin.size(), AR_CCharsSearch.data(), AR_CCharsSearch.size()); }/* template static TypeLength GetLength_PermitChar( const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch) */ template static TypeLength GetLength_NoPermitChar2( TypeCharC* APC_Origin, TypeLength AL_Length, const TStringArray& ARA_SearchArray) { // ARA_SearchArray 의 각 문자열 원소를 순서대로 찾는다. TypeLength VL_ArrSize =ARA_SearchArray.size(); TypeLength VL_SearchNow=0; TypeLength VL_SearchSum=0; if(AL_Length<1 || VL_ArrSize<1) return 0; IterEasyIDc CI_IterEasyID(ARA_SearchArray.GetHeadIterEasyID()); for(TypeLength i=0; i static TypeLength GetLength_NoPermitChar2( TypeCharC* APC_Origin, TypeLength AL_Length, const TStringArray& ARA_SearchArray) */ template static TypeLength GetLength_NoPermitChar2( const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) { return ZtCMainChars::GetLength_NoPermitChar2( AR_CCharsOrigin.data(), AR_CCharsOrigin.size(), ARA_SearchArray); }/* template static TypeLength GetLength_NoPermitChar2( const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) */ static TypeLength GetLength_NoPermitCharRange( TypeCharC* APC_Origin, TypeLength AL_Length, TypeCharC* APC_Permit, TypeLength AL_PermitLength) { /*//////////////////////////////////////////////// ■ AL_PermitLength 은 2 의 배수로서, 2개의 문자가, 허용하지 않는 문자의 범위를 나타낸다. -- 2011-08-12 00:53:00 ////////////////////////////////////////////////*/ if(AL_Length<1 || AL_PermitLength<2) return 0; TypeCharC* VPC_Origin=APC_Origin; TypeCharC* VPC_Permit=APC_Permit; TypeLength VL_SearchLen =0; TypeLength VL_PermitLength=AL_PermitLength/2; TypeLength j =0; for(TypeLength i=0; i=*VPC_Permit && *VPC_Origin<=*(VPC_Permit+1)) { ++VL_SearchLen; break; }/* if(*VPC_Origin>=*VPC_Permit && *VPC_Origin<=*(VPC_Permit+1))*/ VPC_Permit+=2; }/* for(; j static TypeLength GetLength_NoPermitCharRange(const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch) { return ZtCMainChars::GetLength_NoPermitCharRange( AR_CCharsOrigin.data(), AR_CCharsOrigin.size(), AR_CCharsSearch.data(), AR_CCharsSearch.size()); }/* template static TypeLength GetLength_NoPermitCharRange(const TTyChars& AR_CCharsOrigin, const TTyChars& AR_CCharsSearch) */ template static TypeLength GetLength_NoPermitCharRange2( TypeCharC* APC_Origin, TypeLength AL_Length, const TStringArray& ARA_SearchArray) { // ARA_SearchArray 의 각 문자열 원소를 순서대로 찾는다. TypeLength VL_ArrSize =ARA_SearchArray.size(); TypeLength VL_SearchNow=0; TypeLength VL_SearchSum=0; if(AL_Length<1 || VL_ArrSize<1) return 0; IterEasyIDc CI_IterEasyID(ARA_SearchArray.GetHeadIterEasyID()); for(TypeLength i=0; i static TypeLength GetLength_NoPermitCharRange2( TypeCharC* APC_Origin, TypeLength AL_Length, const TStringArray& ARA_SearchArray)*/ template static TypeLength GetLength_NoPermitCharRange2( const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) { return ZtCMainChars::GetLength_NoPermitCharRange2( AR_CCharsOrigin.data(), AR_CCharsOrigin.size(), ARA_SearchArray); }/* template static TypeLength GetLength_NoPermitCharRange2( const TTyChars& AR_CCharsOrigin, const TStringArray& ARA_SearchArray) */ template static TypeLength GetLength_Repeat_Find ( int AI_RepeatMin , int AI_RepeatMax , TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) /*###################################################################*/ { int VI_RepeatCnt=0; TypeLength VL_LengthAll=0; TypeLength VL_LengthNow=0; if(AI_RepeatMax<1) // 유효하지 않은 '최대 반복 횟수'의 경우, 무한대 반복 허용 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_Find2 ( APC_Origin+VL_LengthAll, AL_Length-VL_LengthAll, ARA_SearchArray ); //////////////////////////////////////////////////////////// if(VL_LengthNow<1) { if(VI_RepeatCnt>=AI_RepeatMin) return VL_LengthAll; else return 0; }/* if(VL_LengthNow<1)*/ ++VI_RepeatCnt; } while(true); } else // AI_RepeatMax>=1 { do //// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_Find2 ( APC_Origin+VL_LengthAll, AL_Length-VL_LengthAll, ARA_SearchArray ); //////////////////////////////////////////////////////////// // 현재 VI_RepeatCnt AI_RepeatMax) return 0; // '최대 반복 횟수'를 넘으면 0 을 반환. } else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop { if(++VI_RepeatCnt>=AI_RepeatMax) return VL_LengthAll; // '최대 반복 횟수'에 이르면 즉시 리턴. }/* else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop*/ } while(true); }/* else // AI_RepeatMax>=1 */ return VL_LengthAll; }/* template static TypeLength GetLength_Repeat_Find ( int AI_RepeatMin , int AI_RepeatMax , TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) #####################################################################*/ template static TypeLength GetLength_Repeat_Find( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) { return ZtCMainChars::GetLength_Repeat_Find( AI_RepeatMin, AI_RepeatMax, AR_CChars.data(), AR_CChars.size(), ARA_SearchArray, AE_ESearchMax); }/* template static TypeLength GetLength_Repeat_Find( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) */ template static TypeLength GetLength_Repeat_FindChar( /////////////////////////////// int AI_RepeatMin , int AI_RepeatMax , TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over /*/////////*/ ) { int VI_RepeatCnt=0; TypeLength VL_LengthAll=0; TypeLength VL_LengthNow=0; if(AI_RepeatMax<1) // 유효하지 않은 '최대 반복 횟수'의 경우, 무한대 반복 허용 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_FindChar2 ( APC_Origin+VL_LengthAll, AL_Length-VL_LengthAll, ARA_SearchArray ); //////////////////////////////////////////////////////////////// if(VL_LengthNow<1) { if(VI_RepeatCnt>=AI_RepeatMin) return VL_LengthAll; else return 0; }/* if(VL_LengthNow<1)*/ ++VI_RepeatCnt; } while(true); } else // AI_RepeatMax>=1 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_FindChar2 ( APC_Origin+VL_LengthAll, AL_Length -VL_LengthAll, ARA_SearchArray ); //////////////////////////////////////////////////////////////// if(VL_LengthNow<1) { // 현재 VI_RepeatCnt<=AI_RepeatMax 상태다. if(VI_RepeatCnt AI_RepeatMax) return 0; } else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop { if(++VI_RepeatCnt>=AI_RepeatMax) return VL_LengthAll; }/* else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop*/ } while(true); }/* else // AI_RepeatMax>=1*/ return VL_LengthAll; }/* template static TypeLength GetLength_Repeat_FindChar( /////////////////////////////// int AI_RepeatMin , int AI_RepeatMax , TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over /?/////////// ) */ template static TypeLength GetLength_Repeat_FindChar( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) { return ZtCMainChars::GetLength_Repeat_FindChar( AI_RepeatMin, AI_RepeatMax, AR_CChars.data(), AR_CChars.size(), ARA_SearchArray, AE_ESearchMax); }/* template static TypeLength GetLength_Repeat_FindChar( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) */ template static TypeLength GetLength_Repeat_FindEscape ( int AI_RepeatMin, int AI_RepeatMax, TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) /*#########################################################################*/ { /* ARA_SearchArray 의 첫번째 원소를 escape 문자열로 쓴다. 따라서 ARA_SearchArray 의 배열 갯수는 2 이상이어야 한다. ARA_SearchArray 의 앞 원소인 문자열부터 찾기 시작하므로 찾는 문자열 순서를 잘 지정해야 한다. */ int VI_RepeatCnt=0; TypeLength VL_LengthAll=0; TypeLength VL_LengthNow=0; if(AI_RepeatMax<1) // 유효하지 않은 '최대 반복 횟수'의 경우, 무한대 반복 허용 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_FindEscape2( /////////// APC_Origin+VL_LengthAll , AL_Length -VL_LengthAll , ARA_SearchArray /*/////////*/ ); /////////////////////////////// if(VL_LengthNow<1) { if(VI_RepeatCnt>=AI_RepeatMin) return VL_LengthAll; else return 0; }/* if(VL_LengthNow<1)*/ ++VI_RepeatCnt; } while(true); } else // AI_RepeatMax>=1 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_FindEscape2( /////////// APC_Origin+VL_LengthAll , AL_Length -VL_LengthAll , ARA_SearchArray /*//////////*/ ); ////////////////////////////// // 현재 VI_RepeatCnt AI_RepeatMax) return 0; } else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop { if(++VI_RepeatCnt>=AI_RepeatMax) return VL_LengthAll; }/* else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop*/ } while(true); }/* else // AI_RepeatMax>=1*/ return VL_LengthAll; }/* template static TypeLength GetLength_Repeat_FindEscape ( int AI_RepeatMin, int AI_RepeatMax, TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) ###########################################################################*/ template static TypeLength GetLength_Repeat_FindEscape( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) { return ZtCMainChars::GetLength_Repeat_FindEscape( AI_RepeatMin, AI_RepeatMax, AR_CChars.data(), AR_CChars.size(), ARA_SearchArray, AE_ESearchMax); }/* template static TypeLength GetLength_Repeat_FindEscape( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) */ template static TypeLength GetLength_Repeat_FindSerial ( int AI_RepeatMin , int AI_RepeatMax , TypeCharC* APC_Origin , TypeLength AL_Length, const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) ///////////////////////////////////////////////////////////////////////////// { int VI_RepeatCnt=0; TypeLength VL_LengthAll=0; TypeLength VL_LengthNow=0; if(AI_RepeatMax<1) // 유효하지 않은 '최대 반복 횟수'의 경우, 무한대 반복 허용 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_FindSerial( //////////// APC_Origin+VL_LengthAll , AL_Length -VL_LengthAll , ARA_SearchArray /*/////////*/ ); /////////////////////////////// if(VL_LengthNow<1) { if(VI_RepeatCnt>=AI_RepeatMin) return VL_LengthAll; else return 0; }/* if(VL_LengthNow<1)*/ ++VI_RepeatCnt; } while(true); } else // AI_RepeatMax>=1 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_FindSerial( //////////// APC_Origin+VL_LengthAll , AL_Length -VL_LengthAll , ARA_SearchArray /*//////////*/ ); ////////////////////////////// // 현재 VI_RepeatCnt AI_RepeatMax) return 0; } else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop { if(++VI_RepeatCnt>=AI_RepeatMax) return VL_LengthAll; }/* else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop*/ } while(true); }/* else // AI_RepeatMax>=1*/ return VL_LengthAll; }/* template static TypeLength GetLength_Repeat_FindSerial ( int AI_RepeatMin , int AI_RepeatMax , TypeCharC* APC_Origin , TypeLength AL_Length, const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) ///////////////////////////////////////////////////////////////////////////*/ template static TypeLength GetLength_Repeat_FindSerial( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) { return ZtCMainChars::GetLength_Repeat_FindSerial(AI_RepeatMin, AI_RepeatMax, AR_CChars.data(), AR_CChars.size(), ARA_SearchArray, AE_ESearchMax); }/* template static TypeLength GetLength_Repeat_FindSerial( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) */ template static TypeLength GetLength_Repeat_FindSerialChar ( int AI_RepeatMin, int AI_RepeatMax, TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) /*#############################################################################*/ { int VI_RepeatCnt=0; TypeLength VL_LengthAll=0; TypeLength VL_LengthNow=0; if(AI_RepeatMax<1) // 유효하지 않은 '최대 반복 횟수'의 경우, 무한대 반복 허용 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_FindSerialChar2 ( APC_Origin+VL_LengthAll, AL_Length-VL_LengthAll, ARA_SearchArray ); ////////////////////////////////////////////////////////////////////// if(VL_LengthNow<1) { if(VI_RepeatCnt>=AI_RepeatMin) return VL_LengthAll; else return 0; }/* if(VL_LengthNow<1)*/ ++VI_RepeatCnt; } while(true); } else // AI_RepeatMax>=1 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_FindSerialChar2 ( APC_Origin+VL_LengthAll, AL_Length -VL_LengthAll, ARA_SearchArray ); ////////////////////////////////////////////////////////////////////// if(VL_LengthNow<1) { // 현재 VI_RepeatCnt<=AI_RepeatMax 상태다. if(VI_RepeatCnt AI_RepeatMax) return 0; } else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop { if(++VI_RepeatCnt>=AI_RepeatMax) return VL_LengthAll; }/* else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop*/ } while(true); }/* else // AI_RepeatMax>=1*/ return VL_LengthAll; }/* template static TypeLength GetLength_Repeat_FindSerialChar ( int AI_RepeatMin, int AI_RepeatMax, TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) ###############################################################################*/ template static TypeLength GetLength_Repeat_FindSerialChar( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) { return ZtCMainChars::GetLength_Repeat_FindSerialChar( AI_RepeatMin, AI_RepeatMax, AR_CChars.data(), AR_CChars.size(), ARA_SearchArray, AE_ESearchMax); }/* template static TypeLength GetLength_Repeat_FindSerialChar( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) */ template static TypeLength GetLength_Repeat_StartFind ( int AI_RepeatMin, int AI_RepeatMax, TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) /*########################################################################*/ { int VI_RepeatCnt=0; TypeLength VL_LengthAll=0; TypeLength VL_LengthNow=0; if(AI_RepeatMax<1) // 유효하지 않은 '최대 반복 횟수'의 경우, 무한대 반복 허용 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_StartFind( //////////// APC_Origin+VL_LengthAll , AL_Length -VL_LengthAll , ARA_SearchArray /*/////////*/ ); ////////////////////////////// if(VL_LengthNow<1) { if(VI_RepeatCnt>=AI_RepeatMin) return VL_LengthAll; else return 0; }/* if(VL_LengthNow<1)*/ ++VI_RepeatCnt; } while(true); } else // AI_RepeatMax>=1 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_StartFind( //////////// APC_Origin+VL_LengthAll , AL_Length -VL_LengthAll , ARA_SearchArray /*//////////*/ ); ///////////////////////////// // 현재 VI_RepeatCnt AI_RepeatMax) return 0; } else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop { if(++VI_RepeatCnt>=AI_RepeatMax) return VL_LengthAll; }/* else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop*/ } while(true); }/* else // AI_RepeatMax>=1*/ return VL_LengthAll; }/* template static TypeLength GetLength_Repeat_StartFind ( int AI_RepeatMin, int AI_RepeatMax, TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) ##########################################################################*/ template static TypeLength GetLength_Repeat_StartFind( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) { return ZtCMainChars::GetLength_Repeat_StartFind( AI_RepeatMin, AI_RepeatMax, AR_CChars.data(), AR_CChars.size(), ARA_SearchArray, AE_ESearchMax); }/* template static TypeLength GetLength_Repeat_StartFind( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) */ template static TypeLength GetLength_Repeat_StartFindChar ( int AI_RepeatMin, int AI_RepeatMax, TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) /*#############################################################################*/ { int VI_RepeatCnt=0; TypeLength VL_LengthAll=0; TypeLength VL_LengthNow=0; if(AI_RepeatMax<1) // 유효하지 않은 '최대 반복 횟수'의 경우, 무한대 반복 허용 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_StartFindChar2 ( APC_Origin+VL_LengthAll, AL_Length-VL_LengthAll, ARA_SearchArray ); ///////////////////////////////////////////////////////////////////// if(VL_LengthNow<1) { if(VI_RepeatCnt>=AI_RepeatMin) return VL_LengthAll; else return 0; }/* if(VL_LengthNow<1)*/ ++VI_RepeatCnt; } while(true); } else // AI_RepeatMax>=1 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_StartFindChar2 ( APC_Origin+VL_LengthAll, AL_Length -VL_LengthAll, ARA_SearchArray ); ///////////////////////////////////////////////////////////////////// if(VL_LengthNow<1) { // 현재 VI_RepeatCnt<=AI_RepeatMax 상태다. if(VI_RepeatCnt AI_RepeatMax) return 0; } else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop { if(++VI_RepeatCnt>=AI_RepeatMax) return VL_LengthAll; }/* else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop*/ } while(true); }/* else // AI_RepeatMax>=1*/ return VL_LengthAll; }/* template static TypeLength GetLength_Repeat_StartFindChar ( int AI_RepeatMin, int AI_RepeatMax, TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) ###############################################################################*/ template static TypeLength GetLength_Repeat_StartFindChar( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) { return ZtCMainChars::GetLength_Repeat_StartFindChar( AI_RepeatMin, AI_RepeatMax, AR_CChars.data(), AR_CChars.size(), ARA_SearchArray, AE_ESearchMax); }/* template static TypeLength GetLength_Repeat_StartFindChar( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) */ template static TypeLength GetLength_Repeat_Permit ( int AI_RepeatMin, int AI_RepeatMax, TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) /*#####################################################################*/ { int VI_RepeatCnt=0; TypeLength VL_LengthAll=0; TypeLength VL_LengthNow=0; if(AI_RepeatMax<1) // 유효하지 않은 '최대 반복 횟수'의 경우, 무한대 반복 허용 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_Permit ( APC_Origin+VL_LengthAll, AL_Length-VL_LengthAll, ARA_SearchArray ); ///////////////////////////////////////////////////////////// if(VL_LengthNow<1) { if(VI_RepeatCnt>=AI_RepeatMin) return VL_LengthAll; else return 0; }/* if(VL_LengthNow<1)*/ ++VI_RepeatCnt; } while(true); } else // AI_RepeatMax>=1 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_Permit ( APC_Origin+VL_LengthAll, AL_Length-VL_LengthAll, ARA_SearchArray ); ///////////////////////////////////////////////////////////// if(VL_LengthNow<1) { // 현재 VI_RepeatCnt<=AI_RepeatMax 상태다. if(VI_RepeatCnt AI_RepeatMax) return 0; } else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop { if(++VI_RepeatCnt>=AI_RepeatMax) return VL_LengthAll; }/* else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop*/ } while(true); }/* else // AI_RepeatMax>=1*/ return VL_LengthAll; }/* template static TypeLength GetLength_Repeat_Permit ( int AI_RepeatMin, int AI_RepeatMax, TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) ///////////////////////////////////////////////////////////////////////*/ template static TypeLength GetLength_Repeat_Permit( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) { return ZtCMainChars::GetLength_Repeat_Permit( AI_RepeatMin, AI_RepeatMax, AR_CChars.data(), AR_CChars.size(), ARA_SearchArray, AE_ESearchMax); }/* template static TypeLength GetLength_Repeat_Permit( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) */ template static TypeLength GetLength_Repeat_PermitRange ( int AI_RepeatMin, int AI_RepeatMax, TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) ////////////////////////////////////////////////////////////////////////////// { int VI_RepeatCnt=0; TypeLength VL_LengthAll=0; TypeLength VL_LengthNow=0; if(AI_RepeatMax<1) // 유효하지 않은 최대 반복 횟수의 경우, 무한대 반복 허용 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_PermitRange ( APC_Origin+VL_LengthAll, AL_Length-VL_LengthAll, ARA_SearchArray ); ////////////////////////////////////////////////////////////////// if(VL_LengthNow<1) { if(VI_RepeatCnt>=AI_RepeatMin) return VL_LengthAll; else return 0; }/* if(VL_LengthNow<1)*/ ++VI_RepeatCnt; } while(true); } else // AI_RepeatMax>=1 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_PermitRange ( APC_Origin+VL_LengthAll, AL_Length-VL_LengthAll, ARA_SearchArray ); ////////////////////////////////////////////////////////////////// if(VL_LengthNow<1) { // 현재 VI_RepeatCnt<=AI_RepeatMax 상태다. if(VI_RepeatCnt AI_RepeatMax) return 0; } else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop { if(++VI_RepeatCnt>=AI_RepeatMax) return VL_LengthAll; }/* else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop*/ } while(true); }/* else // AI_RepeatMax>=1*/ return VL_LengthAll; }/* template static TypeLength GetLength_Repeat_PermitRange ( int AI_RepeatMin, int AI_RepeatMax, TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) ////////////////////////////////////////////////////////////////////////////*/ template static TypeLength GetLength_Repeat_PermitRange( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) { return ZtCMainChars::GetLength_Repeat_PermitRange( AI_RepeatMin, AI_RepeatMax, AR_CChars.data(), AR_CChars.size(), ARA_SearchArray, AE_ESearchMax); }/* template static TypeLength GetLength_Repeat_PermitRange( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) */ template static TypeLength GetLength_Repeat_PermitChar ( int AI_RepeatMin, int AI_RepeatMax, TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) /*#########################################################################*/ { int VI_RepeatCnt=0; TypeLength VL_LengthAll=0; TypeLength VL_LengthNow=0; if(AI_RepeatMax<1) // 유효하지 않은 '최대 반복 횟수'의 경우, 무한대 반복 허용 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_PermitChar2 ( APC_Origin+VL_LengthAll, AL_Length-VL_LengthAll, ARA_SearchArray ); ////////////////////////////////////////////////////////////////// if(VL_LengthNow<1) { if(VI_RepeatCnt>=AI_RepeatMin) return VL_LengthAll; else return 0; }/* if(VL_LengthNow<1)*/ ++VI_RepeatCnt; } while(true); } else // AI_RepeatMax>=1 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_PermitChar2 ( APC_Origin+VL_LengthAll, AL_Length-VL_LengthAll, ARA_SearchArray ); ////////////////////////////////////////////////////////////////// if(VL_LengthNow<1) { // 현재 VI_RepeatCnt<=AI_RepeatMax 상태다. if(VI_RepeatCnt AI_RepeatMax) return 0; } else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop { if(++VI_RepeatCnt>=AI_RepeatMax) return VL_LengthAll; }/* else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop*/ } while(true); }/* else // AI_RepeatMax>=1*/ return VL_LengthAll; }/* template static TypeLength GetLength_Repeat_PermitChar ( int AI_RepeatMin, int AI_RepeatMax, TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) ###########################################################################*/ template static TypeLength GetLength_Repeat_PermitChar( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) { return ZtCMainChars::GetLength_Repeat_PermitChar( AI_RepeatMin, AI_RepeatMax, AR_CChars.data(), AR_CChars.size(), ARA_SearchArray, AE_ESearchMax); }/* template static TypeLength GetLength_Repeat_PermitChar( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) */ template static TypeLength GetLength_Repeat_PermitCharRange ( int AI_RepeatMin, int AI_RepeatMax, TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) /*##############################################################################*/ { int VI_RepeatCnt=0; TypeLength VL_LengthAll=0; TypeLength VL_LengthNow=0; if(AI_RepeatMax<1) // 유효하지 않은 '최대 반복 횟수'의 경우, 무한대 반복 허용 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_PermitCharRange2 ( APC_Origin+VL_LengthAll, AL_Length-VL_LengthAll, ARA_SearchArray ); /////////////////////////////////////////////////////////////////////// if(VL_LengthNow<1) { if(VI_RepeatCnt>=AI_RepeatMin) return VL_LengthAll; else return 0; }/* if(VL_LengthNow<1)*/ ++VI_RepeatCnt; } while(true); } else // AI_RepeatMax>=1 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_PermitCharRange2 ( APC_Origin+VL_LengthAll, AL_Length-VL_LengthAll, ARA_SearchArray ); /////////////////////////////////////////////////////////////////////// if(VL_LengthNow<1) { // 현재 VI_RepeatCnt<=AI_RepeatMax 상태다. if(VI_RepeatCnt AI_RepeatMax) return 0; } else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop { if(++VI_RepeatCnt>=AI_RepeatMax) return VL_LengthAll; }/* else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop*/ } while(true); }/* else // AI_RepeatMax>=1*/ return VL_LengthAll; }/* template static TypeLength GetLength_Repeat_PermitCharRange ( int AI_RepeatMin, int AI_RepeatMax, TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) ################################################################################*/ template static TypeLength GetLength_Repeat_PermitCharRange( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) { return ZtCMainChars::GetLength_Repeat_PermitCharRange( AI_RepeatMin, AI_RepeatMax, AR_CChars.data(), AR_CChars.size(), ARA_SearchArray, AE_ESearchMax); }/* template static TypeLength GetLength_Repeat_PermitCharRange( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) */ template static TypeLength GetLength_Repeat_NoPermit ( int AI_RepeatMin, int AI_RepeatMax, TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) /////////////////////////////////////////////////////////////////////////// { int VI_RepeatCnt=0; TypeLength VL_LengthAll=0; TypeLength VL_LengthNow=0; if(AI_RepeatMax<1) // 유효하지 않은 최대 반복 횟수의 경우, 무한대 반복 허용 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_NoPermit ( APC_Origin+VL_LengthAll, AL_Length-VL_LengthAll, ARA_SearchArray ); /////////////////////////////////////////////////////////////// if(VL_LengthNow<1) { if(VI_RepeatCnt>=AI_RepeatMin) return VL_LengthAll; else return 0; }/* if(VL_LengthNow<1)*/ ++VI_RepeatCnt; } while(true); } else // AI_RepeatMax>=1 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_NoPermit ( APC_Origin+VL_LengthAll, AL_Length-VL_LengthAll, ARA_SearchArray ); /////////////////////////////////////////////////////////////// if(VL_LengthNow<1) { // 현재 VI_RepeatCnt<=AI_RepeatMax 상태다. if(VI_RepeatCnt AI_RepeatMax) return 0; } else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop { if(++VI_RepeatCnt>=AI_RepeatMax) return VL_LengthAll; }/* else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop*/ } while(true); }/* else // AI_RepeatMax>=1*/ return VL_LengthAll; }/* template static TypeLength GetLength_Repeat_NoPermit ( int AI_RepeatMin , int AI_RepeatMax , TypeCharC* APC_Origin , TypeLength AL_Length, const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) /////////////////////////////////////////////////////////////////////////*/ template static TypeLength GetLength_Repeat_NoPermit( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) { return ZtCMainChars::GetLength_Repeat_NoPermit( AI_RepeatMin, AI_RepeatMax, AR_CChars.data(), AR_CChars.size(), ARA_SearchArray, AE_ESearchMax); }/* template static TypeLength GetLength_Repeat_NoPermit( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) */ template static TypeLength GetLength_Repeat_NoPermitRange ( int AI_RepeatMin, int AI_RepeatMax, TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) //////////////////////////////////////////////////////////////////////////////// { int VI_RepeatCnt=0; TypeLength VL_LengthAll=0; TypeLength VL_LengthNow=0; if(AI_RepeatMax<1) // 유효하지 않은 최대 반복 횟수의 경우, 무한대 반복 허용 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_NoPermitRange ( APC_Origin+VL_LengthAll, AL_Length-VL_LengthAll, ARA_SearchArray ); //////////////////////////////////////////////////////////////////// if(VL_LengthNow<1) { if(VI_RepeatCnt>=AI_RepeatMin) return VL_LengthAll; else return 0; }/* if(VL_LengthNow<1)*/ ++VI_RepeatCnt; } while(true); } else // AI_RepeatMax>=1 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_NoPermitRange ( APC_Origin+VL_LengthAll, AL_Length-VL_LengthAll, ARA_SearchArray ); //////////////////////////////////////////////////////////////////// if(VL_LengthNow<1) { // 현재 VI_RepeatCnt<=AI_RepeatMax 상태다. if(VI_RepeatCnt AI_RepeatMax) return 0; } else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop { if(++VI_RepeatCnt>=AI_RepeatMax) return VL_LengthAll; }/* else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop*/ } while(true); }/* else // AI_RepeatMax>=1*/ return VL_LengthAll; }/* template static TypeLength GetLength_Repeat_NoPermitRange ( int AI_RepeatMin, int AI_RepeatMax, TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) //////////////////////////////////////////////////////////////////////////////*/ template static TypeLength GetLength_Repeat_NoPermitRange( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) { return ZtCMainChars::GetLength_Repeat_NoPermitRange( AI_RepeatMin, AI_RepeatMax, AR_CChars.data(), AR_CChars.size(), ARA_SearchArray, AE_ESearchMax); }/* template static TypeLength GetLength_Repeat_NoPermitRange( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) */ template static TypeLength GetLength_Repeat_NoPermitChar ( int AI_RepeatMin, int AI_RepeatMax, TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) /*###########################################################################*/ { int VI_RepeatCnt=0; TypeLength VL_LengthAll=0; TypeLength VL_LengthNow=0; if(AI_RepeatMax<1) // 유효하지 않은 최대 반복횟수의 경우, 무한대 반복 허용 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_NoPermitChar2 ( APC_Origin+VL_LengthAll, AL_Length-VL_LengthAll, ARA_SearchArray ); //////////////////////////////////////////////////////////////////// if(VL_LengthNow<1) { if(VI_RepeatCnt>=AI_RepeatMin) return VL_LengthAll; else return 0; }/* if(VL_LengthNow<1)*/ ++VI_RepeatCnt; } while(true); } else // AI_RepeatMax>=1 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_NoPermitChar2 ( APC_Origin+VL_LengthAll, AL_Length-VL_LengthAll, ARA_SearchArray ); //////////////////////////////////////////////////////////////////// if(VL_LengthNow<1) { // 현재 VI_RepeatCnt<=AI_RepeatMax 상태다. if(VI_RepeatCnt AI_RepeatMax) return 0; } else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop { if(++VI_RepeatCnt>=AI_RepeatMax) return VL_LengthAll; }/* else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop*/ } while(true); }/* else // AI_RepeatMax>=1*/ return VL_LengthAll; }/* template static TypeLength GetLength_Repeat_NoPermitChar ( int AI_RepeatMin, int AI_RepeatMax, TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) #############################################################################*/ template static TypeLength GetLength_Repeat_NoPermitChar( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) { return ZtCMainChars::GetLength_Repeat_NoPermitChar( AI_RepeatMin, AI_RepeatMax, AR_CChars.data(), AR_CChars.size(), ARA_SearchArray, AE_ESearchMax); }/* template static TypeLength GetLength_Repeat_NoPermitChar( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) */ template static TypeLength GetLength_Repeat_NoPermitCharRange ( int AI_RepeatMin, int AI_RepeatMax, TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) /*################################################################################*/ { int VI_RepeatCnt=0; TypeLength VL_LengthAll=0; TypeLength VL_LengthNow=0; if(AI_RepeatMax<1) // 유효하지 않은 최대 반복 횟수의 경우, 무한대 반복 허용 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_NoPermitCharRange2 ( APC_Origin+VL_LengthAll, AL_Length-VL_LengthAll, ARA_SearchArray ); ///////////////////////////////////////////////////////////////////////// if(VL_LengthNow<1) { if(VI_RepeatCnt>=AI_RepeatMin) return VL_LengthAll; else return 0; }/* if(VL_LengthNow<1)*/ ++VI_RepeatCnt; } while(true); } else // AI_RepeatMax>=1 { do ////// { VL_LengthAll += VL_LengthNow = ZtCMainChars::GetLength_NoPermitCharRange2 ( APC_Origin+VL_LengthAll, AL_Length-VL_LengthAll, ARA_SearchArray ); ///////////////////////////////////////////////////////////////////////// if(VL_LengthNow<1) { // 현재 VI_RepeatCnt<=AI_RepeatMax 상태다. if(VI_RepeatCnt AI_RepeatMax) return 0; } else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop { if(++VI_RepeatCnt>=AI_RepeatMax) return VL_LengthAll; }/* else // AE_ESearchMax==ZNsEnum::ZESearchMax_Stop*/ } while(true); }/* else // AI_RepeatMax>=1*/ return VL_LengthAll; }/* template static TypeLength GetLength_Repeat_NoPermitCharRange ( int AI_RepeatMin, int AI_RepeatMax, TypeCharC* APC_Origin , TypeLength AL_Length , const TStringArray& ARA_SearchArray , ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ) ##################################################################################*/ template static TypeLength GetLength_Repeat_NoPermitCharRange( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) { return ZtCMainChars::GetLength_Repeat_NoPermitCharRange( AI_RepeatMin, AI_RepeatMax, AR_CChars.data(), AR_CChars.size(), ARA_SearchArray, AE_ESearchMax); }/* template static TypeLength GetLength_Repeat_NoPermitCharRange( int AI_RepeatMin, int AI_RepeatMax, const TTyChars& AR_CChars, const TStringArray& ARA_SearchArray, ZNsEnum::ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over) */ public: };/* template< typename TTypeChars=ZNsType::ZtCTypeChars > class ZtCMainChars //////////////////////////////////////*/ namespace ZNsInterface { template class ZtISearchCCharsEmpty { public: typedef typename TCChars::TypeChar TypeChar ; typedef typename TCChars::TypeLength TypeLength; public: typedef ZtISearchCCharsEmpty ZCNowObj ; typedef ZtISearchCCharsEmpty ZCNextObj; typedef ZtISearchCCharsEmpty ZCNodeObj; public: enum{EBoolNextObj=0}; public: int GetLength (const TypeChar*, TypeLength) const{return 0;} int GetRepeatCntMin () const{return 0;} int GetRepeatCntMax () const{return 0;} int GetSearchCharMin() const{return 0;} int GetSearchCharMax() const{return 0;} int GetSearchSumMin () const{return 0;} int GetSearchSumMax () const{return 0;} ZNsEnum::ZERegFlag GetERegFlag () const{return ZNsEnum::ZERegFlag_Nothing;} ZNsEnum::ZESearchMax GetESearchMax() const{return ZNsEnum::ZESearchMax_Over ;} ZtISearchCCharsEmpty& GetNowObj (){return *this;} ZtISearchCCharsEmpty& GetNextObj(){return *this;} ZtISearchCCharsEmpty& GetSubObj (){return *this;} const ZtISearchCCharsEmpty& GetNowObj ()const{return *this;} const ZtISearchCCharsEmpty& GetNextObj()const{return *this;} const ZtISearchCCharsEmpty& GetSubObj ()const{return *this;} public: };/* template class ZtISearchCCharsEmpty*/ }/* namespace ZNsInterface*/ #define _ISEARCH_CCHARS_EMPTY_ ZNsIFace::ZtISearchCCharsEmpty template< typename TCharsArr , typename TNextObj =_ISEARCH_CCHARS_EMPTY_, // ZNsIFace::ZtISearchCCharsEmpty, ZtCSearchCChars<>, etc bool TBoolNextObj=false > class ZtCSearchCChars : public TNextObj { public : enum{EBoolNextObj=(int)TBoolNextObj} ; public : typedef ZtCSearchCChars ZCSearchCChars; typedef ZtCSearchCChars ZCNowObj ; // cf) std::NsTmplChain::CTmplChain_T<> typedef TNextObj ZCNextObj ; public : typedef TCharsArr ZCCharsArr ; typedef ZNsEnum::ZERegFlag ZERegFlag ; typedef ZNsEnum::ZESearchMax ZESearchMax ; public : typedef typename TCharsArr::TypeData ZCChars ; typedef typename ZCChars ::ZCTypeChars ZCTypeChars; typedef typename ZCChars ::TypeChar TypeChar ; typedef typename ZCChars ::TypeCharC TypeCharC ; typedef typename ZCChars ::TypeLength TypeLength ; typedef ZtCMainChars ZCMainChars; protected: int mi_RepeatCntMin ; int mi_RepeatCntMax ; int mi_SearchCharMin; // enum ZERegErr 의 주석을 참고. int mi_SearchCharMax; int mi_SearchSumMin ; // enum ZERegErr 의 주석을 참고. int mi_SearchSumMax ; ZERegFlag me_ERegFlag ; ZESearchMax me_ESearchMax; ZCCharsArr mo_CCharsArr ; /*protected:*/ protected: /*/////////////////////////////////////////////////////////////////////////////// ■ 아래 2 개 멤버 변수는 ZtCSearchCChars<> 의 컨테이너에서만 의미가 있다. int mi_SearchSumMin; int mi_SearchSumMax; 즉 ZtCSearchCChars<> 컨테이너의 각 원소를 순회하면서, 찾은 길이를 계속 더하게 되는데, 이때 이 더하는 누적값의 허용 범위를 지정하는 것이다. -- 2011-10-02 18:52:00 ///////////////////////////////////////////////////////////////////////////////*/ /*protected:*/ public : ZtCSearchCChars() { Init(); }/* ZtCSearchCChars()*/ ZtCSearchCChars(int AI_RepeatCntMin , int AI_RepeatCntMax , int AI_SearchCharMin, int AI_SearchCharMax, int AI_SearchSumMin , int AI_SearchSumMax , ZERegFlag AE_ERegFlag, ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over /*//////////*/ ) { Init(AI_RepeatCntMin, AI_RepeatCntMax, AI_SearchCharMin, AI_SearchCharMax, AI_SearchSumMin, AI_SearchSumMax, AE_ERegFlag, AE_ESearchMax); }/* ZtCSearchCChars(int AI_RepeatCntMin , int AI_RepeatCntMax , int AI_SearchCharMin, int AI_SearchCharMax, int AI_SearchSumMin , int AI_SearchSumMax , ZERegFlag AE_ERegFlag, ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over ////////////// ) */ void Init() { mi_RepeatCntMin =0; mi_RepeatCntMax =0; mi_SearchCharMin=0; mi_SearchCharMax=0; mi_SearchSumMin =0; mi_SearchSumMax =0; me_ERegFlag =ZNsEnum::ZERegFlag_Nothing; me_ESearchMax =ZNsEnum::ZESearchMax_Over ; }/* void Init()*/ void Init ( int AI_RepeatCntMin , int AI_RepeatCntMax , int AI_SearchCharMin, int AI_SearchCharMax, int AI_SearchSumMin , int AI_SearchSumMax , ZERegFlag AE_ERegFlag, ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over /*///////*/ ) { mi_RepeatCntMin =AI_RepeatCntMin ; mi_RepeatCntMax =AI_RepeatCntMax ; mi_SearchCharMin=AI_SearchCharMin; mi_SearchCharMax=AI_SearchCharMax; mi_SearchSumMin =AI_SearchSumMin ; mi_SearchSumMax =AI_SearchSumMax ; me_ERegFlag =AE_ERegFlag ; me_ESearchMax =AE_ESearchMax ; }/* void Init ( int AI_RepeatCntMin , int AI_RepeatCntMax , int AI_SearchCharMin, int AI_SearchCharMax, int AI_SearchSumMin , int AI_SearchSumMax , ZERegFlag AE_ERegFlag, ZESearchMax AE_ESearchMax=ZNsEnum::ZESearchMax_Over /////////// ) */ ZtCSearchCChars& GetNowObj() {return *this;} const ZtCSearchCChars& GetNowObj() const{return *this;} ZCNextObj& GetNextObj() {return static_cast< ZCNextObj&>(*this);} const ZCNextObj& GetNextObj() const{return static_cast(*this);} ZCCharsArr& GetCCharsArr() {return mo_CCharsArr;} const ZCCharsArr& GetCCharsArr() const{return mo_CCharsArr;} int GetRepeatCntMin () const{return mi_RepeatCntMin ;} int GetRepeatCntMax () const{return mi_RepeatCntMax ;} int GetSearchCharMin() const{return mi_SearchCharMin;} int GetSearchCharMax() const{return mi_SearchCharMax;} int GetSearchSumMin () const{return mi_SearchSumMin ;} int GetSearchSumMax () const{return mi_SearchSumMax ;} ZERegFlag GetERegFlag () const{return me_ERegFlag ;} ZESearchMax GetESearchMax() const{return me_ESearchMax;} TypeLength GetLength(TypeCharC* APC_Origin, TypeLength AL_Length) const { switch(me_ERegFlag) { case ZNsEnum::ZERegFlag_Permit : return ZCMainChars::GetLength_Repeat_Permit (mi_RepeatCntMin, mi_RepeatCntMax, APC_Origin, AL_Length, mo_CCharsArr, me_ESearchMax); case ZNsEnum::ZERegFlag_PermitRange : return ZCMainChars::GetLength_Repeat_PermitRange (mi_RepeatCntMin, mi_RepeatCntMax, APC_Origin, AL_Length, mo_CCharsArr, me_ESearchMax); case ZNsEnum::ZERegFlag_PermitChar : return ZCMainChars::GetLength_Repeat_PermitChar (mi_RepeatCntMin, mi_RepeatCntMax, APC_Origin, AL_Length, mo_CCharsArr, me_ESearchMax); case ZNsEnum::ZERegFlag_PermitCharRange : return ZCMainChars::GetLength_Repeat_PermitCharRange (mi_RepeatCntMin, mi_RepeatCntMax, APC_Origin, AL_Length, mo_CCharsArr, me_ESearchMax); case ZNsEnum::ZERegFlag_NoPermit : return ZCMainChars::GetLength_Repeat_NoPermit (mi_RepeatCntMin, mi_RepeatCntMax, APC_Origin, AL_Length, mo_CCharsArr, me_ESearchMax); case ZNsEnum::ZERegFlag_NoPermitRange : return ZCMainChars::GetLength_Repeat_NoPermitRange (mi_RepeatCntMin, mi_RepeatCntMax, APC_Origin, AL_Length, mo_CCharsArr, me_ESearchMax); case ZNsEnum::ZERegFlag_NoPermitChar : return ZCMainChars::GetLength_Repeat_NoPermitChar (mi_RepeatCntMin, mi_RepeatCntMax, APC_Origin, AL_Length, mo_CCharsArr, me_ESearchMax); case ZNsEnum::ZERegFlag_NoPermitCharRange : return ZCMainChars::GetLength_Repeat_NoPermitCharRange(mi_RepeatCntMin, mi_RepeatCntMax, APC_Origin, AL_Length, mo_CCharsArr, me_ESearchMax); case ZNsEnum::ZERegFlag_Find : return ZCMainChars::GetLength_Repeat_Find (mi_RepeatCntMin, mi_RepeatCntMax, APC_Origin, AL_Length, mo_CCharsArr, me_ESearchMax); case ZNsEnum::ZERegFlag_FindChar : return ZCMainChars::GetLength_Repeat_FindChar (mi_RepeatCntMin, mi_RepeatCntMax, APC_Origin, AL_Length, mo_CCharsArr, me_ESearchMax); case ZNsEnum::ZERegFlag_FindSerial : return ZCMainChars::GetLength_Repeat_FindSerial (mi_RepeatCntMin, mi_RepeatCntMax, APC_Origin, AL_Length, mo_CCharsArr, me_ESearchMax); case ZNsEnum::ZERegFlag_FindSerialChar : return ZCMainChars::GetLength_Repeat_FindSerialChar (mi_RepeatCntMin, mi_RepeatCntMax, APC_Origin, AL_Length, mo_CCharsArr, me_ESearchMax); case ZNsEnum::ZERegFlag_FindEscape : return ZCMainChars::GetLength_Repeat_FindEscape (mi_RepeatCntMin, mi_RepeatCntMax, APC_Origin, AL_Length, mo_CCharsArr, me_ESearchMax); case ZNsEnum::ZERegFlag_StartFind : return ZCMainChars::GetLength_Repeat_StartFind (mi_RepeatCntMin, mi_RepeatCntMax, APC_Origin, AL_Length, mo_CCharsArr, me_ESearchMax); case ZNsEnum::ZERegFlag_StartFindChar : return ZCMainChars::GetLength_Repeat_StartFindChar (mi_RepeatCntMin, mi_RepeatCntMax, APC_Origin, AL_Length, mo_CCharsArr, me_ESearchMax); }/* switch(me_ERegFlag)*/ return 0; }/* TypeLength GetLength(TypeCharC* APC_Origin, TypeLength AL_Length) const*/ template TypeLength GetLength(const TCChars& AR_CChars) const { return GetLength(AR_CChars.data(), AR_CChars.size()); }/* template TypeLength GetLength(const TCChars& AR_CChars) const */ TypeLength GetLengthEx ( ZNsEnum::ZERegErr& ARRE_ZERegErr, TypeCharC* APC_Origin , TypeLength AL_Length ) const /*##################*/ { TypeLength VL_Length = GetLength(APC_Origin, AL_Length); ARRE_ZERegErr=ZNsEnum::ZERegErr_None; const bool CB_IsTrue = ( VL_Length 0 && VL_Length>mi_SearchCharMax) ); if(CB_IsTrue) ARRE_ZERegErr=ZNsEnum::ZERegErr_CharCount; return VL_Length; }/* TypeLength GetLengthEx ( ZNsEnum::ZERegErr& ARRE_ZERegErr, TypeCharC* APC_Origin , TypeLength AL_Length ) const ////////////////////*/ template TypeLength GetLengthEx(ZNsEnum::ZERegErr& ARRE_ZERegErr, const TCChars& AR_CChars) const { return GetLengthEx(RR(ARRE_ZERegErr), AR_CChars.data(), AR_CChars.size()); }/* template TypeLength GetLengthEx(ZNsEnum::ZERegErr& ARRE_ZERegErr, const TCChars& AR_CChars) const */ template static TypeLength GetLengthByCSearchCCharsArr ( const TSearchCCharsArr& AR_CSearchCCharsArr , ZNsEnum::ZERegErr& ARRE_ZERegErr , TypeCharC* APC_Origin , TypeLength AL_Length ) /*#################################################*/ { typedef typename TSearchCCharsArr::iterator iterator; typedef typename TSearchCCharsArr::TypeData TypeData; const iterator VO_iterator(AR_CSearchCCharsArr.begin()); TypeLength VL_SearchSum=0; TypeLength VL_SearchNow=0; int VI_ArrSize =AR_CSearchCCharsArr.size(); if(VI_ArrSize<1) return 0; for(int i=0; i0 && VL_SearchNow>VR_CSearchCChars.GetSearchCharMax())) { ARRE_ZERegErr=ZNsEnum::ZERegErr_CharCount; return 0; } if(VL_SearchSum0 && VL_SearchSum>VR_CSearchCChars.GetSearchSumMax ())) { ARRE_ZERegErr=ZNsEnum::ZERegErr_CharSum ; return 0; }/* if(VL_SearchSum0 && VL_SearchSum>VR_CSearchCChars.GetSearchSumMax ()))*/ /*/////////////////////////////////////////////////////// if(AL_Length<=VL_SearchSum) return VL_SearchSum; ■ 위 코드를 주석으로 막는다. 다음 조건에 따라서, 찾는 문자열이 길이가 0 인 것이 정상일 수도 있는 것이다. -- 2011-08-05 16:30:00 ///////////////////////////////////////////////////////*/ AR_CSearchCCharsArr.MoveNextIter(VO_iterator); }/* for(int i=0; i static TypeLength GetLengthByCSearchCCharsArr ( const TSearchCCharsArr& AR_CSearchCCharsArr , ZNsEnum::ZERegErr& ARRE_ZERegErr , TypeCharC* APC_Origin , TypeLength AL_Length ) ///////////////////////////////////////////////////*/ template static TypeLength GetLengthByCSearchCCharsArr ( const TSearchCCharsArr& AR_CSearchCCharsArr , ZNsEnum::ZERegErr& ARRE_ZERegErr , const TCChars& AR_CChars ) /*#################################################*/ { return GetLengthByCSearchCCharsArr( AR_CSearchCCharsArr, RR(ARRE_ZERegErr), AR_CChars.data(), AR_CChars.size() ); }/* template static TypeLength GetLengthByCSearchCCharsArr ( const TSearchCCharsArr& AR_CSearchCCharsArr , ZNsEnum::ZERegErr& ARRE_ZERegErr , const TCChars& AR_CChars ) ///////////////////////////////////////////////////*/ public: };/* template< typename TCharsArr , typename TNextObj =_ISEARCH_CCHARS_EMPTY_, // ZNsIFace::ZtISearchCCharsEmpty, ZtCSearchCChars<>, etc bool TBoolNextObj=false > class ZtCSearchCChars /////////////////////////////////*/ template< typename TCharsArr , typename TNextObj =_ISEARCH_CCHARS_EMPTY_, // ZNsIFace::ZtISearchCCharsEmpty, ZtCSearchCChars<>, etc typename TSubObj =_ISEARCH_CCHARS_EMPTY_, // ZNsIFace::ZtISearchCCharsEmpty, ZtCSearchCChars<>, etc bool TBoolNextObj=false > class ZtCSearchCCharsEx : public ZtCSearchCChars { public : enum{EBoolNextObj=(int)TBoolNextObj}; public : typedef ZtCSearchCChars ZCSearchCChars; public : typedef ZCSearchCChars ZCNowObj ; typedef TNextObj ZCNextObj; typedef TSubObj CSubObj ; private: CSubObj mo_CSubObj; public : /***/ CSubObj& GetCSubObj() {return mo_CSubObj;} const CSubObj& GetCSubObj()const{return mo_CSubObj;} public : };/* template< typename TCharsArr , typename TNextObj =_ISEARCH_CCHARS_EMPTY_, // ZNsIFace::ZtISearchCCharsEmpty, ZtCSearchCChars<>, etc typename TSubObj =_ISEARCH_CCHARS_EMPTY_, // ZNsIFace::ZtISearchCCharsEmpty, ZtCSearchCChars<>, etc bool TBoolNextObj=false > class ZtCSearchCCharsEx */ #undef _ISEARCH_CCHARS_EMPTY_ // ZNsIFace::ZtISearchCCharsEmpty namespace ZNsType { template< ZTypLength TIntCode , // 'A' 나 L'가' 등의 구체적인 문자가 온다. typename TTypeChar=char, typename TCharCInt=char // TTypeChar 를 표현할 수 있는 정수 자료형이다. > class ZtCTypeCharChain { public: typedef TTypeChar TypeChar; typedef TCharCInt TypeCInt; public: typedef const TTypeChar TypeCharC; public: enum{ZETypeCharTmplChain=ZNsEnum::ZETypeCharTmplChain_Char}; public: static TypeCInt GetCInt(){return (TypeCInt)TIntCode;} static TypeChar GetChar(){return (TypeChar)TIntCode;} public: static bool DoHave(TypeChar AC_Char){return AC_Char==(TypeChar)TIntCode;} public: };/* template< ZTypLength TIntCode , // 'A' 나 L'가' 등의 구체적인 문자가 온다. typename TTypeChar=char, typename TCharCInt =char // TTypeChar 를 표현할 수 있는 정수 자료형이다. > class ZtCTypeCharChain */ // ZtCTypeChar2Chain<> 은 2 개 문자의 범위를 나타낸다. template< ZTypLength TIntCode1 , // 'A' 나 L'가' 등의 구체적인 문자가 온다. ZTypLength TIntCode2 , // 'A' 나 L'가' 등의 구체적인 문자가 온다. typename TTypeChar=char, typename TCharCInt=char // TTypeChar 를 표현할 수 있는 정수 자료형이다. > class ZtCTypeChar2Chain { public: typedef TTypeChar TypeChar; typedef TCharCInt TypeCInt; public: typedef const TTypeChar TypeCharC; public: enum{ZETypeCharTmplChain=ZNsEnum::ZETypeCharTmplChain_Char2}; public: static TypeCInt GetCInt1(){return (TypeCInt)TIntCode1;} static TypeCInt GetCInt2(){return (TypeCInt)TIntCode2;} static TypeChar GetChar1(){return (TypeChar)TIntCode1;} static TypeChar GetChar2(){return (TypeChar)TIntCode2;} public: static bool DoHave(TypeChar AC_Char) { return AC_Char>=(TypeChar)TIntCode1 && AC_Char<=(TypeChar)TIntCode2; }/* static bool DoHave(TypeChar AC_Char)*/ public: };/* template< ZTypLength TIntCode1 , // 'A' 나 L'가' 등의 구체적인 문자가 온다. ZTypLength TIntCode2 , // 'A' 나 L'가' 등의 구체적인 문자가 온다. typename TTypeChar=char, typename TCharCInt=char // TTypeChar 를 표현할 수 있는 정수 자료형이다. > class ZtCTypeChar2Chain */ template< typename TTypeChar=char, typename TCharCInt=char // TTypeChar 를 표현할 수 있는 정수 자료형이다. > class ZtCTypeCharChainEach { public: typedef ZtCTypeCharChain CTypeCharTmplChainOfA; typedef ZtCTypeCharChain CTypeCharTmplChainOfB; typedef ZtCTypeCharChain CTypeCharTmplChainOfC; typedef ZtCTypeCharChain CTypeCharTmplChainOfD; typedef ZtCTypeCharChain CTypeCharTmplChainOfE; typedef ZtCTypeCharChain CTypeCharTmplChainOfF; typedef ZtCTypeCharChain CTypeCharTmplChainOfG; typedef ZtCTypeCharChain CTypeCharTmplChainOfH; typedef ZtCTypeCharChain CTypeCharTmplChainOfI; typedef ZtCTypeCharChain CTypeCharTmplChainOfJ; typedef ZtCTypeCharChain CTypeCharTmplChainOfK; typedef ZtCTypeCharChain CTypeCharTmplChainOfL; typedef ZtCTypeCharChain CTypeCharTmplChainOfM; typedef ZtCTypeCharChain CTypeCharTmplChainOfN; typedef ZtCTypeCharChain CTypeCharTmplChainOfO; typedef ZtCTypeCharChain CTypeCharTmplChainOfP; typedef ZtCTypeCharChain CTypeCharTmplChainOfQ; typedef ZtCTypeCharChain CTypeCharTmplChainOfR; typedef ZtCTypeCharChain CTypeCharTmplChainOfS; typedef ZtCTypeCharChain CTypeCharTmplChainOfT; typedef ZtCTypeCharChain CTypeCharTmplChainOfU; typedef ZtCTypeCharChain CTypeCharTmplChainOfV; typedef ZtCTypeCharChain CTypeCharTmplChainOfW; typedef ZtCTypeCharChain CTypeCharTmplChainOfX; typedef ZtCTypeCharChain CTypeCharTmplChainOfY; typedef ZtCTypeCharChain CTypeCharTmplChainOfZ; typedef ZtCTypeCharChain CTypeCharTmplChainOfa; typedef ZtCTypeCharChain CTypeCharTmplChainOfb; typedef ZtCTypeCharChain CTypeCharTmplChainOfc; typedef ZtCTypeCharChain CTypeCharTmplChainOfd; typedef ZtCTypeCharChain CTypeCharTmplChainOfe; typedef ZtCTypeCharChain CTypeCharTmplChainOff; typedef ZtCTypeCharChain CTypeCharTmplChainOfg; typedef ZtCTypeCharChain CTypeCharTmplChainOfh; typedef ZtCTypeCharChain CTypeCharTmplChainOfi; typedef ZtCTypeCharChain CTypeCharTmplChainOfj; typedef ZtCTypeCharChain CTypeCharTmplChainOfk; typedef ZtCTypeCharChain CTypeCharTmplChainOfl; typedef ZtCTypeCharChain CTypeCharTmplChainOfm; typedef ZtCTypeCharChain CTypeCharTmplChainOfn; typedef ZtCTypeCharChain CTypeCharTmplChainOfo; typedef ZtCTypeCharChain CTypeCharTmplChainOfp; typedef ZtCTypeCharChain CTypeCharTmplChainOfq; typedef ZtCTypeCharChain CTypeCharTmplChainOfr; typedef ZtCTypeCharChain CTypeCharTmplChainOfs; typedef ZtCTypeCharChain CTypeCharTmplChainOft; typedef ZtCTypeCharChain CTypeCharTmplChainOfu; typedef ZtCTypeCharChain CTypeCharTmplChainOfv; typedef ZtCTypeCharChain CTypeCharTmplChainOfw; typedef ZtCTypeCharChain CTypeCharTmplChainOfx; typedef ZtCTypeCharChain CTypeCharTmplChainOfy; typedef ZtCTypeCharChain CTypeCharTmplChainOfz; typedef ZtCTypeCharChain CTypeCharTmplChainOf0; typedef ZtCTypeCharChain CTypeCharTmplChainOf1; typedef ZtCTypeCharChain CTypeCharTmplChainOf2; typedef ZtCTypeCharChain CTypeCharTmplChainOf3; typedef ZtCTypeCharChain CTypeCharTmplChainOf4; typedef ZtCTypeCharChain CTypeCharTmplChainOf5; typedef ZtCTypeCharChain CTypeCharTmplChainOf6; typedef ZtCTypeCharChain CTypeCharTmplChainOf7; typedef ZtCTypeCharChain CTypeCharTmplChainOf8; typedef ZtCTypeCharChain CTypeCharTmplChainOf9; typedef ZtCTypeCharChain CTypeCharTmplChainOfSpace ; // space bar typedef ZtCTypeCharChain CTypeCharTmplChainOfTab ; // horizontal tab typedef ZtCTypeCharChain CTypeCharTmplChainOfLF ; // line feed(개행) typedef ZtCTypeCharChain CTypeCharTmplChainOfCR ; // carriage return(복귀) typedef ZtCTypeCharChain CTypeCharTmplChainOfGraAcc ; // grave accent typedef ZtCTypeCharChain CTypeCharTmplChainOfTilde ; // tilde, swung dash typedef ZtCTypeCharChain CTypeCharTmplChainOfExcMark ; // exclamation mark typedef ZtCTypeCharChain CTypeCharTmplChainOfAt ; // at sign typedef ZtCTypeCharChain CTypeCharTmplChainOfHash ; // number sign/pound/hash typedef ZtCTypeCharChain CTypeCharTmplChainOfDollar ; // dollar sign typedef ZtCTypeCharChain CTypeCharTmplChainOfPercent ; typedef ZtCTypeCharChain CTypeCharTmplChainOfCaret ; // caret typedef ZtCTypeCharChain CTypeCharTmplChainOfAmper ; // ampersand typedef ZtCTypeCharChain CTypeCharTmplChainOfAster ; // asterisk typedef ZtCTypeCharChain CTypeCharTmplChainOfRoundB ; // round brackets, open brackets, brackets (UK), or parentheses typedef ZtCTypeCharChain CTypeCharTmplChainOfRoundB2 ; typedef ZtCTypeCharChain CTypeCharTmplChainOfSquareB ; // square brackets, closed brackets, or brackets (US) typedef ZtCTypeCharChain CTypeCharTmplChainOfSquareB2 ; typedef ZtCTypeCharChain' ),TTypeChar,TCharCInt> CTypeCharTmplChainOfMoreThan ; // inequality signs, brakets typedef ZtCTypeCharChain CTypeCharTmplChainOfLessThan ; // inequality signs, brakets typedef ZtCTypeCharChain CTypeCharTmplChainOfBrace ; // curly brackets, definite brackets, swirly brackets, curly braces, birdie brackets, Scottish brackets, squirrelly brackets, braces, gullwings, fancy brackets, or squiggly brackets typedef ZtCTypeCharChain CTypeCharTmplChainOfBrace2 ; typedef ZtCTypeCharChain CTypeCharTmplChainOfHyphen ; // hyphen typedef ZtCTypeCharChain CTypeCharTmplChainOfUnderSco ; // underscore, understrike, low line, low dash typedef ZtCTypeCharChain CTypeCharTmplChainOfPlus ; // plus sign typedef ZtCTypeCharChain CTypeCharTmplChainOfEquals ; // equality sign, equals sign typedef ZtCTypeCharChain CTypeCharTmplChainOfVertical ; // vertical bar typedef ZtCTypeCharChain CTypeCharTmplChainOfBackslash; // backslash, reverse solidus typedef ZtCTypeCharChain CTypeCharTmplChainOfSemiColon; typedef ZtCTypeCharChain CTypeCharTmplChainOfColon ; typedef ZtCTypeCharChain CTypeCharTmplChainOfApostrop ; // apostrophe typedef ZtCTypeCharChain CTypeCharTmplChainOfQuotation; // quotation mark typedef ZtCTypeCharChain CTypeCharTmplChainOfComma ; // comma typedef ZtCTypeCharChain CTypeCharTmplChainOfPeriod ; // period typedef ZtCTypeCharChain CTypeCharTmplChainOfQuestion ; // question mark typedef ZtCTypeCharChain CTypeCharTmplChainOfSlash ; // slash, solidus typedef ZtCTypeChar2Chain CTypeChar2TmplChainOfaz; typedef ZtCTypeChar2Chain CTypeChar2TmplChainOfAZ; typedef ZtCTypeChar2Chain CTypeChar2TmplChainOf09; public: };/* template< typename TTypeChar=char, typename TCharCInt=char // TTypeChar 를 표현할 수 있는 정수 자료형이다. > class ZtCTypeCharChainEach */ }/* namespace ZNsType*/ /*/////////////////////////////////////////////////////////// ■ typename TTypeCharChain 은 ZNsType::ZtCTypeCharChain<> ZNsType::ZtCTypeChar2Chain<> ZNsType::ZtCTypeCharChainEach<>::CTypeCharTmplChainOf~ ZNsType::ZtCTypeCharChainEach<>::CTypeChar2TmplChainOf~ 등이 될 수 있다. -- 2011-10-09 05:27:00 ///////////////////////////////////////////////////////////*/ template< typename TTypeCharChain, typename TNextCharChain, typename TNextCharChain2 > class ZtCCharChain ///////////////// { public: typedef TTypeCharChain TypeCharChain ; typedef TNextCharChain ZCNextObj ; typedef TNextCharChain2 ZCNextObj2; typedef typename TypeCharChain::TTypeChar TypeChar ; typedef typename TypeCharChain::TCharCInt TypeCInt ; public: typedef const TypeChar TypeCharC; public: enum{ENextObjNo =ZCNextObj ::ENextObjNo +1}; enum{ENextObjNo2 =ZCNextObj2::ENextObjNo2+1}; enum{EObjChainCnt =ZCNextObj ::EObjChainCnt+ZCNextObj2::EObjChainCnt+2}; enum{EBoolNextObj =1}; enum{EBoolNextObj2=1}; public: static bool DoHave(TypeChar AC_Char){return TypeCharChain::DoHave(AC_Char);} public: };/* template< typename TTypeCharChain, typename TNextCharChain, typename TNextCharChain2 > class ZtCCharChain ///////////////*/ template< typename TTypeCharChain, /////////////////////////////// typename TNextCharChain > class ZtCCharChain { public: typedef TTypeCharChain TypeCharChain ; typedef TNextCharChain ZCNextObj ; typedef TNextCharChain ZCNextObj2; // interface 호환을 위해서만 존재. typedef typename TypeCharChain::TTypeChar TypeChar ; typedef typename TypeCharChain::TCharCInt TypeCInt ; public: typedef const TypeChar TypeCharC; public: enum{ENextObjNo =ZCNextObj::ENextObjNo+1}; enum{ENextObjNo2 =0}; enum{EBoolNextObj =1}; enum{EBoolNextObj2=0}; enum{EObjChainCnt =ZCNextObj::EObjChainCnt+1}; public: static bool DoHave(TypeChar AC_Char){return TypeCharChain::DoHave(AC_Char);} public: };/* template< typename TTypeCharChain, ////////////////////////////////// typename TNextCharChain > class ZtCCharChain */ template< typename TTypeCharChain, //////////////////////////////// typename TNextCharChain2 > class ZtCCharChain { public: typedef TTypeCharChain TypeCharChain ; typedef TNextCharChain2 ZCNextObj ; // interface 호환을 위해서만 존재. typedef TNextCharChain2 ZCNextObj2; typedef typename TypeCharChain::TTypeChar TypeChar ; typedef typename TypeCharChain::TCharCInt TypeCInt ; public: typedef const TypeChar TypeCharC; public: enum{ENextObjNo =0}; enum{ENextObjNo2 =ZCNextObj2::ENextObjNo2+1}; enum{EBoolNextObj =0}; enum{EBoolNextObj2=1}; enum{EObjChainCnt =ZCNextObj2::EObjChainCnt+1}; public: static bool DoHave(TypeChar AC_Char){return TypeCharChain::DoHave(AC_Char);} public: };/* template< typename TTypeCharChain, /////////////////////////////////// typename TNextCharChain2 > class ZtCCharChain */ template class ZtCCharChain < TTypeCharChain, ZNsMain::ZCEmpty, ZNsMain::ZCEmpty > { public: typedef ZtCCharChain< ////////////////////////////// TTypeCharChain , ZNsMain::ZCEmpty, ZNsMain::ZCEmpty /*/////////*/ > CCharChain; //////////////////////// public: typedef TTypeCharChain TypeCharChain ; typedef CCharChain ZCNextObj ; // interface 호환을 위해서만 존재. typedef CCharChain ZCNextObj2; // interface 호환을 위해서만 존재. typedef typename TypeCharChain::TTypeChar TypeChar ; typedef typename TypeCharChain::TCharCInt TypeCInt ; public: typedef const TypeChar TypeCharC; public: enum{ENextObjNo =0}; enum{ENextObjNo2 =0}; enum{EBoolNextObj =0}; enum{EBoolNextObj2=0}; enum{EObjChainCnt =1}; public: static bool DoHave(TypeChar AC_Char){return TypeCharChain::DoHave(AC_Char);} public: };/* template class ZtCCharChain < TTypeCharChain, ZNsMain::ZCEmpty, ZNsMain::ZCEmpty > */ template< typename TTypeChars=ZNsType::ZtCTypeChars > class ZtCSearchCursor ///////////////////////////////////// { public : typedef TTypeChars ZCTypeChars; typedef ZtCMainChars ZCMainChars; typedef typename ZCTypeChars::ZCChars ZCChars ; typedef typename ZCTypeChars::TypeChar TypeChar ; typedef typename ZCTypeChars::TypeCharC TypeCharC ; typedef typename ZCTypeChars::TypeLength TypeLength ; private: TypeChar* mpc_OriginChar; TypeLength ml_OriginLen ; TypeLength ml_SearchPos ; TypeLength ml_SearchLen ; public : ZtCSearchCursor() { Init(); }/* ZtCSearchCursor()*/ void Init() { mpc_OriginChar=0; ml_OriginLen =0; ml_SearchPos =0; ml_SearchLen =0; }/* void Init()*/ void InitSearch() { ml_SearchPos =0; ml_SearchLen =0; }/* void InitSearch()*/ void InitOrigin(TypeChar* APC_Origin, TypeLength AL_Length) { mpc_OriginChar=APC_Origin; ml_OriginLen =AL_Length ; }/* void InitOrigin(TypeChar* APC_Origin, TypeLength AL_Length)*/ void InitOrigin(ZCChars& AR_CCharsOrigin) { mpc_OriginChar=AR_CCharsOrigin.data(); ml_OriginLen =AR_CCharsOrigin.size(); }/* void InitOrigin(ZCChars& AR_CCharsOrigin)*/ void InitOrigin(const ZCChars& AR_CCharsOrigin) { mpc_OriginChar=const_cast(AR_CCharsOrigin.data()); ml_OriginLen = AR_CCharsOrigin.size() ; }/* void InitOrigin(const ZCChars& AR_CCharsOrigin)*/ TypeChar* GetOriginData() { return mpc_OriginChar; }/* TypeChar* GetOriginData()*/ TypeCharC* GetOriginData() const { return mpc_OriginChar; }/* TypeCharC* GetOriginData() const*/ TypeLength GetOriginLen() const{return ml_OriginLen ;} TypeLength GetRemainLen() const{return ml_OriginLen-ml_SearchPos;} void AddSearchPos() { ml_SearchPos+=ml_SearchLen; }/* void AddSearchPos()*/ void AddSearchPos(TypeLength AL_AddSearchPos) { ml_SearchPos += AL_AddSearchPos ; }/* void AddSearchPos(TypeLength AL_AddSearchPos)*/ void AddInitSearchPos() { ml_SearchPos+=ml_SearchLen; ml_SearchLen=0; }/* void AddInitSearchPos()*/ TypeLength GetSearchLen() const{return ml_SearchLen;} TypeLength GetSearchPos() const{return ml_SearchPos;} void SetSearchLen(TypeLength AL_SearchLen) { if(AL_SearchLen>=0) ml_SearchLen=AL_SearchLen; }/* void SetSearchLen(TypeLength AL_SearchLen)*/ void SetSearchPos(TypeLength AL_SearchPos) { if(AL_SearchPos>=0) ml_SearchPos=AL_SearchPos; }/* void SetSearchPos(TypeLength AL_SearchPos)*/ void SetSearchPos() { ml_SearchPos=ml_SearchLen; }/* void SetSearchPos()*/ bool DoStart(TypeCharC* APC_Search, TypeLength AL_Length) { return ZCMainChars::DoStart( mpc_OriginChar+ml_SearchPos, APC_Search, ml_OriginLen-ml_SearchPos, AL_Length); }/* bool DoStart(TypeCharC* APC_Search, TypeLength AL_Length)*/ template bool DoStart(const TCChars& AR_CChars) { return DoStart(AR_CChars.data(), AR_CChars.size()); }/* template bool DoStart(const TCChars& AR_CChars) */ TypeLength FindPos(TypeCharC* APC_Search,TypeLength AL_Length) { return ZCMainChars::FindPos( mpc_OriginChar, APC_Search, ml_OriginLen, AL_Length, ml_SearchPos); }/* TypeLength FindPos(TypeCharC* APC_Search,TypeLength AL_Length)*/ template TypeLength FindPos(const TCChars& AR_CChars) { return FindPos(AR_CChars.data(), AR_CChars.size()); }/* template TypeLength FindPos(const TCChars& AR_CChars) */ TypeLength AddSearchByFind(TypeCharC* APC_Search, TypeLength AL_Length) { // APC_Search 을 찾았으면, 그 이전까지의 길이를 리턴한다. TypeLength VL_FindPos = FindPos(APC_Search, AL_Length); if(VL_FindPos<0) return -1; return ml_SearchLen = VL_FindPos-ml_SearchPos; }/* TypeLength AddSearchByFind(TypeCharC* APC_Search, TypeLength AL_Length)*/ template bool AddSearchByFind(const TCChars& AR_CChars) { return AddSearchByFind(AR_CChars.data(), AR_CChars.size()); }/* template bool AddSearchByFind(const TCChars& AR_CChars) */ template TypeLength AddSearchByCSearchCChars(const TSearchCChars& AR_CSearchCChars) { return ml_SearchLen += AR_CSearchCChars.GetLength ( mpc_OriginChar+ml_SearchPos, ml_OriginLen-ml_SearchPos ); }/* template TypeLength AddSearchByCSearchCChars(const TSearchCChars& AR_CSearchCChars) */ template TypeLength AddSearchByTmplChain ( TChainStack& AR_CStackOfTmplChain, const TTmplChain& AR_CTmplChain , ZNsEnum::ZERegErr& ARRE_ZERegErr ) { // TChainStack 은 ZNsInterface::ZtCStackOfTmplChain<> 의 interface 를 갖는다. ml_SearchLen += GetLengthByTmplChain( RR(AR_CStackOfTmplChain), AR_CTmplChain, RR(ARRE_ZERegErr)); return (ARRE_ZERegErr==ZNsEnum::ZERegErr_None) ? ml_SearchLen : 0 ; }/* template TypeLength AddSearchByTmplChain ( TChainStack& AR_CStackOfTmplChain, const TTmplChain& AR_CTmplChain , ZNsEnum::ZERegErr& ARRE_ZERegErr ) /////////////////////////////////////////////////*/ template TypeLength AddSearchByTmplChain(TTmplChain& AR_CTmplChain, ZNsEnum::ZERegErr& ARRE_ZERegErr) { ZNsInterface::ZtCStackOfTmplChain VO_CStackOfTmplChain; return AddSearchByTmplChain(VO_CStackOfTmplChain, AR_CTmplChain, RR(ARRE_ZERegErr)); }/* template TypeLength AddSearchByTmplChain(TTmplChain& AR_CTmplChain, ZNsEnum::ZERegErr& ARRE_ZERegErr) */ template TypeLength AddSearchByTmplTreeChain ( TChainStack& AR_CStackOfTmplChain, const TTmplTreeChain& AR_CTmplChain , ZNsEnum::ZERegErr& ARRE_ZERegErr ) { // TChainStack 은 ZNsInterface::ZtCStackOfTmplChain<> 의 interface 를 갖는다. ml_SearchLen += GetLengthByTmplTreeChain( RR(AR_CStackOfTmplChain), AR_CTmplChain, RR(ARRE_ZERegErr)); return (ARRE_ZERegErr==ZNsEnum::ZERegErr_None) ? ml_SearchLen : 0 ; }/* template TypeLength AddSearchByTmplTreeChain ( TChainStack& AR_CStackOfTmplChain, const TTmplTreeChain& AR_CTmplChain , ZNsEnum::ZERegErr& ARRE_ZERegErr ) /////////////////////////////////////////////////////*/ template TypeLength AddSearchByTmplTreeChain ( const TTmplTreeChain& AR_CTmplChain, ZNsEnum::ZERegErr& ARRE_ZERegErr ) { ZNsInterface:: ZtCStackOfTmplChain VO_CStackOfTmplChain ; return AddSearchByTmplTreeChain( VO_CStackOfTmplChain, AR_CTmplChain, RR(ARRE_ZERegErr) ); }/* template TypeLength AddSearchByTmplTreeChain ( const TTmplTreeChain& AR_CTmplChain, ZNsEnum::ZERegErr& ARRE_ZERegErr ) */ template TypeLength GetLengthByTmplChain ( TChainStack& AR_CStackOfTmplChain, const TTmplChain& AR_CTmplChain , ZNsEnum::ZERegErr& ARRE_ZERegErr ) /*###############################################*/ { /*//////////////////////////////////////////////////////////////////////////// ■ TTmplChain 자료형으로는 ZtCSearchCChars<> 가 적합하다. -- 2011-09-29 22:47:00 ■ AR_CStackOfTmplChain 이 있으므로 해서 *this 의 멤버를 변경하지 않아도 된다. -- 2013-06-26 01:56:00 ////////////////////////////////////////////////////////////////////////////*/ typedef typename TTmplChain::ZCNowObj ZCNowObj; const ZCNowObj& VR_CNowObj=AR_CTmplChain.GetNowObj(); TypeLength VL_LengthNow =VR_CNowObj.GetLength ( mpc_OriginChar+ml_SearchPos+AR_CStackOfTmplChain.GetSearchSum(), ml_OriginLen -ml_SearchPos-AR_CStackOfTmplChain.GetSearchSum() ); ///////////////////////////////////////////// if(VL_LengthNow 0 && VL_LengthNow>VR_CNowObj.GetSearchCharMax())) { ARRE_ZERegErr=ZNsEnum::ZERegErr_CharCount; return 0; } if(AR_CStackOfTmplChain.GetSearchSum()0 && VL_LengthNow>VR_CNowObj.GetSearchSumMax ())) { ARRE_ZERegErr=ZNsEnum::ZERegErr_CharSum ; return 0; }/* if(AR_CStackOfTmplChain.GetSearchSum()0 && VL_LengthNow>VR_CNowObj.GetSearchSumMax ()))*/ AR_CStackOfTmplChain.AddSearchSum(VL_LengthNow); if(TTmplChain::EBoolNextObj<1) return AR_CStackOfTmplChain.GetSearchSum() ; return VL_LengthNow + GetLengthByTmplChain( AR_CStackOfTmplChain, AR_CTmplChain.GetNextObj(), RR(ARRE_ZERegErr)); }/* template TypeLength GetLengthByTmplChain ( TChainStack& AR_CStackOfTmplChain, const TTmplChain& AR_CTmplChain , ZNsEnum::ZERegErr& ARRE_ZERegErr ) /////////////////////////////////////////////////*/ template TypeLength GetLengthByTmplChain(TTmplChain& AR_CTmplChain, ZNsEnum::ZERegErr& ARRE_ZERegErr) { ZNsInterface::ZtCStackOfTmplChain VO_CStackOfTmplChain; return GetLengthByTmplChain(VO_CStackOfTmplChain, AR_CTmplChain, RR(ARRE_ZERegErr)); }/* template TypeLength GetLengthByTmplChain(TTmplChain& AR_CTmplChain, ZNsEnum::ZERegErr& ARRE_ZERegErr) */ template TypeLength GetLengthByTmplTreeChain ( TChainStack& AR_CStackOfTmplChain, const TTmplTreeChain& AR_CTmplTreeChain , ZNsEnum::ZERegErr& ARRE_ZERegErr ) /////////////////////////////////////////////////////// { // 테스트가 필요. 2013-06-26 17:20:00 typedef typename TTmplTreeChain::ZCNowObj ZCNowObj; const ZCNowObj& VR_CNowObj=AR_CTmplTreeChain.GetNowObj(); if(VR_CNowObj.GetERegFlag()==ZNsEnum::ZERegFlag_BlockStart) { TChainStack VO_CChainStack; ZNsEnum::ZERegErr VE_ZERegErr =ZNsEnum::ZERegErr_None; TypeLength VL_LengthNow=0; TypeLength VL_LengthSum=0; TypeLength VL_SearchCnt=0; /*////////////////////////////////////////////////////////////////////////////////// ■ *this 멤버를 전혀 건드리지 않는 또 다른 방법은, AR_CStackOfTmplChain 이외에 스택 에 ZtCCharChain<> object 를 선언해서 사용하면 되는데, 이 구현이 더 좋을까? -- 2013-06-26 01:08:00 //////////////////////////////////////////////////////////////////////////////////*/ while(true) { // '조회 Block'에 대하여 찾은 횟수가 VR_CNowObj.GetRepeatCntMax() 를 // 넘지 않는 범위 내에서 while 문을 반복한다. VL_LengthNow=GetLengthByTmplTreeChain( /////// RR(VO_CChainStack) , AR_CTmplTreeChain.GetSubObj(), RR(VE_ZERegErr) /*/////////*/ ); ///////////////////////////// if(VE_ZERegErr!=ZNsEnum::ZERegErr_None) { AR_CStackOfTmplChain.AddSearchSum(-VL_LengthSum); break; }/* if(VE_ZERegErr!=ZNsEnum::ZERegErr_None)*/ ++VL_SearchCnt; VL_LengthSum+=VL_LengthNow; if(VR_CNowObj.GetESearchMax()==ZNsEnum::ZESearchMax_Stop) { if(VL_SearchCnt==VR_CNowObj.GetRepeatCntMax()) { AR_CStackOfTmplChain.AddSearchSum(-VL_LengthSum); break; }/* if(VL_SearchCnt==VR_CNowObj.GetRepeatCntMax())*/ } if(VR_CNowObj.GetRepeatCntMax()>0) { if(VL_SearchCnt>VR_CNowObj.GetRepeatCntMax()) { AR_CStackOfTmplChain.AddSearchSum(-VL_LengthSum); VL_LengthSum=0; break; }/* if(VL_SearchCnt>VR_CNowObj.GetRepeatCntMax())*/ }/* if(VR_CNowObj.GetRepeatCntMax()>0)*/ AR_CStackOfTmplChain.AddSearchSum(VL_LengthNow); if(ml_OriginLen<=ml_SearchPos+AR_CStackOfTmplChain.GetSearchSum()) { AR_CStackOfTmplChain.AddSearchSum(-VL_LengthSum); break; }/* if(ml_OriginLen<=ml_SearchPos+AR_CStackOfTmplChain.GetSearchSum())*/ }/* while(true)*/ if(VL_SearchCnt0 && VL_LengthSum>VR_CNowObj.GetSearchCharMax() ) ; if(CB_IsCharCntErr) { ARRE_ZERegErr=ZNsEnum::ZERegErr_CharCount; return 0; }/* if(CB_IsCharCntErr)*/ AR_CStackOfTmplChain.AddSearchSum(VL_LengthSum); const bool CB_IsCharSumErr= AR_CStackOfTmplChain.GetSearchSum()0 && AR_CStackOfTmplChain.GetSearchSum()>VR_CNowObj.GetSearchSumMax() ); if(CB_IsCharSumErr) { ARRE_ZERegErr=ZNsEnum::ZERegErr_CharSum; AR_CStackOfTmplChain. AddSearchSum( -VL_LengthSum ); return 0; }/* if(CB_IsCharSumErr)*/ if(TTmplTreeChain::EBoolNextObj<1) return VL_LengthSum; return VL_LengthSum + GetLengthByTmplTreeChain( AR_CStackOfTmplChain, AR_CTmplTreeChain.GetNextObj(), RR(ARRE_ZERegErr)); }/* if (VR_CNowObj.GetERegFlag()==ZNsEnum::ZERegFlag_BlockStart)*/ else if(VR_CNowObj.GetERegFlag()==ZNsEnum::ZERegFlag_BlockClose) { return 0; }/* else if(VR_CNowObj.GetERegFlag()==ZNsEnum::ZERegFlag_BlockClose)*/ TypeLength VL_LengthNow = VR_CNowObj.GetLength ( mpc_OriginChar+ml_SearchPos+AR_CStackOfTmplChain.GetSearchSum(), ml_OriginLen -ml_SearchPos-AR_CStackOfTmplChain.GetSearchSum() ); ////////////////////////////////////////////// if(VL_LengthNow 0 && VL_LengthNow>VR_CNowObj.GetSearchCharMax())) { ARRE_ZERegErr=ZNsEnum::ZERegErr_CharCount; return 0; } if(AR_CStackOfTmplChain.GetSearchSum()0 && VL_LengthNow>VR_CNowObj.GetSearchSumMax ())) { ARRE_ZERegErr=ZNsEnum::ZERegErr_CharSum ; return 0; }/* if(AR_CStackOfTmplChain.GetSearchSum()0 && VL_LengthNow>VR_CNowObj.GetSearchSumMax ()))*/ AR_CStackOfTmplChain.AddSearchSum(VL_LengthNow); if(TTmplTreeChain::EBoolNextObj<1) return VL_LengthNow; return VL_LengthNow + GetLengthByTmplTreeChain( AR_CStackOfTmplChain, AR_CTmplTreeChain.GetNextObj(), RR(ARRE_ZERegErr)); }/* template TypeLength GetLengthByTmplTreeChain ( TChainStack& AR_CStackOfTmplChain, const TTmplTreeChain& AR_CTmplTreeChain , ZNsEnum::ZERegErr& ARRE_ZERegErr ) /////////////////////////////////////////////////////*/ template TypeLength GetLengthByTmplTreeChain ( TTmplTreeChain& AR_CTmplChain, ZNsEnum::ZERegErr& ARRE_ZERegErr ) { ZNsInterface:: ZtCStackOfTmplChain VO_CStackOfTmplChain; return GetLengthByTmplTreeChain( VO_CStackOfTmplChain, AR_CTmplChain, RR(ARRE_ZERegErr)); }/* template TypeLength GetLengthByTmplTreeChain ( TTmplTreeChain& AR_CTmplChain, ZNsEnum::ZERegErr& ARRE_ZERegErr ) */ public: };/* template< typename TTypeChars=ZNsType::ZtCTypeChars > class ZtCSearchCursor ///////////////////////////////////*/ typedef ZNsType::ZtCTypeChars ZCTypeChars; typedef ZtCMainChars ZCMainChars; }/* namespace ZNsChars*/ typedef ZNsChars ::ZCTypeChars ZCTypeChars; typedef ZNsChars ::ZCMainChars ZCMainChars; typedef ZCMainChars::ZCChars ZCChars ; }/* namespace ZNsMain */ #endif // __ZCPPMAIIN__ZTCMAINCHARS_H__ /*///////////////////////////////////////////////////////////////////////////////////////// ■ namespace ZNsChars 에는 문자열 관련 함수들이 오는데, MainChars.H 에 있는 함수보다 좀 더 확장성있게 설계하였다. 그런데 사용하기에는 다소 복잡하다. 그리고 ZtCMainChars.H 는 추후에 MainChars.H 을 대체할 것이다. -- 2011-07-10 03:48:00 그래서 아래 선언을 namespace std 에 추가해서, 사용하기 쉽게 했다. typedef ZNsChars::ZCTypeChars ZCTypeChars; typedef ZNsChars::ZCMainChars ZCMainChars; -- 2011-08-15 18:16:00 ■ ZtCMainChars<>::DoStart() 등의 함수에 대소문자를 구분 여부를, ZtCMainChars<> 의 템플릿 인자에 bool 등의 값으로 지정하려고 하였으나, utf8 등의 경우에 아주 골치 아플 것 같아서, 기본적으로 대소문자 구분을 하는 것으로 한다. 굳이 대소문자 구분을 하고 싶은 경우는, 정규 표현식 관련 object 을 쓰도록 하자. -- 2011-07-12 07:14:00 ■ 'char 의 int 확장에 따른 문제의 코드' 아래 함수에서 int ZtCMainChars<>::Minus(TypeCharC*, TypeCharC*, TypeLength, TypeLength) return 문을 return VC_Minus; // VC_Minus 는 *(VP_Left-1)-*(VP_Right-1) 에서 return int(*(VP_Left-1))-int(*(VP_Right-1)); 로 고쳤다. 컴파일러에 따라, 음수 char 을 int 로 확장하면 양수(+)가 될 수 있는 것이다. 이 것을 언제 알았냐면, LG CNS 에서 충전기 프로젝트를 할 때다. 그때 ELDK 4.0 tool chain 의 컴파일러를 사용했는데, NsUtility::CLoadSimUrlConfig_T<> 으로 설정 파일을 읽어들일 때, 자 꾸 몇몇 설정값을 인식하지 못하고 있었다. CLoadSimUrlConfig_T<> 은 ns1.cppschool.com 과 ns2.cppschool.com 에서 테스트된 클래스이다. 그런데도 이런 문제가 발생한 것이다. 이전에 Hemose 의 메신저 서버를 만들 때에도 이런 문제가 있었는데, 풀리지 않을 것 같은 문제로 여 기고 매우 긴장하고 있었다. CObjAVL.H 파일의 AddKey() 함수의 비교하는 부분에 cout 으로 출력해 보니까, 항상 '>' 조건이 아닌가. 그래서 ZtCMainChars<>::Minus() 함수까지 파들어가 리턴하는 값을 보니까 항상 양수였다! 이럴수가, 왼쪽이 작으면 음수를 리턴해야 한다. 그런 데 항상 양수라니. 좀 더 조사해 보니까, 해당 컴파일러의, char 의 int 형 확장에 따른 문제 였고 코드를 위처럼 고치게 되었다. -- 2011-12-29 17:35:00 /////////////////////////////////////////////////////////////////////////////////////////*/