0

Looking at table on http://msdn.microsoft.com/en-us/library/y1z022s1%28v=vs.80%29.aspx#_core_collection_shape_features

I can not see a MFC collection for the purpose I need.

The CMap documentation on http://msdn.microsoft.com/en-us/library/s897094z%28v=vs.80%29.aspx also states that

"You might think that this iteration is sequential by key value; it is not. The sequence of retrieved elements is indeterminate."

as I would expect from a thing I presume it uses hashing algorhitms.

What I need, is a dictionary that has the following features:

  • Ordered (by an int, for example) - Purpose: Swapping elements of order and also getting them following the sequence that was stated
  • Seems to me this even doesn´t even need to be a "real key" - I really don't need those crazy hashing algorhitms for fast access. And , the question of accessing elements by key, it seems I don't need it for now, but I can only answer securely to this when beginning to use it.
  • Don't need fast insert, delete, update, etc.
  • Don't need fast search of a specified element
  • key unicity

I wonder how many times I can apply this pattern in real apps. What is the best solution you can suggest me for this?

Note: I had the same problem in C# also, some time ago. Solutions for it are also welcome. If I recall correctly SortedDictionary is sorted on the key, so it is not suitable.

EDIT: Even if it would be preferable - only for the sake of not being dissonant with the already existing code base - to use a thing from MFC, it is not an obligation. So you can suggest whatever you want, if it is standard C++.

EDIT2: For improving the clarity: the description of each element of the container would be

{
     int Unique NonNullable OrderIndex,
     enum KeyEnum Unique NonNullable key, 
     enum ValueEnum NotUnique NonNullable value
}

If it is implemented as something like a dynamic array, I really don't even care about storing the OrderIndex. For this one, I really only need a unique value that indicates the relative position and have the possibilty to swap elements of position.

Thanks in advance,

Sérgio

sergiol
  • 4,122
  • 4
  • 47
  • 81
  • Even looking at this diagram http://stackoverflow.com/questions/471432/in-which-scenario-do-i-use-a-particular-stl-container I can't say what would be the best one to use in my question – sergiol Feb 24 '12 at 19:42
  • Some interesting debate is going on here: http://stackoverflow.com/questions/1504451/how-to-implement-a-multi-index-dictionary – sergiol Feb 26 '12 at 14:59

5 Answers5

1

MFC doesn't provide a container that does what you need, but you can use std::map or std::set instead. Each will keep the keys unique; which you choose will depend on whether you want your key separated from the payload or integrated into a single object.

Mark Ransom
  • 299,747
  • 42
  • 398
  • 622
0

I decided to derive a templated class from both CMap and CArray and write the ArrayMapTempl.h file as follows:

//Author: Sérgio Loureiro. This is open source.

#include <afxtempl.h>

template<class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
class CArrayMap: protected CArray<KEY,ARG_KEY>, protected CMap<KEY, ARG_KEY, VALUE, ARG_VALUE>
{
private:
    bool m_isChangingSize;
public:
    CArrayMap():
      m_isChangingSize(false)
    {
    };

    CArrayMap(const CArrayMap& src){};
    CArrayMap operator=(const CArrayMap& src){return *this;};

    // Attributes
    INT_PTR GetSize() const;
    INT_PTR GetCount() const;
    BOOL IsEmpty() const;
    INT_PTR GetUpperBound() const;

    // Lookup
    int Lookup(ARG_KEY key) const;
    int Lookup(ARG_KEY key, VALUE& rValue) const;

// Operations
    // Clean up
    void RemoveAll();

    // Accessing elements
    const CPair& GetAt(INT_PTR nIndex) const;
    CPair& GetAt(INT_PTR nIndex);
    void SetAt(INT_PTR nIndex, ARG_KEY newKey, ARG_VALUE newValue);
    const CPair& ElementAt(INT_PTR nIndex) const;
    CPair& ElementAt(INT_PTR nIndex);

    // Direct Access to the element data
    const CPair& GetData() const;
    CPair& GetData();

    // Potentially growing the array
    INT_PTR Add(ARG_KEY newKey, ARG_VALUE newValue);
    void Copy(const CArrayMap& src);

    // overloaded operator helpers
    const CPair& operator[](INT_PTR nIndex) const;
    CPair& operator[](INT_PTR nIndex);

    // Operations that move elements around

    BOOL Swap(INT_PTR nIndex, INT_PTR nIndex2);
    BOOL MoveUp(INT_PTR nIndex);
    BOOL MoveDown(INT_PTR nIndex);

    BOOL SwapByKey(ARG_KEY key, ARG_KEY key2);
    BOOL MoveUpByKey(ARG_KEY key);
    BOOL MoveDownByKey(ARG_KEY key);

    BOOL InsertAt(INT_PTR nIndex, ARG_KEY newKey, ARG_VALUE newValue);
    BOOL RemoveAt(INT_PTR nIndex);
    BOOL RemoveByKey(ARG_KEY key);


public:
    void Serialize(CArchive&);
#ifdef _DEBUG
    void Dump(CDumpContext&) const;
    void AssertValid() const;
#endif

#if 0   
public:
// Construction
    CArray();

// Attributes
    INT_PTR GetSize() const;
    INT_PTR GetCount() const;
    BOOL IsEmpty() const;
    INT_PTR GetUpperBound() const;
    void SetSize(INT_PTR nNewSize, INT_PTR nGrowBy = -1);

// Operations
    // Clean up
    void FreeExtra();
    void RemoveAll();

    // Accessing elements
    const TYPE& GetAt(INT_PTR nIndex) const;
    TYPE& GetAt(INT_PTR nIndex);
    void SetAt(INT_PTR nIndex, ARG_TYPE newElement);
    const TYPE& ElementAt(INT_PTR nIndex) const;
    TYPE& ElementAt(INT_PTR nIndex);

    // Direct Access to the element data (may return NULL)
    const TYPE* GetData() const;
    TYPE* GetData();

    // Potentially growing the array
    void SetAtGrow(INT_PTR nIndex, ARG_TYPE newElement);
    INT_PTR Add(ARG_TYPE newElement);
    INT_PTR Append(const CArray& src);
    void Copy(const CArray& src);

    // overloaded operator helpers
    const TYPE& operator[](INT_PTR nIndex) const;
    TYPE& operator[](INT_PTR nIndex);

    // Operations that move elements around
    void RemoveAt(INT_PTR nIndex, INT_PTR nCount = 1);
    void InsertAt(INT_PTR nStartIndex, CArray* pNewArray);

// Implementation
protected:
    TYPE* m_pData;   // the actual array of data
    INT_PTR m_nSize;     // # of elements (upperBound - 1)
    INT_PTR m_nMaxSize;  // max allocated
    INT_PTR m_nGrowBy;   // grow amount

public:
    ~CArray();
    void Serialize(CArchive&);
#ifdef _DEBUG
    void Dump(CDumpContext&) const;
    void AssertValid() const;
#endif
#endif

//----------------------------------------------------------------------------------------
#if 0
public:
    // CPair
    struct CPair
    {
        const KEY key;
        VALUE value;
    protected:
        CPair( ARG_KEY keyval ) : key( keyval ) {}
    };

protected:
    // Association
    class CAssoc : public CPair
    {
        friend class CMap<KEY,ARG_KEY,VALUE,ARG_VALUE>;
        CAssoc* pNext;
        UINT nHashValue;  // needed for efficient iteration
    public:
        CAssoc( ARG_KEY key ) : CPair( key ) {}
    };

public:
// Construction
    /* explicit */ CMap(INT_PTR nBlockSize = 10);

// Attributes
    // number of elements
    INT_PTR GetCount() const;
    INT_PTR GetSize() const;
    BOOL IsEmpty() const;

    // Lookup
    BOOL Lookup(ARG_KEY key, VALUE& rValue) const;
    const CPair *PLookup(ARG_KEY key) const;
    CPair *PLookup(ARG_KEY key);

// Operations
    // Lookup and add if not there
    VALUE& operator[](ARG_KEY key);

    // add a new (key, value) pair
    void SetAt(ARG_KEY key, ARG_VALUE newValue);

    // removing existing (key, ?) pair
    BOOL RemoveKey(ARG_KEY key);
    void RemoveAll();

    // iterating all (key, value) pairs
    POSITION GetStartPosition() const;

    const CPair *PGetFirstAssoc() const;
    CPair *PGetFirstAssoc();

    void GetNextAssoc(POSITION& rNextPosition, KEY& rKey, VALUE& rValue) const;

    const CPair *PGetNextAssoc(const CPair *pAssocRet) const;
    CPair *PGetNextAssoc(const CPair *pAssocRet);

    // advanced features for derived classes
    UINT GetHashTableSize() const;
    void InitHashTable(UINT hashSize, BOOL bAllocNow = TRUE);

// Implementation
protected:
    CAssoc** m_pHashTable;
    UINT m_nHashTableSize;
    INT_PTR m_nCount;
    CAssoc* m_pFreeList;
    struct CPlex* m_pBlocks;
    INT_PTR m_nBlockSize;

    CAssoc* NewAssoc(ARG_KEY key);
    void FreeAssoc(CAssoc*);
    CAssoc* GetAssocAt(ARG_KEY, UINT&, UINT&) const;

public:
    ~CMap();
    void Serialize(CArchive&);
#ifdef _DEBUG
    void Dump(CDumpContext&) const;
    void AssertValid() const;
#endif
#endif

};

template <class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
inline INT_PTR CArrayMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::GetSize() const
{
    ASSERT(CArray::m_nSize == CMap::m_nCount);
    return CArray::GetSize();
};


template <class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
inline INT_PTR CArrayMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::GetCount() const
{
    ASSERT(CArray::m_nSize == CMap::m_nCount);
    return CArray::GetCount();
}


template <class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
inline BOOL CArrayMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::IsEmpty() const
{ 
    ASSERT(CArray::m_nSize == CMap::m_nCount);
    return CArray::IsEmpty();
}

template <class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
inline INT_PTR CArrayMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::GetUpperBound() const
{ 
    ASSERT(CArray::m_nSize == CMap::m_nCount);
    return CArray::GetUpperBound();
}


template <class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
inline INT_PTR CArrayMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::Add(ARG_KEY newKey, ARG_VALUE newValue)
{ 
    VALUE rValue;
    if( CMap::Lookup(newKey,rValue))    //already exists
        return -1;

    INT_PTR nIndex = CArray::m_nSize;   //old size will be the new position

    m_isChangingSize= true;
    CMap::operator[] (newKey)= newValue;
    CArray::Add(newKey);
    m_isChangingSize= false;

    ASSERT(CArray::m_nSize == CMap::m_nCount);
    return nIndex;
};


template <class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
inline const typename CMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::CPair&
    CArrayMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::GetAt(INT_PTR nIndex) const
{ 
    ASSERT(nIndex >= 0 && nIndex < m_nSize);
    if(nIndex >= 0 && nIndex < m_nSize)
    {
        return *CMap::PLookup(CArray::GetAt(nIndex));
    }
    AfxThrowInvalidArgException();
};


template <class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
inline typename CMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::CPair&
    CArrayMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::GetAt(INT_PTR nIndex)
{ 
    ASSERT(nIndex >= 0 && nIndex < m_nSize);
    if(nIndex >= 0 && nIndex < m_nSize)
    {
        return *CMap::PLookup(CArray::GetAt(nIndex));
    }
    AfxThrowInvalidArgException();
};

template<class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
int CArrayMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::Lookup(ARG_KEY key) const
{
    VALUE rValue;
    return this->Lookup(key, rValue);
};

template<class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
int CArrayMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::Lookup(ARG_KEY key, VALUE& rValue) const
{
    for (int i=0; i<m_nSize ;i++)
    {
        if(CArray::operator [] ( i ) == key && CMap::Lookup(key, rValue))
        {
            return i;
        }
    }
    return -1;
};


template <class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
void CArrayMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::RemoveAll()
{
    m_isChangingSize=true;
    CMap::RemoveAll();
    CArray::RemoveAll();
    m_isChangingSize=false;

    ASSERT(CArray::m_nSize == CMap::m_nCount);
};



template <class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
BOOL CArrayMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::Swap(INT_PTR nIndex, INT_PTR nIndex2)
{
    if(nIndex<0 || nIndex2<0)
        return FALSE;

    if(nIndex>=m_nSize || nIndex2>=m_nSize)
        return FALSE;

    //Swap with itself. Everything is fine and nothing needs to be done
    if(nIndex == nIndex2)
        return TRUE;

    KEY k= CArray::GetAt(nIndex);
    CArray::SetAt(nIndex, CArray::GetAt(nIndex2));
    CArray::SetAt(nIndex, k);
};

template <class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
BOOL CArrayMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::MoveUp(INT_PTR nIndex)
{
    if (nIndex == 0)
        return FALSE;
    return Swap(nIndex,nIndex-1);
};

template <class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
BOOL CArrayMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::MoveDown(INT_PTR nIndex)
{
    if (nIndex == m_nSize-1)
        return FALSE;
    return Swap(nIndex,nIndex+1);
};

template <class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
BOOL CArrayMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::SwapByKey(ARG_KEY key, ARG_KEY key2)
{
    int nIndex= Lookup(key);
    int nIndex2= Lookup(key2);
    if(nIndex == -1 || nIndex2 == -1)
        return FALSE;

    return Swap(nIndex,nIndex2);
}

template <class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
BOOL CArrayMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::MoveUpByKey(ARG_KEY key)
{
    int nIndex= Lookup(key);
    if(nIndex == -1)
        return FALSE;

    return MoveUp(nIndex);
}

template <class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
BOOL CArrayMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::MoveDownByKey(ARG_KEY key)
{
    int nIndex= Lookup(key);
    if(nIndex == -1)
        return FALSE;

    return MoveDown(nIndex);
}



template <class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
int CArrayMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::InsertAt(INT_PTR nIndex,ARG_KEY newKey, ARG_VALUE newValue)
{

    AssertValid();          //ASSERT_VALID(this);

    if(nIndex < 0)
        return FALSE;   //AfxThrowInvalidArgException();

    if(nIndex > m_nSize)    //doesn't make sense to grow more than last+1 , given newKey has to be unique
        return FALSE;

    //I am not using this->Lookup(ARG_KEY key), because I 
    //presume CMap::Lookup(ARG_KEY key, VALUE& rValue) will be faster,
    //as it does not need to traverse the array.    

    VALUE rValue;
    if(CMap::Lookup(newKey,rValue)) //already exists
        return FALSE;

    m_isChangingSize=true;
    CMap::operator[] (newKey)= newValue;
    CArray::InsertAt(nIndex,newKey,1);
    m_isChangingSize=false;

    ASSERT(CArray::m_nSize == CMap::m_nCount);
    return TRUE;
}


template <class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
BOOL CArrayMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::RemoveAt(INT_PTR nIndex)
{
    if(nIndex<0 || nIndex>= m_nSize)
        return FALSE;

    KEY k= CArray::GetAt(nIndex);

    //I am not using this->Lookup(ARG_KEY key), because I 
    //presume CMap::Lookup(ARG_KEY key, VALUE& rValue) will be faster,
    //as it does not need to traverse the array.    

    VALUE rValue;
    if(CMap::Lookup(k,rValue))  //already exists
    {
        m_isChangingSize= true;
        CMap::RemoveKey(k);
        CArray::RemoveAt(nIndex);
        m_isChangingSize= false;

        ASSERT(CArray::m_nSize == CMap::m_nCount);
        return TRUE;
    }
    else
        return FALSE;
};

template <class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
BOOL CArrayMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::RemoveByKey(ARG_KEY key)
{
    int nIndex= Lookup(key);
    if(nIndex == -1)
        return FALSE;

    KEY k= CArray::GetAt(nIndex);

    return RemoveAt(nIndex);
};


template<class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
void CArrayMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::Serialize(CArchive& ar)
{
    ASSERT(CArray::m_nSize == CMap::m_nCount);
    //ASSERT_VALID((const CArray *)this);
    //ASSERT_VALID((const CMap *)this);

    CObject::Serialize(ar);

    if (ar.IsStoring())
    {
        ar.WriteCount(m_nSize);
        if (m_nSize == 0)
            return;  // nothing more to do

        for(INT_PTR i=0;i<m_nSize;i++)
        {
            KEY* pKey;
            VALUE* pValue;
            /* 
             * in some cases the & operator might be overloaded, and we cannot use it to 
             * obtain the address of a given object.  We then use the following trick to 
             * get the address
             */
            pKey = reinterpret_cast< KEY* >( &reinterpret_cast< int& >( const_cast< KEY& > ( static_cast< const KEY& >( CArray::operator[]( i ) ) ) ) );
            pValue = reinterpret_cast< VALUE* >( &reinterpret_cast< int& >( static_cast< VALUE& >( CMap::operator[]( *pKey ) ) ) );
            SerializeElements<KEY>(ar, pKey, 1);
            SerializeElements<VALUE>(ar, pValue, 1);
        }
    }
    else
    {
        DWORD_PTR nNewCount = ar.ReadCount();
        while (nNewCount--)
        {
            KEY newKey[1];
            VALUE newValue[1];
            SerializeElements<KEY>(ar, newKey, 1);
            SerializeElements<VALUE>(ar, newValue, 1);
            this->Add(newKey[0], newValue[0]);  //includes checking if it already exists
        }
    }
}

#ifdef _DEBUG
template<class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
void CArrayMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::Dump(CDumpContext& dc) const
{
    ASSERT(CArray::m_nSize == CMap::m_nCount);

    CObject::Dump(dc);

    dc << "with " << m_nSize << " elements";
    if (dc.GetDepth() > 0)
    {
        // Dump in format "[key] -> value"
        KEY key[1];
        VALUE val[1];

        POSITION pos = GetStartPosition();
        while (pos != NULL)

        for (int i=0; i<m_nSize; i++)
        {
            key[0]= CArray::operator[]( i );

            //val[0]= CMap::operator[]( key[0] );
            CMap::Lookup(key[0], val[0]);

            dc << "\n\t[";
            DumpElements<KEY>(dc, key, 1);
            dc << "] = ";
            DumpElements<VALUE>(dc, val, 1);
        }
    }

    dc << "\n";
}

template<class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
void CArrayMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::AssertValid() const
{
    CArray::AssertValid();
    CMap::AssertValid();

    if(!m_isChangingSize)   
        ASSERT(CArray::m_nSize == CMap::m_nCount);
}

#endif //_DEBUG

Now I have everything I need. I didn't test everything, but I believe that only little corrections will be needed, if needed.

Anyway, thank you all for the answers and comments.

sergiol
  • 4,122
  • 4
  • 47
  • 81
0

When you say 'Ordered' you are already indirectly implying that 'order index' is the 'key' which is unique. Why can't you use std::vector?

If you want to have another unique key than you can use std::map but you will have to improvise 'order' as part of the key/value combination. I see the ultimate solution will be something composite. You will have your own class to support what you want which in tern may std::map to implement this or any other contain like list.

zar
  • 11,361
  • 14
  • 96
  • 178
  • Comment for improving the clarity to people incoming: I want both unicity of KeyEnum and OrderIndex; and NO, I don't want unicity of the pair but unicity of each one. – sergiol Feb 25 '12 at 01:10
0

After this conversation on C++ Freenode's IRC channel, I feel tempted to try Boost Multi index (zxvf is me):

zxvf            hello
zxvf            I was trying to solve the problem of this question: http://stackoverflow.com/questions/9329011/mfc-dictionary-collection-with-key-unicity-and-ordering-by-position/9438561#9438561
zxvf            what kind of container would you recommend to me?
TinoDidriksen   std::vector sounds fitting.
zxvf            you can not guarantee unicity of keyEnum, TinoDidriksen
MrBar       zxvf: so use std::map then
zxvf            MrBar: I think you all didn't get the point of the problem
evilissimo  I think you'd need something like boost multi_index
zxvf            I want both unicity of KeyEnum and OrderIndex 
MrBar       zxvf: i get point, but that container u asked about not exist
TinoDidriksen   zxvf, Boost.Multi_index then.
evilissimo  zxvf, by unicity you mean that there are at no given time two of any of them in the container?
evilissimo  or by the combination?
MrBar       zxvf: u need to use intermix of containers
zxvf            and NO, I don't want unicity of the pair <OrderIndex, KeyEnum> but unicity of each one
evilissimo  zxvf, had to ask
                zxvf seeing what the heck is Boost Multi index
MrBar       zxvf: noooo, not see in boost there no back way
zxvf            MrBar, could you rephrase please?
zxvf            Not english native speaker, me
evilissimo  zxvf, that wasn't even valid english
MrBar       zxvf: hmm i too
evilissimo  zxvf, basically there are tons of useful stuff in boost, and usually once you start loving one library you start using more of them 
zxvf            thanks, people. It's aready late here and I will not see this tonight. But seems to me that Boost Multi index is a very good help for me
sergiol
  • 4,122
  • 4
  • 47
  • 81
  • Sems that for C# someone has managed to do a thing like Boost Multi index: http://www.codeproject.com/Articles/18864/Multi-Index-Container-for-C-2-0 . Seems that is much less powerful. – sergiol Feb 26 '12 at 14:51
  • For C# also, there is a gui that as done a MultiKeyDictionary: http://www.codeproject.com/Articles/32894/C-Multi-key-Generic-Dictionary – sergiol Feb 26 '12 at 15:03
0

Use an array and store the index in the array as an element of your value. Use another CMap for fast hash access if you need. The maps i know and heared off all d o not support an Order Index number.

Lothar
  • 12,537
  • 6
  • 72
  • 121
  • What I was doing is a class with multiple inheritance from both CArray and CMap. It is pratically done, only lacks the worst part: testing it. – sergiol Mar 01 '12 at 01:47