cArraySortRef.h

Go to the documentation of this file.

//
 
#ifndef _INC_cArraySortRef_H
#define _INC_cArraySortRef_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cArraySort.h"
#include "cArrayRef.h"
 
namespace Gray
{
        template<class TYPE, typename TYPE_KEY>
        class cArraySortRef : public cArraySortFacade < cRefPtr<TYPE>, TYPE*, TYPE_KEY >
        {
 
                typedef cArraySortFacade< cRefPtr<TYPE>, TYPE*, TYPE_KEY > SUPER_t;
 
        public:
 
                void DisposeAll()
                {
 
                        ITERATE_t iSize = this->GetSize();
                        if (iSize > 0)
                        {
                                {       // save original list, call DisposeThis on everything from original list
                                        cArrayRef<TYPE> orig;
                                        orig.SetCopy(*this);
 
                                        ASSERT(orig.GetSize() == iSize);
                                        for (ITERATE_t i = 0; i < iSize; i++)
                                        {
                                                TYPE* pObj = orig.GetAt(i);
                                                if (pObj != nullptr)
                                                        pObj->DisposeThis();
                                        }
                                }
                                this->RemoveAll();
                        }
                }
        };
 
        //*************************************************
 
        template <class TYPE, typename _TYPE_HASH = HASHCODE_t>
        class cArraySortHash : public cArraySortRef < TYPE, _TYPE_HASH >
        {
 
        public:
                typedef cArraySortRef<TYPE, _TYPE_HASH> SUPER_t;
                typedef typename SUPER_t::REF_t REF_t;
                typedef typename SUPER_t::KEY_t KEY_t;
 
        protected:
                virtual COMPARE_t CompareData(REF_t pData1, REF_t pData2) const noexcept override
                {
                        ASSERT_N(pData1 != nullptr);
                        ASSERT_N(pData2 != nullptr);
                        KEY_t key1 = pData1->get_HashCode();
                        KEY_t key2 = pData2->get_HashCode();
                        return cValT::Compare(key1, key2);
                }
                virtual COMPARE_t CompareKey(KEY_t key1, REF_t pBase) const override
                {
                        ASSERT_N(pBase != nullptr);
                        KEY_t key2 = pBase->get_HashCode();
                        return cValT::Compare(key1, key2);
                }
        public:
                virtual ~cArraySortHash()
                {}
 
                ITERATE_t FindIForAK(const TYPE* pBase) const
                {
                        if (pBase == nullptr)
                                return k_ITERATE_BAD;
                        return this->FindIForKey(pBase->get_HashCode());
                }
                bool RemoveArgKey(TYPE* pBase)
                {
                        if (pBase == nullptr)
                                return false;
                        return SUPER_t::RemoveArgKey(pBase, pBase->get_HashCode());
                }
        };
 
        //*************************************************
 
        template <class TYPE, typename TYPE_KEY = int>
        class cArraySortValue : public cArraySortRef < TYPE, TYPE_KEY >
        {
 
        public:
                typedef cArraySortRef<TYPE, TYPE_KEY> SUPER_t;
                typedef typename SUPER_t::REF_t REF_t;
                typedef typename SUPER_t::KEY_t KEY_t;
 
        protected:
                virtual COMPARE_t CompareData(REF_t pData1, REF_t pData2) const noexcept override
                {
                        ASSERT(pData1 != nullptr);
                        ASSERT(pData2 != nullptr);
                        TYPE_KEY key1 = pData1->get_SortValue();
                        TYPE_KEY key2 = pData2->get_SortValue();
                        COMPARE_t iDiff = cValT::Compare(key1, key2);
                        if (iDiff == COMPARE_Equal)     // allow duplicate get_SortValue() but NOT duplicate objects!
                                return cValT::Compare((INT_PTR)pData1, (INT_PTR)pData2);
                        return iDiff;
                }
                virtual COMPARE_t CompareKey(KEY_t key1, REF_t pBase) const override
                {
                        if (pBase == nullptr)
                                return COMPARE_Greater;
                        TYPE_KEY key2 = pBase->get_SortValue();
                        return cValT::Compare(key1, key2);
                }
        public:
                virtual ~cArraySortValue()
                {}
 
                ITERATE_t FindIForAK(const TYPE* pBase) const
                {
                        if (pBase == nullptr)
                                return k_ITERATE_BAD;
                        TYPE_KEY nKey = pBase->get_SortValue();
                        ITERATE_t i = this->FindIFirstForKey(nKey);
                        if (i < 0)
                                return k_ITERATE_BAD;
                        for (;; i++)
                        {
                                cRefPtr<TYPE> pBase2 = this->GetAtCheck(i);
                                if (pBase2 == nullptr)  // pBase is not in the array!
                                        break;
                                if (pBase2 == pBase) // since sorted values are allowed to duplicate.
                                        return i;
                        }
                        // This probably shouldn't happen? pBase is not in the array!
                        return k_ITERATE_BAD;   // FindIForAC(pBase);   // just do a brute force search.
                }
                bool RemoveArgKey(TYPE* pBase)
                {
                        ITERATE_t index = this->FindIForAK(pBase);
                        if (index < 0)
                                return false;
                        SUPER_t::RemoveAt(index);
                        return true;
                }
                ITERATE_t AddAfter(TYPE* pBase)
                {
                        ASSERT(pBase != nullptr);
                        TYPE_KEY nKey = pBase->get_SortValue();
                        ITERATE_t i = this->FindILastForKey(nKey);
                        if (i < 0)      // one of the same type is here?
                        {
                                return this->Add(pBase);        // add new sorted by nKey.
                        }
                        // add to the end of the get_SortValue series.
                        this->InsertAt(++i, pBase);
                        return i;
                }
        };
 
        //*************************************************
 
        template <class TYPE, typename _TYPECH = GChar_t>
        class cArraySortName : public cArraySortRef < TYPE, const _TYPECH* >
        {
 
        public:
                typedef cArraySortRef<TYPE, const _TYPECH*> SUPER_t;
                typedef typename SUPER_t::REF_t REF_t;
                typedef typename SUPER_t::KEY_t KEY_t;
 
        protected:
                virtual COMPARE_t CompareData(REF_t pData1, REF_t pData2) const noexcept override
                {
                        ASSERT_N(pData1 != nullptr);
                        ASSERT_N(pData2 != nullptr);
                        return StrT::CmpI<_TYPECH>(pData1->get_Name(), pData2->get_Name());
                }
                virtual COMPARE_t CompareKey(KEY_t key1, REF_t pObj) const override
                {
                        ASSERT_N(key1 != nullptr);
                        ASSERT_N(pObj != nullptr);
                        return StrT::CmpI<_TYPECH>(key1, pObj->get_Name());
                }
        public:
                virtual ~cArraySortName()
                {}
 
                ITERATE_t FindIForAK(const TYPE* pBase) const
                {
                        if (pBase == nullptr)
                                return k_ITERATE_BAD;
                        return this->FindIForKey(pBase->get_Name());
                }
                bool RemoveArgKey(TYPE* pBase)
                {
                        if (pBase == nullptr)
                                return false;
                        return SUPER_t::RemoveArgKey(pBase, pBase->get_Name());
                }
        };
}
#endif // _INC_cArraySortRef_H