cArraySortString.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cArraySortString_H
#define _INC_cArraySortString_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cArraySortRef.h"
#include "cArrayString.h"
#include "cUnitTestDecl.h"
 
namespace Gray
{
        UNITTEST2_PREDEF(cArraySortString);
 
        template< typename _TYPE_CH = TCHAR >
        class GRAYCORE_LINK cArraySortString : public cArraySorted < cStringT<_TYPE_CH>, cStringT<_TYPE_CH>, const _TYPE_CH* >
        {
 
        public:
                typedef cArraySorted< cStringT<_TYPE_CH>, cStringT<_TYPE_CH>, const _TYPE_CH*> SUPER_t;
                typedef cStringT<_TYPE_CH> STR_t;       // alias for container
                typedef typename SUPER_t::REF_t REF_t;
                typedef typename SUPER_t::KEY_t KEY_t;
 
        public:
                virtual ~cArraySortString()
                {
                }
                virtual COMPARE_t CompareKey(KEY_t pszID1, REF_t sID2) const override
                {
                        ASSERT(pszID1 != nullptr);
                        return StrT::CmpI<_TYPE_CH>(pszID1, sID2);
                }
                virtual COMPARE_t CompareData(REF_t sID1, REF_t sID2) const noexcept override
                {
                        return StrT::CmpI<_TYPE_CH>(sID1, sID2);
                }
 
                ITERATE_t AddStr(const _TYPE_CH* pszStr)
                {
                        return this->Add(STR_t(pszStr));
                }
 
                ITERATE_t FindKeyRoot(const _TYPE_CH* pszRoot)
                {
 
                        StrLen_t iStrLen = StrT::Len(pszRoot);
                        ITERATE_t iHigh = this->GetSize() - 1;
                        ITERATE_t iLow = 0;
                        while (iLow <= iHigh)
                        {
                                ITERATE_t i = (iHigh + iLow) / 2;
                                STR_t sCur = this->GetAt(i);
                                COMPARE_t iCompare = StrT::CmpIN<_TYPE_CH>(pszRoot, sCur, iStrLen);
                                if (iCompare == COMPARE_Equal)
                                        return i;       // pszRoot is a parent of
                                if (iCompare > 0)
                                {
                                        iLow = i + 1;
                                }
                                else
                                {
                                        iHigh = i - 1;
                                }
                        }
                        return k_ITERATE_BAD;
                }
 
                ITERATE_t FindKeyDerived(const _TYPE_CH* pszDerived)
                {
 
                        ITERATE_t iHigh = this->GetSize() - 1;
                        ITERATE_t iLow = 0;
                        while (iLow <= iHigh)
                        {
                                ITERATE_t i = (iHigh + iLow) / 2;
                                STR_t sCur = this->GetAt(i);
                                COMPARE_t iCompare = StrT::CmpIN<_TYPE_CH>(pszDerived, sCur, sCur.GetLength());
                                if (iCompare == COMPARE_Equal)
                                        return(i);      // pszDerived is a child of sCur (derived from root sCur)
                                if (iCompare > 0)
                                {
                                        iLow = i + 1;
                                }
                                else
                                {
                                        iHigh = i - 1;
                                }
                        }
                        return k_ITERATE_BAD;
                }
 
                UNITTEST_FRIEND(cArraySortString);
        };
 
        typedef cArraySortString<char> cArraySortStringA;
        typedef cArraySortString<wchar_t> cArraySortStringW;
 
}
 
#endif