Discussion :

[camboui]

Voici le genre de chose que je faisais et fais encore

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#pragma pack(1)
struct record
{
char name[20];
unsigned id,seq;
};
 
record r;
strcpy(r.name,s.c_str());// bof bof...
r.id=25;
r.seq=10;
...
file.write(&r,sizeof(record));

A la longue c'est fastidieux et on se retrouve avec des dizaines si pas des centaines de structures en tout genre avec à chaque fois des kilomètres de code pas très fiable associés à chaque structure. Bref, c'est du C, pas vraiment du C++.

J'ai vu un peu comment était construit boost::serialize avec la méthode intrusive serialize(). Le principe est très sympa.
J'aimerais m'en inspirer pour généraliser quelque chose de ce genre:

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
struct record
{
std::string name;
unsigned id,seq;
 
void serialize_record(archive_record & a)
{
 a & name & id;
}
 
void serialize_keysort(archive_keysort & a,int keynumber)
{
 switch (keynumber)
 {
  case 0: a & id; break;
  case 1: a & name & seq; break;
 }
}
 
void serialize_keysearch(archive_keysearch & a,int keynumber)
{
 switch (keynumber)
 {
  case 0: a & id; break;
  case 1: a & name; break;
 }
}
};

En gros, j'ai des records à stocker avec une ou plusieurs clé de tri (et donc de recherche). Dans l'exemple j'ai "name" et "id" qui sont des infos utiles à stocker, et les deux participent chacune dans une clé de tri. Au delà, il y a aussi "seq" mais qui n'est utile que pour imposer une sequencement ordonné dans une des clés, après je n'en ai plus besoin.

Un petite aide pour poursuivre ma réflexion serait bienvenue. Et surtout s'il existe déjà du tout fait, c'est encore mieux
Merci.

[camboui]

Bon ben il semble que cela n'inspire personne
Vous ne faites jamais de la gestion de fichiers un peu élaborée, ou de bd "custom" ?

Bah, j'ai un peu simplifié mon modéle de réflexion. Mon truc avec les clés est un peu compliqué, j'ai simplifié en ceci pour n'avoir qu'une clé par structure:

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
struct record
{
std::string name;
unsigned id;
 
template <class archive_record>
void serialize_record(archive_record & a)
{
 a & name & id;
}
 
template <class archive_key>
void serialize_key(archive_key & a)
{
  a & id;
}
};

[Mac LAK]

En général, vu le niveau auquel je travaille (bas niveau), j'applique le plus souvent deux choses totalement disjointes :

• Je sérialise "brutalement" un attribut de ma classe, qui est la plupart du temps une structure packed servant de container interne à la classe, via la surcharge de "<<" et ">>" sur la classe elle-même, ou carrément via des fread/fwrite (je sais, c'est mal, m'en fous). Ça, c'est pour ce qui tourne tout le temps, genre stockage brutal, communications réseau intensives, etc.
• Si c'est de la configuration initiale, j'utilise plutôt de l'XML avec des wrappers automatiques depuis le schéma XSD, qui valide au maximum possible les fichiers XML afin de m'éviter d'avoir à le faire au niveau applicatif.

Si ça peut t'aider...

[camboui]

OK, merci.

Je vais me débrouiller et je ferai part de mes résutats si ça intéresse quelqu'un

J'aimerais cependant un petite aide pour sérializer en binaire tous les types courants de sorte que
memcmp(v1,v2,min(v1.length(),v2.length()))
renvoit la bonne valeur quoiqu'il y ait dans v1 et v2. Par exemple:
v1 << int(5) << std::wstring(L"abc") << float(23.7).
v2 << int(-7) << std::wstring(L"xyzt") << float(-0.095).
je suppose que ce n'est qu'un problème d'ordre "endian" et rien d'autre.

[Mac LAK]

Quant on sérialise, par définition, on DOIT tenir compte de l'endianness et de l'alignement si l'on désire avoir quelque chose de transmissible à une autre machine.

Dans ton cas, il faut bien sûr s'assurer de la taille des données, de l'endianness (little-endian sur un PC, mais big-endian sur un réseau en général), et du padding entre les divers éléments quand ils sont en mémoire.

Sur ton exemple, comme les chaînes de caractère sont de taille différente, ça n'aura jamais de sens : le champ flottant ne sera aligné avec celui d'une autre structure que par miracle. Si tu veux éviter ça, il faut utiliser une taille constante sur les chaînes, et remplir la partie non-utilisée de zéros. Par contre, tu vas perdre de la place, forcément...

[white_tentacle]

Sur ton exemple, comme les chaînes de caractère sont de taille différente, ça n'aura jamais de sens : le champ flottant ne sera aligné avec celui d'une autre structure que par miracle. Si tu veux éviter ça, il faut utiliser une taille constante sur les chaînes, et remplir la partie non-utilisée de zéros. Par contre, tu vas perdre de la place, forcément...

Tu peux aussi préfixer la chaîne de caractère par sa taille. Ca permet de perdre moins de place, par contre, ça t'oblige à décoder la structure séquentiellement (plus possible d'accéder directement à un champ sans avoir lu tous les précédents).

[camboui]

Les chaines de caractères seront terminées par zéro, cela devrait permettre de comparer des flux binaire de longueur quelconque avec du texte en milieu de flux (pas besoin d'aligner les champs donc).
Cependant, il faut aussi sur PC respecter le bon "endian":

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
#include "tchar.h"
#include <iostream>
#include <sstream>
#include <functional>
 
template <typename T>
bool cmp(T v1,T v2)
{
	return memcmp(&v1,&v2,sizeof(T))<0;
}
 
int _tmain(int argc, _TCHAR* argv[])
{
	std::wcout << std::less<int>()(-10,1000000000) << std::endl;
	std::wcout << cmp(-10,1000000000) << std::endl;
	return 0;
}

Le résultat devrait être le même, mais il ne l'est pas. Résultat
1
0

[camboui]

Il me semblait bien...

je suppose que ce n'est qu'un problème d'ordre "endian" et rien d'autre.

L'affirmation ci-dessus de mon précédant post est donc fausse

Je repose donc la question:
comment sérializer en binaire tous les types courants de sorte que
memcmp(v1.void_ptr(),v2.void_ptr(),min(v1.length(),v2.length()))
renvoit la bonne valeur quoiqu'il y ait dans v1 et v2 ?

[screetch]

ca dépend de ce que tu veux tester. Si tu veux tester l'égalité, le memcmp fonctionne
si tu veux tester a < b quel que soit le type de a et b ca ne marchera jamais, puisque ca dépend de la représentation binaire du type.

[white_tentacle]

C'est mort à mon avis. memcpy compare de la mémoire, c'est tout. Pour une comparaison sémantique, il faut des types et l'opérateur <.

Donc, étape suivant, on remonte au besoin. Que cherches-tu à faire exactement ?