CMap et serialisation

**MarieMtl** · 25/01/2006, 22h30

Bonjour,

Est il possible de serialiser un objet contenant une CMap, avec pour chaque elements de ma CMap une autre CMap.
Pour etre plus claire peut etre :
J'ai un objet MonObjet qui contient une CMap d'objet Toto. Un objet Toto contient lui aussi une CMap d'objet Tata.

Est ce possible d'archiver le tout ? MonObjet en entier ???

J'ai essayer de mettre cela en place et pour l'instant, MonObjet est archive ainsi que la CMap d'objets Toto mais mes CMap d'objets Tata sont vides.

Merci de votre aide,
Marie.

**farscape** · 25/01/2006, 23h00

salut ,
oui c'est possible

http://c.developpez.com/faq/vc/?page...HowToSerialize

**MarieMtl** · 25/01/2006, 23h32

Oui, je me suis base la dessus pour creer mon archive.
Sauf que j'arrive a archiver et recuperer la premiere CMap mais pas les CMap contenu dans chaque element de ma premiere CMap.

Voici les fonctions que j'utilise :
Premiere CMap

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
template <>  void AFXAPI SerializeElements <CLcmTab> (CArchive& ar, CLcmTab * pItem, int nCount)
{
    for ( int i = 0; i < nCount; i++, pItem++ )            
        pItem->Serialize( ar );    
}

Seconde(s) CMap

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
template <> void AFXAPI SerializeElements <CLcmWindow> (CArchive& ar, CLcmWindow * pItem, int nCount)
{
    for ( int i = 0; i < nCount; i++, pItem++ )            
        pItem->Serialize(ar);    
}

Dans la methode Serialize de mon objet, je fais un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 m_mapTab.Serialize(ar);

Puis dans la methode serialise de mon objet LcmTab je fais un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 m_mapWindow.Serialize(ar);

Une idee ?

Marie.

**farscape** · 26/01/2006, 20h43

bonsoir,
il me manque des infos : la declaration des classes en jeux .
et des CMap.

**MarieMtl** · 30/01/2006, 16h17

Voici le .h de mon objet LCMWindow (debarassee des divers commentaires)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// LcmWindow.h: interface for the CLcmWindow class.
#if !defined(AFX_LCMWINDOW_H__E56875DF_4EE7_4220_9FDE_B70BEB2D0ECC__INCLUDED_)
#define AFX_LCMWINDOW_H__E56875DF_4EE7_4220_9FDE_B70BEB2D0ECC__INCLUDED_
 
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
 
class CLcmWindow : public CObject  
{
 
public:
	DECLARE_SERIAL(CLcmWindow)
 
	BOOL m_open;
	CString m_typeClass;
	WINDOWPLACEMENT m_sizePosition;
 
	CLcmWindow();
	CLcmWindow(CString, WINDOWPLACEMENT);
	virtual ~CLcmWindow();
	void Clear();
 
	CLcmWindow(const CLcmWindow &);
 
	const CLcmWindow& operator=(const CLcmWindow &);
	void setSizePosition(WINDOWPLACEMENT);
	void setOpen();
	void setClose();
	void Serialize(CArchive & ar);
};
 
template<> void AFXAPI SerializeElements<CLcmWindow> (CArchive& ar, CLcmWindow * pElements, int nCount);
 
#endif // !defined(AFX_LCMWINDOW_H__E56875DF_4EE7_4220_9FDE_B70BEB2D0ECC__INCLUDED_)

Voici le .h de l'objet LcmTab

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
// LcmTab.h: interface for the CLcmTab class.
#if !defined(AFX_LCMTAB_H__D943494E_233B_4D99_8045_FAC72BADCB9B__INCLUDED_)
#define AFX_LCMTAB_H__D943494E_233B_4D99_8045_FAC72BADCB9B__INCLUDED_
 
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
 
class CLcmTab : public CObject  
{
public:
	DECLARE_SERIAL(CLcmTab)
 
	CString m_strName;
	int m_intIcone;
	CMap <CString, LPCSTR, CLcmWindow, CLcmWindow&> m_mapFrame;
	CMap<CString, LPCSTR, CLcmWindow, CLcmWindow&> m_mapDefaultValuesFrame;
 
	CString m_strActiveFrame;
	CLcmTab(CString, int);
 
	CLcmTab();
	virtual ~CLcmTab();
	void Clear();
 
	CLcmTab(const CLcmTab &);
	const CLcmTab& operator=(const CLcmTab &);
	void AddLcmWindow(CLcmWindow);
	void AddLcmWindow(CString, WINDOWPLACEMENT);
	CLcmWindow * GetLcmWindow(CString);
	CString GetActiveLcmWindow();
	void SetActiveLcmWindow(CString);
	void Serialize(CArchive &ar);
 
};
 
template<> void AFXAPI SerializeElements<CLcmTab> (CArchive& ar, CLcmTab * pElements, int nCount);
 
#endif // !defined(AFX_LCMTAB_H__D943494E_233B_4D99_8045_FAC72BADCB9B__INCLUDED_)

Voici la CMap de Lcmtab

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

CMap < CString, LPCSTR, CLcmTab, CLcmTab & > m_mapTab;

Marie.

**farscape** · 30/01/2006, 19h44

Pour la serialisation d'une CMap il te faut serialiser la clef et la data ,sinon c'est normal que ta CMap soit vide ...
pour bien comprendre voici un extrait MFC de la fonction serialize d'une CMap:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
template<class KEY, class ARG_KEY, class VALUE, class ARG_VALUE>
void CMap<KEY, ARG_KEY, VALUE, ARG_VALUE>::Serialize(CArchive& ar)
{
	ASSERT_VALID(this);
 
	CObject::Serialize(ar);
 
	if (ar.IsStoring())
	{
		ar.WriteCount(m_nCount);
		if (m_nCount == 0)
			return;  // nothing more to do
 
		ASSERT(m_pHashTable != NULL);
		for (UINT nHash = 0; nHash < m_nHashTableSize; nHash++)
		{
			CAssoc* pAssoc;
			for (pAssoc = m_pHashTable[nHash]; pAssoc != NULL;
			  pAssoc = pAssoc->pNext)
			{
				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& >( pAssoc->key ) ) ) );
				pValue = reinterpret_cast< VALUE* >( &reinterpret_cast< int& >( static_cast< VALUE& >( pAssoc->value ) ) );
				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);
			SetAt(newKey[0], newValue[0]);
		}
	}
}

on voit bien que lors de la sauvegarde (isStoring()) SerializeElements est appelée deux une pour la clef et la data .
pareil pour la lecture suivie d'un SetAt pour remplir la CMap...

**farscape** · 30/01/2006, 21h05

bon precision ,les types de bases comme les CString sont traités donc pas besoin de spécialisation pour ce type .
le code devrait fonctionner ...
on est d'accord sur le fait que tu as implementé correctement le constructeur de copie et l'operateur d'affectation?
fait voir ce que tu as mis dans la fonction serialize de la classe CLcmTab.

j'ai fait un essai rapide avec l'exemple de la faq ça fonctionne.

**MarieMtl** · 30/01/2006, 22h06

Je n'utilise pas de methode CopyFrom, ni pour l'un ni pour l'autre et voici comment j'ai implemente mes methodes pour CLcmWindow (celui dont la serialisation de la map ne fonctionne pas)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
CLcmWindow::CLcmWindow(const CLcmWindow &_newWind)
{
     *this = _newWind;
 
}
//------------------------------------------------------------------------------------------
const CLcmWindow& CLcmWindow::operator=(const CLcmWindow &_newWind)
{
	m_sizePosition = _newWind.m_sizePosition;
	m_typeClass = _newWind.m_typeClass;
	m_open = _newWind.m_open;
 
    return *this;
}
//-----------------------------------------------------------------------------------
void CLcmWindow::Serialize(CArchive & ar) {
 
	if (ar.IsStoring()) {
// Attention, n'archive pas la structure WINDOWPOS
		ar<<m_typeClass<<m_open;
 
	}
	else {
		ar>>m_typeClass>>m_open;
	}
}

**farscape** · 31/01/2006, 06h42

ok (meme si tu aurais pu tester que &_newWind!=this) mais c'est l'implémentation dans la classe CLcmTab que je voulais voir ..

**MarieMtl** · 31/01/2006, 15h28

Voila ma methode de serialisation dans LcmTab

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void CLcmTab::Serialize(CArchive &ar) {
 
	if (ar.IsStoring()) {
 
		ar<<m_strName<<m_intIcone<<m_strActiveFrame;
 
		m_mapFrame.Serialize(ar);
 
	}
	else {
 
		ar>>m_strName>>m_intIcone>>m_strActiveFrame;
 
		m_mapFrame.Serialize(ar);
 
	}
 
}

Marie.

**farscape** · 31/01/2006, 15h40

pourquoi m_mapDefaultValuesFrame n'est pas serialisée ?
et montre moi l'operateur d'affection et le constructeur de copie de cette classe ...
(je crois que la ça devrait etre bon lol)

**MarieMtl** · 31/01/2006, 16h20

mapDefaultValuesFrame est une map des valeurs par defaut des fenetres (taille et position). Ca ne necessite pas l'archivage (ici j'archive l'espace de travail pour chaque document) , on peut les assimiler a des constantes que l'on recupere d'un fichier ini par ex.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
const CLcmTab& CLcmTab::operator=(const CLcmTab &_newTab)
{
    m_strName = _newTab.m_strName;
	m_intIcone = _newTab.m_intIcone;
 
    return *this;
 
}
CLcmTab::CLcmTab(CString _strName, int _intIcone)
{
	m_strName = _strName;
	m_intIcone = _intIcone;
}

Je crois que j'ai compris mon erreur, je dois egalement affecter ma map ?

Marie.

**farscape** · 31/01/2006, 16h58

Envoyé par MarieMtl

mapDefaultValuesFrame est une map des valeurs par defaut des fenetres (taille et position). Ca ne necessite pas l'archivage (ici j'archive l'espace de travail pour chaque document) , on peut les assimiler a des constantes que l'on recupere d'un fichier ini par ex.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
const CLcmTab& CLcmTab::operator=(const CLcmTab &_newTab)
{
    m_strName = _newTab.m_strName;
	m_intIcone = _newTab.m_intIcone;
 
    return *this;
 
}
CLcmTab::CLcmTab(CString _strName, int _intIcone)
{
	m_strName = _strName;
	m_intIcone = _intIcone;
}

Je crois que j'ai compris mon erreur, je dois egalement affecter ma map ?

Marie.

oui

,(il faudra itera sur la map d'origine pas de copie en direct)le mieux etant de faire une fonction comme dans la faq pour ecrire le code qu'une seule fois ...

**MarieMtl** · 31/01/2006, 18h01

Impec' !!! Ca fonctionne ...

Merci,
Marie.

CMap et serialisation

MFC

Discussions similaires

Partager

Partager