Adressage de données complexes

Version imprimable

Bonjour:lol:

J'ai des données complexes dans des structures de données et je n'arrive pas a savoir comment je dois les adresser.
Je donne d'abord les structure et leurs applications et dans un deuxième temps je parlerai de l'utilisation de ces structures:
d'abord la définition des données( provisoire, il est possible que je doive les faire évoluer)

Code:

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
enum enElementSemantique
{
   ELEMENT_NONE,
   ELEMENT_PREDICAT,
   ELEMENT_PRECONDITION,
   ELEMENT_QUALIFICATEUR,
   ELEMENT_COMMENTAIRE,
   NUMBER_OF_ELEMENT
};
 
typedef struct stElementSemantique{
      hidDB idElement;
      hidDB idSegSrc;
      std::list<CSegmentChunkDescription *>* ListChunk;
      hidDB idElementSrc;
      hidDB TypeElement;
      hidDB TypeSeg;
} stELEMENT_SEMANTIQUE;
 
struct stPropositionRecursive
{
   stELEMENT_SEMANTIQUE ChunkPivot;
   stELEMENT_SEMANTIQUE ChunkVerb;
   stELEMENT_SEMANTIQUE ChunkComplement;
   stPropositionRecursive* pNouvelleRecursion;
};
enChunkType NextPos[6]= {(enChunkType)0,(enChunkType)0,(enChunkType)0,(enChunkType)0,(enChunkType)0,(enChunkType)0};
enChunkType Curpos;
//---------------------------------------------------------------------------
class CCoherence
{
public:
   CCoherence::CCoherence( void);
   CCoherence::~CCoherence( void);
   void CCoherence::ExtractPreCondition( void);
private:
   enElementSemantique CCoherence::NewTypeElement( CSegmentChunkDescription *itChunk);
};
 
struct stAnalysedPredicats
{
   stELEMENT_SEMANTIQUE ChunkVerb;
   stELEMENT_SEMANTIQUE ChunkSujet;
   stELEMENT_SEMANTIQUE ChunkComplement;
};
struct stAnalysedPreconditions
{
   stELEMENT_SEMANTIQUE ChunkDeclencheur;
   stELEMENT_SEMANTIQUE ChunkSujet;
   stELEMENT_SEMANTIQUE ChunkVerb;
   stELEMENT_SEMANTIQUE ChunkComplement;
   stPropositionRecursive* pNouvelleRecursion;
};
 
struct stAnalysedQualifications
{
};
 
struct stSemanticSegment
{
  std::list<stAnalysedPredicats*> ListPredicat;                     //  Liste de pointeurs sur les Predicats qui sont dans le Segment
  std::list<stAnalysedPreconditions *> ListPrecondition;             //  Liste de pointeurs sur les Préconditions qui sont dans le Segment
  std::list<stAnalysedQualifications *> ListQualification;           //  Liste de pointeurs sur les Qualificateurs qui sont dans le Segment
  std::wstring wsComments;                                         //  Commentaires qui sont dans le Segment
};

commentaires:
Je découpe un texte. La première découpe est une découpe en syntagmes. les syntagmes sont appelés dans ce cas des Chunk, qui sont typés. les types sont :

Code:

1
2
3
4
5
6
7
8
9
10
 
enum enChunkType {
  CHUNKTYPE_NONE,                                        // 0 Undefined chunk type
  CHUNKTYPE_VERB,                                        // 1
  CHUNKTYPE_NOUN,                                       // 2
  CHUNKTYPE_FUNCT,                                      // 3
  CHUNKTYPE_DECLENCHEUR,                            // 4
  CHUNKTYPE_OTHER,                                      // 5
  NUMBER_OF_CHUNKTYPE
  };

Cette découpe marche.
A partir de cette découpe je veux synthétiser les syntagmes en propositions. Ces propositions sont soit des prédicats, soit des préconditions... (voir le type enElementSémantique)
J'ai défini des structures cibles stAnalysedPredicats... qui donnent la structure visée pour chaque proposition
Le fichier d'include passe la compilation.

Ca se corse quand je veux remplir la structure:

Code:

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
 
stSemanticSegment SemanticSegment;
std::list<stSemanticSegment*>* pListSemanticSegment;
std::list<hidDB> ListSegment;
std::list<CSegmentChunkDescription *> ListChunk;
std::list<CSegmentChunkDescription *>::iterator itChunk;
std::list<hidDB>::iterator itSegment;
CSegmentChunkDescription* pCurrentChunk;
stElementSemantique* pCurrentElement;
stElementSemantique* pPreviousElement;
int Step;
  bool processed = false;
int len;
// dans un premier temp, et pour chaque segment, on retire de la base de donnée
// le segment avec ses sous-éléments
// on appelle donc la primitive de la base de donnée jusqu à plus soif (fin de fichier)
   objMDBManager.GetSegmentsID( (enLanguage)2, &ListSegment);
   objMDBManager.GetSegmentChunksDescriptionOfSegments( ListSegment, false, ListChunk);
// dans le second temps on parcours le segment chunk par chunk en cherchant les
// chunk nominaux, verbaux, ou fonctionnells et on applique le deuxième niveau
// de la grammaire comme on l'a fait pour les chunks
   itChunk = ListChunk.begin();
   itSegment = ListSegment.begin();
   while( itChunk != ListChunk.end())
   { //2
      while( itSegment != ListSegment.end())
      { //3
         pCurrentChunk = *itChunk;
         Curpos = pCurrentChunk->ChunkType;
         if( Curpos == NextPos[0] && Curpos == NextPos[1] && Curpos == NextPos[2] && Curpos == NextPos[3] && Curpos == NextPos[4] && Curpos == NextPos[5])
         { //4
            // on est au début d'un sujet, il faut déterminer quel élément sémantique on va traiter
            pCurrentElement = new stELEMENT_SEMANTIQUE;
            pCurrentElement->TypeElement = (int64_t)CCoherence::NewTypeElement( pCurrentChunk);
            if( pPreviousElement->TypeElement != 0)
            { //5
               len = pPreviousElement->ListChunk->size();
 
               if (len != 0)
               { //6
                  switch( pPreviousElement->TypeElement)
                  { //7
                     case ELEMENT_PREDICAT:
                        SemanticSegment.ListPredicat.push_back( SemanticSegment.ListPredicat.pPreviousElement);
                        len = SemanticSegment.ListPredicat.ChunkVerb.size();
                        break;

Le push ne passe pas à la compilation. je dois pousser le syntagme identifié par le programme dans une élément sémantique correspondant et si possible dans la catégorie grammaticale idoine (p ex ce syntagme est le premier groupe nominal de la proposition qui est un prédicat: c'est donc le sujet. Mais c'est peut être trop vouloir que de nommer les syntagme. Peut être serait il utile de les mettre dans une liste et de les repérer par position.

Je dois préciser que j'ai en entré un syntagme déjà catégorisé porté par pPreviousElement. (réutilisation de la structure qui décompose les mots en syntagmes).

Je peux modifier les structures pour avoir un meilleur adressage, mais ma question est comment adresser l'intérieur des structures actuelles et quelle simplification peut on choisir.
Ca serait :ccool:

06/07/2010, 02h30
r0d

Bonjour,

ce n'est pas le push_back qui pose problème, mais l'élément que tu lui fournis.
D'après ton code, SemanticSegment.ListPredicat.pPreviousElement n'existe pas. SemanticSegment.ListPredicat est une std::list, et une std::list ne possède pas d'attribut pPreviousElement.
06/07/2010, 08h49
JeanNoel53

Le push oui, mais comment

Bonjour;:D

Je suis d'accord pour le push back; mais je me perd un peu dans mes structures. je sais que pPreviousElement porte la donnée a pousser, mais ou?
il y a deux endroit ou la pousser: au fur et à mesure de l'analyse pousser le syntagme dans la liste et en fin de phrase, pousser la liste dans une autre:
il y a en fait deux problèmes qui se mordent la queue: un problème de syntaxe: comment désigner les listes, et un problème de sémantique: quelles listes privilégier. Je suis maître du problème de sémantique, mais je ne peux pas le traiter sans savoir adresser les différentes listes.

Si j'avais un exemple d'adressage sur une des listes, ce serait :ccool:

Solution apportée

Bonjour :lol:

J'ai donc simplifié les données pour résoudre la question
J'ai un regroupement d'énumération

Code:

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
 
enum enChunkType {
  CHUNKTYPE_NONE,                                       // 0 Undefined chunk type
  CHUNKTYPE_VERB,                                       // 1
  CHUNKTYPE_NOUN,                                       // 2
  CHUNKTYPE_FUNCT,                                      // 3
  CHUNKTYPE_DECLENCHEUR,                                // 4
  CHUNKTYPE_OTHER,                                      // 5
  NUMBER_OF_CHUNKTYPE
};
 
enum enElementSemantique
{
   ELEMENT_NONE,
   ELEMENT_PREDICAT,
   ELEMENT_PRECONDITION,
   ELEMENT_QUALIFICATEUR,
   ELEMENT_COMMENTAIRE,
   NUMBER_OF_ELEMENT
};
 
enum enFonction
{
  FONCTION_NONE,
  FONCTION_SUJET,
  FONCTION_PREDICAT,
  FONCTION_OBJET,
  FONCTION_VERB,
  FONCTION_DECLENCHEUR,
  NUMBER_OF_FUNCTIONS
};

J'ai enrichi la structure des syntagmes du code fonctionnel

Code:

1
2
3
4
5
6
7
8
 
hidDB                   hidElementID;       //  Identifier of the segment where the chunk is used
  enFonction              TypeFonction;
  long long               llChunkID;          //  Identifiant du Chunk dans la base de données
  long                    lInitialPosition;
  std::wstring            wsText;             //  Texte de l'element
  enChunkType             ChunkType;          //  Type of the Chunk
  int                     Status;

J'ai ensuite simplifié les structures qui sont dirigé par la structure stSemanticSegment:

Code:

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
 
typedef struct stElementSemantique{
      hidDB idElement;
      hidDB idSegSrc;
      std::list<CSegmentChunkDescription *>* ListChunk;
      hidDB idElementSrc;
      hidDB TypeElement;
      hidDB TypeSeg;
} stELEMENT_SEMANTIQUE;
 
 
struct stPropositionRecursive
{
   stELEMENT_SEMANTIQUE ChunkPivot;
   stELEMENT_SEMANTIQUE ChunkVerb;
   stELEMENT_SEMANTIQUE ChunkComplement;
   stPropositionRecursive* pNouvelleRecursion;
};
 
struct stSemanticSegment
{
  hidDB idSegSrc;
 
  enElementSemantique TypeElement;
  std::list<CSegmentChunkDescription*> ListSemanticElement;                     //  Liste de pointeurs sur les Predicats qui sont dans le Segment
  std::wstring wsComments;                                           //  Commentaires qui sont dans le Segment
  stPropositionRecursive* pNouvelleRecursion;
};

et j'ai codé deux partie de push qui marchent bien:

Code:

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
 
   pListSemanticSegment = &ListSemanticSegment;
   pPreviousElement = &TempElement;
   objMDBManager.GetSegmentsID( (enLanguage)2, &ListSegment);
// dans le second temps on parcours le segment chunk par chunk en cherchant les
// chunk nominaux, verbaux, ou fonctionnells et on applique le deuxième niveau
// de la grammaire comme on l'a fait pour les chunks
   iSizeSegment = ListSegment.size();
   pPreviousElement->TypeElement = 0;
   itSegment = ListSegment.begin();
   while( itSegment != ListSegment.end())
   { //2
      objMDBManager.GetSegmentChunksDescriptionOfSegments( *itSegment, false, &ListChunk);
      iSizeChunk = ListChunk.size();
      itChunk = ListChunk.begin();
      while( itChunk != ListChunk.end())
      { //3
         pCurrentChunk = *itChunk;
         Curpos = pCurrentChunk->ChunkType;
         if( Curpos != NextPos[0] && Curpos != NextPos[1] && Curpos != NextPos[2] && Curpos != NextPos[3] && Curpos != NextPos[4] && Curpos != NextPos[5])
         { //4
            // on est au début d'un sujet, il faut déterminer quel élément sémantique on va traiter
            pCurrentElement = new stSemanticSegment;
            pCurrentElement->TypeElement = (int64_t)CCoherence::NewTypeElement( pCurrentChunk, pPreviousChunk);
            if( pPreviousElement->TypeElement != 0)
            { //5
               if( Step == 3)
               {
                  if( pPreviousChunk->ChunkType == CHUNKTYPE_NOUN)
                  {
                      pPreviousElement->ListSemanticElement.push_back( pPreviousChunk);
                  }
               }
               len = pPreviousElement->ListSemanticElement.size();
               if( len > 0)
               { //6
                  pListSemanticSegment->push_back( *pPreviousElement);
                  len = pListSemanticSegment->size();
               }
            } //5

Dans ce code je met la liste des syntagmes dans une liste de segment, sachant que les segments sont typés par pCurrentElement->TypeElement
et quand j'ai un chunk à mettre dans la structure qui est pointé par pPreviousElement j'écrit:

Code:

1
2
3
4
5
6
7
8
 
case CHUNKTYPE_NOUN:
                   NextPos[0] = CHUNKTYPE_VERB;
                   pCurrentChunk->TypeFonction = FONCTION_SUJET;
                   pCurrentElement->ListSemanticElement.push_back(pCurrentChunk);
                   processed = true;
                   Step++;
                   break;

et tout ça ça marche:ccool: