cPairSort.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cPairSort_H
#define _INC_cPairSort_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cArraySort.h"
#include "cPair.h"
 
namespace Gray
{
        template <class _TYPE_PAIR, class _TYPE_KEY>
        class cPairSortBase : public cArraySorted < _TYPE_PAIR*, _TYPE_PAIR*, _TYPE_KEY >
        {
 
        public:
                virtual ~cPairSortBase()
                {
                }
 
                ITERATE_t InitAssocElements(const _TYPE_PAIR* pInit, size_t iSizeElement = sizeof(_TYPE_PAIR))
                {
                        ITERATE_t i = 0;
                        for (;; i++)
                        {
                                BYTE* pData = ((BYTE*)pInit) + (i*iSizeElement);
                                if (!*((_TYPE_KEY*)pData))
                                        break;
                                SetAtGrow(i, (_TYPE_PAIR*)pData);
                        }
                        this->QSort();
                        return i;
                }
                virtual COMPARE_t CompareKey(KEY_t Key, REF_t Data2) const override
                {
                        return cValT::Compare(Key, *((_TYPE_KEY*)Data2));
                }
                virtual COMPARE_t CompareData(REF_t Data1, REF_t Data2) const noexcept override
                {
                        return cValT::Compare(*((_TYPE_KEY*)Data1), *((_TYPE_KEY*)Data2));
                }
                _TYPE_PAIR* FindArgForKey(_TYPE_KEY Key) const
                {
                        ITERATE_t index = FindIForKey(Key);
                        if (index < 0)
                                return nullptr;
                        return this->GetAt(index);
                }
        };
 
        template < class _TYPE_A, class _TYPE_B >
        class cPairSortVal : public cPairSortBase < cPair< _TYPE_A, _TYPE_B>, _TYPE_A >
        {
                typedef cPair< _TYPE_A, _TYPE_B> PAIR_t;
        };
 
        template < class _TYPE_A, class _TYPE_B>
        class cPairSortStr : public cPairSortBase < cPair< _TYPE_A, _TYPE_B>, const ATOMCHAR_t* >
        {
                typedef cPair< _TYPE_A, _TYPE_B> PAIR_t;
 
        public:
                virtual ~cPairSortStr()
                {
                }
 
                virtual COMPARE_t CompareKey(KEY_t pszKey, REF_t Data2) const override
                {
                        return StrT::CmpI((const ATOMCHAR_t*)pszKey, *(const ATOMCHAR_t**)Data2);
                }
                virtual COMPARE_t CompareData(REF_t Data1, REF_t Data2) const noexcept override
                {
                        return StrT::CmpI(*(const ATOMCHAR_t**)Data1, *(const ATOMCHAR_t**)Data2);
                }
                _TYPE_B FindKeyRetB(const ATOMCHAR_t* pszKey) const
                {
                        PAIR_t* pEntry = this->FindArgForKey(pszKey);
                        if (pEntry == nullptr)
                        {
                                return (_TYPE_B)k_ITERATE_BAD;
                        }
                        return pEntry->get_B();
                }
        };
};
 
#endif