AssociationMap.h

Go to the documentation of this file.

//! @file AssociationMap.h
//! CAssociationMap provides a compact way of associating a key to several values
 
#ifndef CASSOCIATIONMAP_CLASS_H
#define CASSOCIATIONMAP_CLASS_H
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "Collection.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
///////////////////////////////////////////////////////////////////////////////////////////////////
//! @class CAssociationCollector
//! @brief This collector is to used when you know that the collecting process does not involves duplicate pairs in the CAssociationMap.
//! @details It is quicker to build than CSingleAssociationCollector which verify that the value has not already been inserted.
//! Once build the collector can be used to build a CAssociationMap which is a very compact way to store the association data
///////////////////////////////////////////////////////////////////////////////////////////////////
 
template<class MAPTYPE, class ASSOCTYPE, class SIZETYPE>
class CAssociationCollector
{
    friend CAssociationMap<MAPTYPE, ASSOCTYPE, SIZETYPE>;
 
public:
    typedef struct CollectorEntry
    {
        MAPTYPE key;
        ASSOCTYPE assoc;
    } CollectorEntry;
 
    typedef CXArray<CollectorEntry> CollectorArray;
    typedef CHashMap<MAPTYPE, const MAPTYPE&, unsigned int> CollectorMap;
 
private:
    int size;
    CollectorEntry entry;
    CollectorMap map; // Number of association for a given element
    CollectorArray items; // Array of association
 
#ifdef _DEBUG
    unsigned int assocSizeof;  // Verify out of bounds
#endif
 
protected:
    inline void FreeKeys()
    {
        map.Free();
    }
 
    inline void FreeEntries()
    {
        items.RemoveAll();
    }
 
    inline int GetSize()
    {
        return size;
    }
 
    inline CollectorEntry *GetEntry(int i)
    {
        return &items[i];
    }
 
    inline int GetKeyCount()
    {
        return map.GetCount();
    }
 
    inline int FindKey(MAPTYPE& key, unsigned int& count)
    {
        return map.Find(key, count);
    }
 
    inline void RemoveKey(MAPTYPE& key)
    {
        map.Remove(key);
    }
 
public:
    CAssociationCollector(int elementNbr = 0, int collectorGrowMode = CollectorArray::GROW_DOUBLE_SIZE)
    {
        size = 0;
 
        if (elementNbr == 0)
            elementNbr = 128;
 
            map.InitHashTable(elementNbr);
 
            if (collectorGrowMode != CollectorArray::GROW_DOUBLE_SIZE)
                collectorGrowMode = elementNbr / 3 < 1024 ? CollectorArray::GROW_DEFAULT : elementNbr / 3;
 
            items.SetSize(elementNbr, collectorGrowMode);
 
#ifdef _DEBUG
        assocSizeof = (unsigned int)((((longint)1) << (sizeof(SIZETYPE)*8))-1);
#endif
    }
 
    void Add(const MAPTYPE& key, const ASSOCTYPE& assoc)
    {
        unsigned int *count = map.Find(key);
        if (count)
        {
            (*count)++;
    #ifdef _DEBUG
            XASSERT(*count <= assocSizeof);
    #endif
        }
        else
            map.Insert(key, 1);
 
        entry.key = key;
        entry.assoc = assoc;
        items.SetAtGrow(size++, entry);
    }
 
    void Add(const CollectorEntry& entry) // Faster adding
    {
        unsigned int *count = map.Find(entry.key);
        if (count)
        {
            (*count)++;
#ifdef _DEBUG
            XASSERT(*count <= assocSizeof);
#endif
        }
        else
            map.Insert(entry.key, 1);
 
 
        items.SetAtGrow(size++, entry);
    }
};
 
///////////////////////////////////////////////////////////////////////////////////////////////////
//! @class CSingleAssociationCollector
//! @brief CSingleAssociationCollector this collector ensures to collect single pairs in the association map.
//! @details It requires a HashMethod to be defined:
//!
//! @code{.cpp} 
//! template <> class CHashMethods<CSingleAssociationCollector::CollectorEntry>
//! {
//!     public:
//!         static unsigned int HashValue(const CSingleAssociationCollector::CollectorEntry& info)
//!         static bool HashCompare(const CSingleAssociationCollector::CollectorEntry& info1, const CSingleAssociationCollector::CollectorEntry& info2)
//! };
//! @endcode
//! 
//! Once build the collector can be used to build a CAssociationMap which is a very compact way to store the association data
///////////////////////////////////////////////////////////////////////////////////////////////////
 
template<class MAPTYPE, class ASSOCTYPE> struct SingleCollectorEntry
{
    MAPTYPE key;
    ASSOCTYPE assoc;
};
 
template<class MAPTYPE, class ASSOCTYPE, class SIZETYPE>
class CSingleAssociationCollector
{
    friend CAssociationMap<MAPTYPE, ASSOCTYPE, SIZETYPE>;
 
public:
    typedef SingleCollectorEntry<MAPTYPE, ASSOCTYPE> CollectorEntry; // This typedef is a simple way to provide HashFunctions Ie. CHashMethods<CAssociationMap::Collector::CollectorEntry>
 
private:
    typedef CHashMethods<CollectorEntry> CHashCollectorMethods;
    typedef CHashTable<CollectorEntry, CHashCollectorMethods> CollectorHashEntry;
    typedef CHashMap<MAPTYPE, const MAPTYPE&, unsigned int> CollectorKeyCount;
 
 
    CollectorHashEntry entries; // Number of association for a given element
    CollectorKeyCount valuesCounts; // Number of single values for each key
 
protected:
    inline void FreeKeys()
    {
        valuesCounts.Free();
    }
 
    inline int GetKeyCount()
    {
        return valuesCounts.GetCount();
    }
 
    inline int FindKey(const MAPTYPE& key, unsigned int& count)
    {
        return valuesCounts.Find(key, count);
    }
 
    inline CollectorEntry *GetNextEntry(HashPos& pos)
    {
        return entries.GetNextPtr(pos);
    }
 
    inline HashPos GetFirstEntry()
    {
        return entries.GetFirst();
    }
 
    inline void FreeEntries()
    {
        entries.Free();
    }
 
public:
    CSingleAssociationCollector(int elementNbr = 0)
    {
        if (elementNbr == 0)
            elementNbr = 128;
 
            entries.InitHashTable(elementNbr);
            valuesCounts.InitHashTable(elementNbr);
        }
 
    void Add(const CollectorEntry& entry)  // Faster adding
    {
        if (entries.Insert(entry) == false) // Already added
            return;
 
        unsigned int *count = valuesCounts.Find(entry.key);
        if (count)
            (*count)++; // Contains the different values count
        else
            valuesCounts.Insert(entry.key, 1);
    }
};
 
///////////////////////////////////////////////////////////////////////////////////////////////////
//! @class CAssociationMap
//! @brief This class handles an association between a key and its associated values.
//! @details It must be build using an CAssociationCollector class.
//! In then stores the association in a very compact way compare to CHashAssocMap
template<class MAPTYPE, class ASSOCTYPE, class SIZETYPE, template<typename T1, typename T2> class COLLTYPE> // COLLTYPE = CSimpleCollection by default
class CAssociationMap
{
protected:
    CHashMap<MAPTYPE, const MAPTYPE&, unsigned int> map;
    COLLTYPE<ASSOCTYPE, SIZETYPE> assocs;
#ifdef _DEBUG
    bool checkDuplicate;
#endif
 
public:
    typedef CAssociationCollector<MAPTYPE, ASSOCTYPE, SIZETYPE> Collector;
    typedef SingleCollectorEntry<MAPTYPE, ASSOCTYPE> CollectorEntry; // This typedef is a simple way to provide HashFunctions Ie. CHashMethods<CAssociationMap::Collector::CollectorEntry>
 
    CAssociationMap()
    {
    #ifdef _DEBUG
        checkDuplicate = true;
    #endif
    }
 
    // Defines an estimate number of entries and the estimated number of element per entry
    void SetSize(unsigned int entries, unsigned int elementPerEntries)
    {
        map.Clear();
        map.InitHashTable(entries);
        assocs.PreAllocate(entries, entries*elementPerEntries);
    }
 
    //! Giving a key return an array with the associates data and the number of element in that array.
    ASSOCTYPE *Lookup(const MAPTYPE& entry, int& size) const
    {
        unsigned int index;
        if (map.Find(entry, index))
            return assocs.GetEntry(index, size);
 
        size = 0;
        return NULL;
    }
 
    //! Returns true if a key is found in the association map
    bool IsFound(const MAPTYPE& entry) const
    {
        return (map.IsFound(entry) != 0);
    }
 
    //! Remove a key and its association from the map
    void Remove(const MAPTYPE& entry)
    {
        unsigned int index;
        if (map.Find(entry, index))
        {
            assocs.SetEntrySize(index, 0);
        }
    }
 
 
    //! @brief Move a from  association key to a destination key and associates the from values to the destination key
    //! @note Destination association are lost and replaced by from association values
    bool MoveTo(const MAPTYPE& from, const MAPTYPE& to)
    {
        unsigned int index;
        if (!map.Find(from, index))
            return false;
 
        map.Remove(from);
        map.Insert(to, index);
 
        return true;
    }
 
#ifdef _DEBUG
    // Look if entry is already associated to assoc
    bool CheckDuplicates() const
    {
        if (!checkDuplicate)
            return false;
 
        // Check redundancy
        CHashTable<ASSOCTYPE> duplicateHash;
 
        MAPTYPE entry;
        HashPos pos = map.GetFirst();
        unsigned int index;
        int i, size;
        int count = 0;
        while (pos != HashEnd)
        {
            map.GetNext(pos, entry, index);
 
            ASSOCTYPE *assoc = assocs.GetEntry(index, size);
            if (size == 1)
                continue;
            else if (size == 2)
            {
                if (CHashMethods<ASSOCTYPE>::HashCompare(assoc[0],assoc[1]))
                {
                    count++;
                    continue;
                }
 
                continue;
            }
 
            for (i=0; i<size; i++)
            {
                if (duplicateHash.IsFound(assoc[i]))
                {
                    count++;
                    continue;
                }
 
                duplicateHash.Insert(assoc[i]);
            }
 
            if (size > 1024)
                duplicateHash.Free(); // If one key has a lot of values, this could be better to free, because next clear will have to reset the hash for many values
            else
            duplicateHash.Clear();
        }
 
        if (count > 0)
            XTRACE(_T("CAssociationMap: WARNING %d duplicated entry has been found in the map.\nCSingleAssociationCollector should be used instead CAssociationCollector.\n"), count);
 
        return (count > 0);
    }
#endif
 
#if 0
    bool CleanDuplicates()
    {
        CHashTable<ASSOCTYPE> *duplicateHash = NULL;
        bool duplicate = false;
        MAPTYPE entry;
        HashPos pos = map.GetFirst();
        unsigned int index;
        int i, size;
        while (pos != HashEnd)
        {
            map.GetNext(pos, entry, index);
 
            ASSOCTYPE *assoc = assocs.GetEntry(index, size);
            if (size <= 1)
                continue;
            else if (size == 2)
            {
                if (assoc[0] == assoc[1])
                {
                    assocs.RemoveElementInEntry(index, 1);
                    duplicate = true;
                }
 
                continue;
            }
            else if (size == 3)
            {
                if (assoc[0] == assoc[1])
                {
                    assocs.RemoveElementInEntry(index, 1);
                    duplicate = true;
                }
                else if (assoc[0] == assoc[2])
                {
                    assocs.RemoveElementInEntry(index, 2);
                    duplicate = true;
                }
                else if (assoc[1] == assoc[2])
                {
                    assocs.RemoveElementInEntry(index, 2);
                    duplicate = true;
                }
 
                continue;
            }
 
            // Slower cases
            // Check redundancy
            if (duplicateHash == NULL)
                duplicateHash = xNew(CHashTable<ASSOCTYPE>);
 
            for (i=0; i<size; i++)
            {
                if (duplicateHash->IsFound(assoc[i]))
                {
                    assocs.RemoveElementInEntry(index, i);
                    duplicate = true;
 
                    i--;
                    size--;
                    continue;
                }
 
                duplicateHash->Insert(assoc[i]);
            }
 
            duplicateHash->Clear();
        }
 
        if (duplicateHash)
            xDelete(duplicateHash);
 
        return (duplicate);
    }
#endif
 
    //! Associate an element to an entry. This method is slow, and a collector should be prefered.
    //! Beware: element might have already been associated to entry and the method does not ensure of entry/element unicity
    //! if unicity is required, and data might have duplicate, CleanDuplicates might be called
    void AddAssociation(const MAPTYPE& entry, const ASSOCTYPE& element)
    {
        unsigned int index;
        if (!map.Find(entry, index))
        {
            index = assocs.AddEntry(FALSE);
            map.Insert(entry, index);
        }
 
        assocs.AddElementInEntry(index, element);
    }
 
    //! Remove an association and all its entries. This method is SLOW
    //! Do not release memory. This can be done calling FreeExtra at the end of the removal process for example
    bool RemoveAssociation(const MAPTYPE& refentry)
    {
        unsigned int refindex;
        if (!map.Find(refentry, refindex))
            return false;
 
        // Implementation note: SetEntrySize(..., 0) lead to have assocs.GetEntriesSize() > map.GetCount(). map.GetSize must be used to get the real size
        map.Remove(refentry, false);
        assocs.RemoveEntry(refindex); 
 
        // Update indexes
        unsigned int *index;
        HashPos pos = map.GetFirst();
        while (pos != HashEnd)
        {
            map.GetNext(pos, index);
            if (*index >= refindex)
                (*index)--;
        }
        return true;
    }
 
    HashPos GetFirst() const
    {
        XASSERT(assocs.GetEntriesSize() == map.GetCount());
        return map.GetFirst();
    }
 
    ASSOCTYPE *GetNext(HashPos& pos, MAPTYPE& entry, int& size) const
    {
        XASSERT(pos != HashEnd);
        unsigned int index;
        map.GetNext(pos, entry, index);
        return assocs.GetEntry(index, size);
    }
 
    ASSOCTYPE *GetNext(HashPos& pos, MAPTYPE *&entry, int& size) const
    {
        XASSERT(pos != HashEnd);
        unsigned int *index = NULL;
        map.GetNext(pos, entry, index);
        return assocs.GetEntry(*index, size);
    }
 
    //! return the number of key values in the association map
    unsigned int GetSize() const
    {
        XASSERT(assocs.GetEntriesSize() == map.GetCount());
        return map.GetCount();
    }
 
    bool FreeExtra()
    {
        XASSERT(assocs.GetEntriesSize() == map.GetCount());
        bool compressed = map.Minimize();
        compressed |= assocs.FreeExtra();
 
#ifdef _DEBUG
        CheckDuplicates();
#endif
 
        return compressed;
    }
 
    void Free()
    {
        map.Free();
        assocs.Free();
    }
 
    void Copy(const CAssociationMap<MAPTYPE, ASSOCTYPE, SIZETYPE>& refAssociationMap)
    {
        *this = refAssociationMap;
    }
 
    CAssociationMap<MAPTYPE, ASSOCTYPE, SIZETYPE, COLLTYPE>& operator=(const CAssociationMap<MAPTYPE, ASSOCTYPE, SIZETYPE, COLLTYPE> &refAssociationMap)
    {
        map = refAssociationMap.map;
        assocs.Copy(refAssociationMap.assocs);
 
        return *this;
    }
 
    //! Init the association map from a CAssociationCollector
    void Convert(CAssociationCollector<MAPTYPE, ASSOCTYPE, SIZETYPE>& collector)
    {
        Free();
 
        unsigned int keynbr = collector.GetKeyCount();
        if (!keynbr)
            return;
 
    #ifdef _DEBUG
        checkDuplicate = true; // This collector might generate duplicates
    #endif
 
        unsigned int *sizes = xAllocateArray(unsigned int, keynbr);
        unsigned int count, index = 0;
            
        // Preallocate the size for each entries
        // key should be entered in the sizes order (step2)
        // otherwise preallocation is unuseful
        typename CAssociationCollector<MAPTYPE, ASSOCTYPE, SIZETYPE>::CollectorEntry *entry;
        int i, size = collector.GetSize();
        for (i=0; i<size; i++)
        {
            entry = collector.GetEntry(i);
            if (collector.FindKey(entry->key, count))
            {
                sizes[index++] = count;
                collector.RemoveKey(entry->key);
            }
        }
 
        XASSERT(collector.GetKeyCount() == 0 && index == keynbr); // each array key should be in hash table, and each hash table entry should be in array. Otherwise something wrong
        collector.FreeKeys();
 
        assocs.SetEntriesSize(keynbr, 0, COL_EMPTY_NEW_ENTRIES|COL_EXACTSIZE_ENTRIES, sizes);
        xDeallocateArray(sizes);
 
        map.InitHashTable(keynbr);
 
        // Step2 : Init the association map.
        unsigned int entryIndex = 0, entryNbr = 0;
        for (i=0; i<size; i++)
        {
            entry = collector.GetEntry(i);
            if (!map.Find(entry->key, entryIndex))
            {
                entryIndex = entryNbr;
                map.Insert(entry->key, entryNbr++);
            }
 
            assocs.AddElementInEntry(entryIndex, entry->assoc);
        }
 
        collector.FreeEntries();
        MOOTOOLS_PRIVATE_TRACE_IF(FreeExtra(), _T("CAssociationMap::Convert(CAssociationCollector: FreeExtra performs some reallocation. It should not\n"));
    }
 
    //! Init the association map from a CSingleAssociationCollector
    void Convert(CSingleAssociationCollector<MAPTYPE, ASSOCTYPE, SIZETYPE>& collector)
    {
        Free();
 
        unsigned int keynbr = collector.GetKeyCount();
        if (!keynbr)
            return;
 
    #ifdef _DEBUG
        checkDuplicate = true; // This collector might generate duplicates
    #endif
 
        map.InitHashTable(keynbr);
 
        unsigned int *sizes = xAllocateArray(unsigned int, keynbr);
        unsigned int index = 0;
            
        // Preallocate the size for each entries
        // key should be entered in the sizes order (step2)
        // otherwise preallocation is unuseful
        CollectorEntry *entry;
        unsigned int entryIndex = 0, entryNbr = 0, count;
        HashPos pos = collector.GetFirstEntry();
        while (pos != HashEnd)
        {
            entry = collector.GetNextEntry(pos);
            if (map.Find(entry->key, entryIndex))
                continue;
 
            if (collector.FindKey(entry->key, count))
            {
                map.Insert(entry->key, entryNbr);
                sizes[entryNbr++] = count;
            }
        }
    
        XASSERT(entryNbr == keynbr); // each array key should be in hash table, and each hash table entry should be in array. Otherwise something wrong
        collector.FreeKeys();
 
        // We have now the exact size
        assocs.SetEntriesSize(keynbr, 0, COL_EMPTY_NEW_ENTRIES|COL_EXACTSIZE_ENTRIES, sizes);
 
        xDeallocateArray(sizes);
 
        // Step2 : Init the association map.
        pos = collector.GetFirstEntry();
        while (pos != HashEnd)
        {
            entry = collector.GetNextEntry(pos);
            if (!map.Find(entry->key, entryIndex))
            {
                XASSERT(0); // Should not occurs, key have been entered before
                continue;
            }
 
            assocs.AddElementInEntry(entryIndex, entry->assoc);
        }
 
        XASSERT(GetSize() == keynbr); // The size should be the same than the one we used 
 
        collector.FreeEntries();
        MOOTOOLS_PRIVATE_TRACE_IF(FreeExtra(), _T("CAssociationMap::Convert(CSingleAssociationCollector: FreeExtra performs some reallocation. It should not\n"));
    }
};
 
#define GROUPMAP_NOINDEX (-1)
 
///////////////////////////////////////////////////////////////////////////////////////////////////
//! @class CGroupMap
//! @brief This class is useful to gather items together and retrieve the elements gathered.
//! @details Ie. : for gathering confused points: Group1 [#1 #5 #8 #11] Group2 [#7 #9 #10 #15] Group3 [#16 #17 #18 #20]
//! Then, giving any element of a group you can retrieve the other elements\n
//! **Important:** an element can belong to one group only
template<class MAPTYPE, class SIZETYPE, template<class T1, class T2> class COLLTYPE> // COLLTYPE = CSimpleCollection by default
class CGroupMap
{
private:
    CHashMap<MAPTYPE, MAPTYPE, unsigned int> indexToGroup;
    COLLTYPE<MAPTYPE, SIZETYPE> groupAssoc;
 
public:
    CGroupMap()
    {
    }
 
    void Free()
    {
        indexToGroup.Free();
        groupAssoc.Free();
    }
 
    void FreeExtra()
    {
        indexToGroup.Minimize();
        groupAssoc.FreeExtra();
    }
 
    void PreAllocate(unsigned int estimatedGroupNbr, unsigned int estimatedTotalElementNumber)
    {
        indexToGroup.InitHashTable(estimatedGroupNbr);
        groupAssoc.PreAllocate(estimatedGroupNbr, estimatedTotalElementNumber);
    }
 
    unsigned int AddGroup(unsigned int newGroupCount = 1) // Return first new group entry index
    {
        unsigned int firstgroup = groupAssoc.GetEntriesSize();
        groupAssoc.SetEntriesSize(firstgroup+newGroupCount, 0, COL_EMPTY_NEW_ENTRIES|COL_KEEP_ENTRIES);
        return firstgroup;
    }
 
    bool RemoveGroup(unsigned int group)
    {
        if (group >= groupAssoc.GetEntriesSize())
            return false;
 
        int i, size;
        MAPTYPE *assoc = groupAssoc.GetEntry(group, size);
        for (i=0; i<size; i++)
            indexToGroup.Remove(assoc[i]);
 
        groupAssoc.SetEntrySize(group, 0); // We must keep the same number of entry, otherwise indexToGroup contains bad group indexes
 
        return true;
    }
 
    bool MergeGroup(unsigned int dstgroup, unsigned int srcgroup)
    {
        if (dstgroup >= groupAssoc.GetEntriesSize())
            return false;
 
        if (srcgroup >= groupAssoc.GetEntriesSize())
            return false;
 
        int i, srcsize, dstsize, tmp;
        groupAssoc.GetEntry(srcgroup, srcsize);
        groupAssoc.GetEntry(dstgroup, dstsize);
        
        groupAssoc.SetEntrySize(dstgroup, dstsize+srcsize); // preallocate size before getting entry access, but it could resize the array and make the value being invalid
 
        MAPTYPE *srcassoc = groupAssoc.GetEntry(srcgroup, srcsize);
        MAPTYPE *dstassoc = groupAssoc.GetEntry(dstgroup, tmp);
        for (i=0; i<srcsize; i++)
        {
            indexToGroup.Insert(srcassoc[i], dstgroup); // Replace previous value
            dstassoc[dstsize+i] = srcassoc[i];
        }
 
        groupAssoc.SetEntrySize(srcgroup, 0); // We must keep the same number of entry, otherwise indexToGroup contains bad group indexes
 
        return true;
    }
 
    unsigned int AddElementInGroup(unsigned int group, MAPTYPE element)
    {
        indexToGroup.Insert(element, group);
        XASSERT(group < groupAssoc.GetEntriesSize());
        return groupAssoc.AddElementInEntry(group, element);
    }
 
    bool RemoveElementByIndexPos(MAPTYPE element, int indexpos) // faster the RemoveElement, if we know indexpos
    {
        unsigned int group = GetGroupIndex(element);
        if (group == GROUPMAP_NOINDEX)
            return false;
 
        indexToGroup.Remove(element);
 
#ifdef _DEBUG
        int size;
        MAPTYPE *assoc = groupAssoc.GetEntry(group, size);
        XASSERT(indexpos < size && assoc[indexpos] == element);
#endif
 
        groupAssoc.RemoveElementInEntry(group, indexpos);
        return true;
    }
    
    bool RemoveElement(MAPTYPE element)
    {
        unsigned int group = GetGroupIndex(element);
        if (group == GROUPMAP_NOINDEX)
            return false;
 
        indexToGroup.Remove(element);
 
        int i, size;
        MAPTYPE *assoc = groupAssoc.GetEntry(group, size);
        for (i = 0; i<size; i++)
        {
            if (assoc[i] == element)
            {
                groupAssoc.RemoveElementInEntry(group, i);
                return true;
            }
        }
 
        XASSERT(0); // Should have been found
        return false;
    }
 
    unsigned int GetGroupCount() const
    {
        return groupAssoc.GetEntriesSize();
    }
 
    unsigned int GetGroupIndex(MAPTYPE element) const
    {
        unsigned int group = GROUPMAP_NOINDEX;
        indexToGroup.Find(element, group);
        return group;
    }
 
    const MAPTYPE *GetGroup(unsigned int groupIndex, int& size) const
    {
        if (groupIndex >= groupAssoc.GetEntriesSize())
        {
            size = 0;
            return NULL;
        }
 
        return groupAssoc.GetEntry(groupIndex, size);
    }
 
    unsigned int GetGroupSize(unsigned int groupIndex) const
    {
        if (groupIndex >= groupAssoc.GetEntriesSize())
            return 0;
 
        int size;
        groupAssoc.GetEntry(groupIndex, size);
        return size;
    }
 
    const CGroupMap& operator=(const CGroupMap &copyFrom)
    {
        if (this != &copyFrom)
        {
            this->indexToGroup = copyFrom.indexToGroup;
            this->groupAssoc.Copy(copyFrom.groupAssoc);
        }
 
        return *this;
    }
};
 
END_MOOTOOLS_NAMESPACE
 
#endif // CASSOCIATIONMAP_CLASS_H