From: pascale.noyret Date: Mon, 2 Mar 2020 16:03:56 +0000 (+0100) Subject: sauvegarde du 17/03 X-Git-Tag: V200520bis~86 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=135734c7362d8107e3475ea9a6a3a946a7eda70a;p=tools%2Feficas.git sauvegarde du 17/03 --- diff --git a/Efi2Xsd/AccasXsd.py b/Efi2Xsd/AccasXsd.py index ac7b084e..d932becc 100755 --- a/Efi2Xsd/AccasXsd.py +++ b/Efi2Xsd/AccasXsd.py @@ -4,6 +4,8 @@ import sys,os import types import Accas import imp +from copy import deepcopy + # CONTEXT est accessible (__init__.py de Noyau) @@ -65,12 +67,16 @@ class X_definition: return nom self.aCreer = False if nom == 'T_Consigne' : return nom + listePossible=cata.dictTypesXSD[nom] indice=0 while (indice < len(listePossible)) : objAComparer=listePossible[indice] + print ('je compare', self.nom, 'avec', objAComparer.nom ) + print (self.compare(objAComparer) ) if self.compare(objAComparer) : return objAComparer.nomDuTypePyxb indice += 1 + print ('jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj sortie de boucle') self.aCreer = True cata.dictTypesXSD[nom].append(self) nomAlter='T_'+self.nom+'_'+str(indice) @@ -85,32 +91,163 @@ class X_definition: # cata.dictTypesXSD[nom] = self # return None +# ---------------------------------------- +class X_factCompoAmbigu(X_definition): +# ---------------------------------------- + + def __init__(self,nom,listeDeCreation,pere): + self.nom=nom + self.pere=pere + self.statut='f' + self.entites={} + self.mcXSD=[] + self.ordre_mc=[] + for (mc, index) in listeDeCreation : + self.mcXSD.append(mc) + self.ordre_mc.append(mc.nom) + #self.mcXSD=list(deepcopy(self.ordre_mc)) + print ('creation de X_factCompoAmbigu', self.nom, self.ordre_mc) + self.arbrePossibles=[] + for mc in self.mcXSD : + if not hasattr(mc, 'arbrePossibles') : mc.construitArbrePossibles() + for ligne in mc.arbrePossibles : + if ligne not in self.arbrePossibles : self.arbrePossibles.append(ligne) + + self.arbrePossibles.remove([]) + # bien reflechir a l ordre des 2 lignes ci-dessous + self.construitEntites(self.mcXSD) + for i in self.entites : + print (i,self.entites[i]) + lesPossibles=deepcopy(self.arbrePossibles) + self.mcXSD=self.factorise(lesPossibles) + self.label='BlocAmbigu' + + def construitEntites(self, laListe): + for mc in laListe : + if self.entites.has_key(mc.nom): self.entites[mc.nom].append(mc) + else : self.entites[mc.nom] = [mc,] + self.construitEntites(mc.mcXSD) + + + def dumpXsd(self, dansFactorisation=False): + self.tousLesFils=[] + self.getNomDuCodeDumpe() + self.nomDuTypePyxb = self.definitNomDuTypePyxb() + self.texteSimple = "" + # il va falloir faire quelque chose d autre pour + # Bloc1, simp1 obligatoire Bloc2 + # a cause du 0 probablement un booleen + self.texteElt=substDsSequence.format(self.code,self.nomDuTypePyxb,0,1) + print ('dump de ', self.nomDuTypePyxb, self.aCreer) + self.texteComplexeVenantDesFils = '' + self.texteComplexe = debutTypeCompo.format(self.nomDuTypePyxb) + self.creeTexteComplexe(self.mcXSD) + self.texteComplexe += finTypeCompo + print (self.texteComplexe) + print ('oooooooo', self.mcXSD) + exit() + + def creeTexteComplexe(self,laListe): + if (len(laListe))==1: + print ('creeTexteComplexe', laListe,' ____________________') + # on a une sequence + self.texteComplexe += debutTypeCompoSeq + eltSequence = laListe[0] + index=0 + while (type(eltSequence[index]) != types.ListType ): + nomFils=eltSequence[index] + index=index+1 + print (self.entites[nomFils]) + # if len(self.entites[nomFils]) == 1: + # il faut verifier le type normalement + # et creer le texteSimple du fils en fonction + if 1 == 1 : + mcFils=self.entites[nomFils][0] + mcFils.dumpXsd(dansFactorisation=True) + self.texteComplexe += mcFils.texteElt + self.texteSimple += mcFils.texteSimple + reste=eltSequence[index:][0] + if reste != [] :self.creeTexteComplexe(reste) + #self.texteComplexeVenantDesFils += self.CreeTexteComplexeVenantDesFils(dansFactorisation) + # PN ou doit on le faire ? + #self.texteComplexe = texteComplexeVenantDesFils + self.texteComplexe + self.texteComplexe += finTypeCompoSeq + else : + # on a un choix + eltChoix = laListe + print (eltChoix) + self.texteComplexe += choiceDsBloc + print ('traitement de', eltChoix) + for l in eltChoix : + if l != [] : self.creeTexteComplexe(l) + ##for nom in l : + # if len(self.entites[nomFils]) == 1: + # il faut verifier le type normalement + # et creer le texteSimple du fils en fonction + # if 1 == 1 : + # mcFils=self.entites[nom][0] + # mcFils.dumpXsd(dansFactorisation=True) + # self.texteComplexe += mcFils.texteElt + # self.texteSimple += mcFils.texteSimple + #reste=laListe[1:][0] + self.texteComplexe += finChoiceDsBloc + #if reste != [] :self.creeTexteComplexe(reste) + + + def factorise(self, laListe): + maListeRetour=[] + aReduire={} + for ligne in laListe : + if ligne == [] : continue + #print ('je traite', ligne) + if aReduire.has_key(ligne[0]) : aReduire[ligne[0]].append(ligne[1:]) + else : aReduire[ligne[0]]=[ligne[1:],] + #print ('clef = ', ligne[0], ' ', aReduire[ligne[0]]) + for clef in aReduire: + if len(aReduire[clef])==1 : + if aReduire[clef] != [[]]: maListeRetour.append([clef,]+aReduire[clef]) + else : maListeRetour.append([clef,]) + else : + nvlElt=[clef,] + #print ('je sors', nvlElt) + nvlElt.append(self.factorise(aReduire[clef])) + maListeRetour.append(nvlElt) + #print ('maListeRetour ',self.nom, maListeRetour) + #print ('________ fin factorise________' , laListe) + #print ('_________________________') + return maListeRetour + + + + # ---------------------------------------- class X_definitionComposee (X_definition): # ------------------------------------------ - def CreeTexteComplexeVenantDesFils(self): + def CreeTexteComplexeVenantDesFils(self,dansFactorisation=False): texteComplexeVenantDesFils="" fichierDejaDumpe=False - for nom in self.ordre_mc: - mcFils = self.entites[nom] + #for nom in self.ordre_mc: + # mcFils = self.entites[nom] + for mcFils in self.mcXSD : if not (isinstance(mcFils, Accas.BLOC_FICHIER)) : - mcFils.dumpXsd() + mcFils.dumpXsd(dansFactorisation) self.texteComplexe += mcFils.texteElt self.texteSimple += mcFils.texteSimple texteComplexeVenantDesFils += mcFils.texteComplexe continue elif not fichierDejaDumpe : - mcFils.dumpXsd() + mcFils.dumpXsd(dansFactorisation) self.texteComplexe += mcFils.texteElt self.texteSimple += mcFils.texteSimple texteComplexeVenantDesFils += mcFils.texteComplexe fichierDejaDumpe = True return texteComplexeVenantDesFils - def dumpXsd(self): - #print ('------------------------------------------------') + def dumpXsd(self,dansFactorisation=False): + print ('------------------------------------------------', self.nom) if PourTraduction : print (self.nom) + self.prepareDumpXSD() self.getNomDuCodeDumpe() self.nomDuTypePyxb = self.definitNomDuTypePyxb() @@ -122,7 +259,7 @@ class X_definitionComposee (X_definition): if self.aCreer : self.texteComplexe = debutTypeCompo.format(self.nomDuTypePyxb) self.texteComplexe += debutTypeCompoSeq - texteComplexeVenantDesFils=self.CreeTexteComplexeVenantDesFils() + texteComplexeVenantDesFils=self.CreeTexteComplexeVenantDesFils(dansFactorisation) self.texteComplexe = texteComplexeVenantDesFils + self.texteComplexe if not isinstance(self,X_OPER ) : self.texteComplexe += finTypeCompoSeq @@ -151,6 +288,140 @@ class X_definitionComposee (X_definition): if not self.entites[defFille].compare(autreMC.entites[defFille]) : return False return True + def prepareDumpXSD(self): + print ('prepareDumpXSD', self.nom) + self.tousLesFils=[] + self.mcXSD=[] + for nomMC in self.ordre_mc: + mc=self.entites[nomMC] + self.mcXSD.append(mc) + mc.prepareDumpXSD() + self.chercheListesDeBlocsNonDisjointsAvecIndex() + for l in list(self.listeDesBlocsNonDisjointsAvecIndex) : + #print ('je traite ', l, self.besoinDeFactoriserTrivial(l)) + if not(self.besoinDeFactoriserTrivial(l)) : self.listeDesBlocsNonDisjointsAvecIndex.remove(l) + else : self.factorise(l) + #print (self.aUnPremierCommunDansLesPossibles(l)) + #if self.aUnPremierCommunDansLesPossibles(l) : + # print ('aUnCommunDansLesPossibles --> Factorisation') + #else : self.listeDesBlocsNonDisjointsAvecIndex.remove(l) + # trouver un cas test + + def chercheListesDeBlocsNonDisjointsAvecIndex(self): + self.listeDesBlocsNonDisjointsAvecIndex=[] + index=-1 + for nomChild in self.ordre_mc : + child=self.entites[nomChild] + index=index+1 + if child.label != 'BLOC' : continue + if self.listeDesBlocsNonDisjointsAvecIndex == [] : + self.listeDesBlocsNonDisjointsAvecIndex.append([(child,index),]) + continue + vraimentIndependant=True + for liste in list(self.listeDesBlocsNonDisjointsAvecIndex): + independant=True + for (bloc,indInListe) in liste : + if bloc.isDisjoint(child) : continue + independant=False + vraimentIndependant=False + if not (independant) : + liste.append((child, index)) + if vraimentIndependant: + self.listeDesBlocsNonDisjointsAvecIndex.append([(child,index),]) + # on nettoye la liste des blocs tous seuls + for l in list(self.listeDesBlocsNonDisjointsAvecIndex) : + if len(l) ==1 : self.listeDesBlocsNonDisjointsAvecIndex.remove(l) + + def aUnPremierCommunDansLesPossibles(self, laListe) : + # fonctionne avec liste de mc ou une liste(mc,index) + import types + mesPremiers=set() + for elt,index in laListe : + if not type(e) == types.ListType : + if elt.nom in mesPremiers : return True + mesPremiers.add(elt.nom) + else : + if elt[0].nom in mesPremiers : return True + mesPremiers.add(elt[0].nom) + return False + + def besoinDeFactoriserTrivial(self,laListe): + besoin=False + lesPremiers=set() + for mcBloc,indice in laListe : + mc=mcBloc.mcXSD[0] + if mc.label == 'BLOC': return True + if not(mc.statut=='o') : return True + if mc.nom in lesPremiers : return True + lesPremiers.add(mc.nom) + return False + + def factorise(self,liste): + self.listeConstruction=liste + indexDebut=liste[0][1] + nomDebut=liste[0][0].nom + indexFin=liste[-1][1]+1 + nomFin=liste[-1][0].nom + nom=nomDebut+'_'+nomFin + + newListe=self.mcXSD[0:indexDebut] + #print (newListe, newListe.__class__) + monEltFacteur=X_factCompoAmbigu(nom,liste,self) + newListe.append(monEltFacteur) + newListe=newListe+self.mcXSD[indexFin:] + self.mcXSD=newListe + + def construitTousLesFils(self): + for nomChild in self.ordre_mc : + child=self.entites[nomChild] + if child.label != 'BLOC' : + self.tousLesFils.append(child.nom) + else: + if child.tousLesFils == [] : child.construitTousLesFils() + for nomPetitFils in child.tousLesFils : self.tousLesFils.append(nomPetitFils) + #print ('construitArbreEntier pour ', self.nom, self.tousLesFils) + + + def isDisjoint(self, mc1) : + if self.tousLesFils == [] : self.construitTousLesFils() + if not (hasattr(mc1, 'tousLesFils')) : mc1.tousLesFils = [] + if mc1.tousLesFils == [] : mc1.construitTousLesFils() + for fils in mc1.tousLesFils : + if fils in self.tousLesFils : return False + return True + + def construitArbrePossibles(self): + self.arbrePossibles=[[],] + for child in self.mcXSD : child.construitArbrePossibles() + for child in self.mcXSD : + if child.label != 'BLOC' : + self.arbrePossibles = deepcopy(self.adjoint(self.arbrePossibles, child.arbrePossibles)) + else : + self.arbrePossibles = deepcopy(self.fusionne(self.arbrePossibles, child.arbrePossibles)) + #print ( self.arbrePossibles) + + def adjoint(self, liste1, liste2): + #print ('adjoint', liste1, liste2) + l=[] + for elt1 in liste1: + for elt2 in liste2: + newListe=deepcopy(elt1) + if elt2 != []: newListe.append(elt2) + l.append(newListe) + return l + + def fusionne(self, liste1, liste2): + listeFinale=[] + for elt1 in liste1 : + for eltListe in liste2: + newListe=deepcopy(elt1) + for elt in eltListe : + if elt not in newListe : newListe.append(elt) + if newListe not in listeFinale : listeFinale.append(newListe) + return listeFinale + + + # --------------------------------- class X_FACT (X_definitionComposee): #--------- ------------------------ @@ -162,16 +433,28 @@ class X_FACT (X_definitionComposee): self.minOccurs = self.min if self.statut =='f' : self.minOccurs=0 + def construitArbrePossibles(self): + if self.statut == 'f' : + self.arbrePossibles = (self.nom,[]) + self.arbreMCPossibles = (self,None) + else : + self.arbrePossibles = (self.nom,) + self.arbreMCPossibles = (self,) + + + # --------------------------------- class X_OPER (X_definitionComposee): # --------------------------------- - def dumpXsd(self): - X_definitionComposee.dumpXsd(self) + def dumpXsd(self,dansFactorisation=False): + X_definitionComposee.dumpXsd(self,dansFactorisation) self.texteComplexe += finTypeCompoSeq self.texteComplexe += operAttributeName self.texteComplexe += attributeTypeForASSD self.texteComplexe += attributeTypeUtilisateurName.format(self.sd_prod.__name__) self.texteComplexe += finTypeCompo + + cata = CONTEXT.getCurrentCata() if self.sd_prod.__name__ not in list(cata.dictTypesASSDorUserASSDCrees) : cata.dictTypesASSDorUserASSDCrees[self.sd_prod.__name__]=[self,] @@ -187,18 +470,23 @@ class X_PROC (X_definitionComposee): #----------------------------------- class X_BLOC (X_definitionComposee): #----------------------------------- - def dumpXsd(self): - #print ('------------------------------------------------') - #print ('dumpXsd de ' , self.nom) - + def dumpXsd(self,dansFactorisation=False): + print ('------------------------------------------------') + print ('dumpXsd de ' , self.nom) + print (self.nomXML) + self.tousLesFils=[] + self.getNomDuCodeDumpe() + # dans ce cas les blocs successifs sont identiques et on ne dumpe que le 1er + self.nomDuTypePyxb = self.definitNomDuTypePyxb() self.texteSimple = "" # on n ajoute pas de type simple + print (self.aCreer) # Pour les blocs le minOccurs vaut 0 et le max 1 if self.aCreer : self.texteComplexe = debutTypeSubst.format(self.nomDuTypePyxb) - texteComplexeVenantDesFils=self.CreeTexteComplexeVenantDesFils() + texteComplexeVenantDesFils=self.CreeTexteComplexeVenantDesFils(dansFactorisation) self.texteComplexe = texteComplexeVenantDesFils + self.texteComplexe self.texteComplexe += finTypeSubst else : @@ -214,17 +502,29 @@ class X_BLOC (X_definitionComposee): val1=getattr(self,attr) val2=getattr(autreMC,attr) if val1 != val2 : return False + print ('je passe la 22222222222222222') for defFille in self.entites.keys(): + print (defFille) if defFille not in autreMC.entites.keys() : return False + print (defFille) if not self.entites[defFille].compare(autreMC.entites[defFille]) : return False + print (defFille) return True + def construitArbrePossibles(self): + #print ('je passe la pour', self.nom) + X_definitionComposee.construitArbrePossibles(self) + if [] not in self.arbrePossibles : self.arbrePossibles.append([]) + self.sequenceEnXSD=[] + + #-------------------------------- class X_SIMP (X_definition): #-------------------------------- - def dumpXsd(self): + def dumpXsd(self, dansFactorisation=False): if PourTraduction : print (self.nom) + self.prepareDumpXSD() #if self.nom == 'Fichier' : import traceback; traceback.print_stack() #print ('exploreObjet SIMP') self.getNomDuCodeDumpe() @@ -241,6 +541,7 @@ class X_SIMP (X_definition): # on se sert des listes ou non pour la gestion des minOccurs /maxOccurs est > 0 if self.statut =='f' : minOccurs = 0 else : minOccurs = 1 + if dansFactorisation : minOccurs = 1 # le defaut est dans l elt Name -> tester la coherence d existence avec Accas # regles Accas if (hasattr (self, 'nomXML')) and self.nomXML != None : nomUtil=self.nomXML @@ -269,9 +570,12 @@ class X_SIMP (X_definition): if self.val_min != float('-inf') : self.texteSimple += "\t\t\t\t"+minInclusiveBorne.format(self.val_min) if self.val_max != float('inf') and self.val_max != '**' : self.texteSimple +="\t\t\t\t"+ maxInclusiveBorne.format(self.val_max) if self.into != None: - for val in self.into : self.texteSimple += "\t\t\t\t"+enumeration.format(val) + # PN --> traduction des ontp + into=self.into + if self.intoXML != None : into = self.intoXML + for val in into : self.texteSimple += "\t\t\t\t"+enumeration.format(val) if PourTraduction : - for val in self.into : print (str(val)) + for val in into : print (str(val)) self.texteSimple += fermeBalisesMileu if self.max !=1 and self.max != '**' and self.max != float('inf') : self.texteSimple += maxLengthTypeSimple.format(self.max) if self.min !=1 and self.min != float('-inf') : self.texteSimple += minLengthTypeSimple.format(self.min) @@ -282,13 +586,23 @@ class X_SIMP (X_definition): if self.val_min != float('-inf') : self.texteSimple += minInclusiveBorne.format(self.val_min) if self.val_max != float('inf') and self.val_max != '**' : self.texteSimple += maxInclusiveBorne.format(self.val_max) if self.into != None: - for val in self.into : self.texteSimple += enumeration.format(val) + into=self.into + if self.intoXML != None : into = self.intoXML + for val in into : self.texteSimple += enumeration.format(val) if PourTraduction : - for val in self.into : print (str(val)) + for val in into : print (str(val)) self.texteSimple += fermeRestrictionBase self.texteSimple += fermeSimpleType + def prepareDumpXSD(self): + if self.statut == 'f' : + self.arbrePossibles = (self.nom,[]) + else : + self.arbrePossibles = (self.nom,) + self.mcXSD=[] + + def traduitType(self): # il faut traduire le min et le max @@ -340,12 +654,22 @@ class X_SIMP (X_definition): def compare(self,autreMC): if self.label != autreMC.label : return False - for attr in ( 'type', 'ang', 'fr', 'into', 'intoSug' , 'siValide', 'defaut', 'min' ,'max' ,'homo' ,'position' ,'val_min' , 'val_max' , 'docu' , 'validators' , 'sug' ) : + listeAComparer = [ 'type', 'defaut', 'min' ,'max' ,'val_min' , 'val_max' ] + if self.intoXML != None : listeAComparer.append('intoXML') + else : listeAComparer.append('into') + for attr in listeAComparer : val1=getattr(self,attr) val2=getattr(autreMC,attr) if val1 != val2 : return False return True + def construitArbrePossibles(self): + if self.statut == 'f' : + self.arbrePossibles = (self.nom,[]) + else : + self.arbrePossibles = (self.nom,) + + #----------------- class X_JDC_CATA : #----------------- @@ -399,7 +723,6 @@ class X_JDC_CATA : texteKeyRef = "" # Pour le nom des key_ref en creation : le type ( une seule key-ref par type. facile a retrouver) for clef in self.dictTypesASSDorUserASSDCrees: - print ('---- En creation', clef, '__________________') existeASSD=0 texteDesFields="" for unOper in self.dictTypesASSDorUserASSDCrees[clef]: @@ -449,6 +772,7 @@ class X_JDC_CATA : #import pprint #if (not PourTraduction) and (dico != {}) : pprint.pprint(dico) + print ('__________________________ decommenter pour le texteXSD________________________') print (self.texteXSD) return self.texteXSD @@ -505,6 +829,7 @@ class X_JDC_CATA : c.nomDuCodeDumpe=self.nomDuCodeDumpe c.code=self.code c.dumpXsd() + self.texteSimple += c.texteSimple self.texteComplexe += c.texteComplexe c.texteElt=eltCompoDsSequenceInExtension.format(c.nom,self.code,c.nomDuTypePyxb) diff --git a/Efi2Xsd/balisesXSD.py b/Efi2Xsd/balisesXSD.py index e4c6059a..5f310273 100644 --- a/Efi2Xsd/balisesXSD.py +++ b/Efi2Xsd/balisesXSD.py @@ -37,10 +37,13 @@ finTypeCompo = '\t\n' eltCompoDsSequence = '\t\t\t\n' eltCompoDsSequenceInExtension = '\t\t\t\n' + # BLOC debutTypeSubst = '\t \n\t\t\n' finTypeSubst = '\t\t\n\t\n' substDsSequence = '\t\t\t\n' +choiceDsBloc='\t\t\t\n' +finChoiceDsBloc='\t\t\t\n' # User OR ASSD diff --git a/Noyau/N_ASSD.py b/Noyau/N_ASSD.py index a6c69d7a..fa1adfbc 100644 --- a/Noyau/N_ASSD.py +++ b/Noyau/N_ASSD.py @@ -215,9 +215,36 @@ class ASSD(object): val = self.jdc.parLot return val == 'OUI' - def rebuild_sd(self): - """Conserver uniquement pour la compatibilite avec le catalogue v10 dans eficas.""" + def getEficasAttribut(self, attribut): + #print ('getEficasAttribut : ', self, attribut) + valeur=self.etape.getMocle(attribut) + try : + valeur=self.etape.getMocle(attribut) + except : + valeur = None + #print (valeur) + return valeur + + def getEficasListOfAttributs(self,listeAttributs): + from .N_MCLIST import MCList + #print ('getEficasListOfAttributs pour', self,listeAttributs) + aTraiter=(self.etape,) + while len(listeAttributs) > 0 : + attribut=listeAttributs.pop(0) + print ("attribut", attribut) + nvListe=[] + for mc in aTraiter : + print (mc) + try : + resultat=mc.getMocle(attribut) + if isinstance(resultat,MCList): + for rmc in resultat : nvListe.append(rmc) + else : nvListe.append(resultat) + except : pass + aTraiter=nvListe + #print ('fin getEficasListOfAttributs ', nvListe) + return nvListe class assd(ASSD): diff --git a/Noyau/N_BLOC.py b/Noyau/N_BLOC.py index d5f64107..5d594d65 100644 --- a/Noyau/N_BLOC.py +++ b/Noyau/N_BLOC.py @@ -52,7 +52,7 @@ class BLOC(N_ENTITE.ENTITE): class_instance = N_MCBLOC.MCBLOC label = 'BLOC' - def __init__(self, fr="", docu="", regles=(), statut='f', condition=None,ang="", + def __init__(self, fr="", docu="", regles=(), statut='f', condition=None,ang="", nomXML=None, **args): """ Un bloc est caractérisé par les attributs suivants : @@ -78,6 +78,7 @@ class BLOC(N_ENTITE.ENTITE): self.regles = (regles,) self.statut = statut self.condition = condition + self.nomXML = nomXML self.entites = args self.affecter_parente() self.txtNomComplet = '' @@ -149,6 +150,17 @@ class BLOC(N_ENTITE.ENTITE): '\n', "Erreur dans la condition : ", self.condition, ''.join(l)) else: return 0 + + + def construitArbrePossibles(self): + self.arbrePossibles=[[],] + for child in self.mcListe : + if child.label != 'BLOC' : + self.arbrePossibles = deepcopy(self.adjoint(self.arbrePossibles, child.arbrePossibles)) + else : + self.arbrePossibles = deepcopy(self.fusionne(self.arbrePossibles, child.arbrePossibles)) + self.arbrePossibles.append([]) + def longueurDsArbre(self): longueur=0 @@ -172,8 +184,11 @@ def blocUtils(): return not au_moins_un(mcsimp, valeurs) def getEficasAttribut( nomUserASSD, nomAttr): - #print ('dans getEficasAttribut de Bloc') if nomUserASSD == None : return None return ( nomUserASSD.getEficasAttribut(nomAttr)) + def getEficasListOfAttributs( nomASSD, listeAttributs): + if nomASSD == None : return () + return ( nomASSD.getEficasListOfAttributs(listeAttributs)) + return locals() diff --git a/Noyau/N_ENTITE.py b/Noyau/N_ENTITE.py index a6ab02bb..22058f5d 100644 --- a/Noyau/N_ENTITE.py +++ b/Noyau/N_ENTITE.py @@ -70,6 +70,8 @@ class ENTITE(object): #self.doitSenregistrerComme = None self.txtNomComplet='' self.redefinit=False + #self.construitArbrePossible() + #print ('____________________________ init _________________', self.nom, self.arbrePossible) def affecter_parente(self): """ @@ -310,4 +312,26 @@ class ENTITE(object): self.redefinit=True # PNPN il faut remonter a l etape + def adjoint(self, liste1, liste2): + # utilise pour l arbrePossibles + print ('adjoint', liste1, liste2) + l=[] + for elt1 in liste1: + for elt2 in liste2: + newListe=deepcopy(elt1) + if elt2 != []: newListe.append(elt2) + l.append(newListe) + return l + + def fusionne(self, liste1, liste2): + # utilise pour l arbrePossibles + l=[] + for elt1 in liste1 : + for eltListe in liste2: + newListe=deepcopy(elt1) + for elt in eltListe : + newListe.append(elt) + l.append(newListe) + return l + diff --git a/Noyau/N_ETAPE.py b/Noyau/N_ETAPE.py index dd3f493e..06d2f993 100644 --- a/Noyau/N_ETAPE.py +++ b/Noyau/N_ETAPE.py @@ -463,3 +463,12 @@ Causes possibles : # pourrait etre appelee par une commande fortran faisant appel a des fonctions python # on passe la main au parent return self.parent.getConcept(nomsd) + + def construitArbrePossibles(self): + self.arbrePossibles=[[],] + for child in self.mcListe : + if child.label != 'BLOC' : + self.arbrePossibles = deepcopy(self.adjoint(self.arbrePossibles, child.arbrePossibles)) + else : + self.arbrePossibles = deepcopy(self.fusionne(self.arbrePossibles, child.arbrePossibles)) + diff --git a/Noyau/N_FACT.py b/Noyau/N_FACT.py index 7c086a5a..44948b25 100644 --- a/Noyau/N_FACT.py +++ b/Noyau/N_FACT.py @@ -172,3 +172,10 @@ class FACT(N_ENTITE.ENTITE): self.checkDocu() self.checkValidators() self.verifCataRegles() + + def construitArbrePossibles(self): + if self.statut == 'f' : + self.arbrePossibles = (self.nom,[]) + else : + self.arbrePossibles = (self.nom,) + diff --git a/Noyau/N_MCSIMP.py b/Noyau/N_MCSIMP.py index 52e96325..035d2176 100644 --- a/Noyau/N_MCSIMP.py +++ b/Noyau/N_MCSIMP.py @@ -60,13 +60,13 @@ class MCSIMP(N_OBJECT.OBJECT): self.nom = nom self.val = val self.parent = parent + self.objPyxbDeConstruction = objPyxbDeConstruction if parent: self.jdc = self.parent.jdc if self.jdc : self.cata = self.jdc.cata else : self.cata = None self.niveau = self.parent.niveau self.etape = self.parent.etape - self.buildObjPyxb() else: # Le mot cle simple a été créé sans parent # est-ce possible ? @@ -82,7 +82,7 @@ class MCSIMP(N_OBJECT.OBJECT): self.convProto = ConversionFactory('type', typ=self.definition.type) self.valeur = self.getValeurEffective(self.val) if self.definition.utiliseUneReference and self.valeur != None: self.valeur.ajoutUtilisePar(self) - self.objPyxbDeConstruction = objPyxbDeConstruction + self.buildObjPyxb() self.listeNomsObjsCrees = [] def getValeurEffective(self, val): diff --git a/Noyau/N_SIMP.py b/Noyau/N_SIMP.py index ba002dd7..777ab3b7 100644 --- a/Noyau/N_SIMP.py +++ b/Noyau/N_SIMP.py @@ -50,7 +50,7 @@ class SIMP(N_ENTITE.ENTITE): def __init__(self, typ,ang="", fr="", statut='f', into=None, intoSug = None,siValide = None, defaut=None, min=1, max=1, homo=1, position='local', val_min=float('-inf'), val_max=float('inf'), docu="", validators=None, nomXML=None, - sug=None,fenetreIhm=None, attribut=False, sortie='n'): + sug=None,fenetreIhm=None, attribut=False, sortie='n', intoXML=None): """ Un mot-clé simple est caractérisé par les attributs suivants : - type : cet attribut est obligatoire et indique le type de valeur attendue @@ -122,6 +122,7 @@ class SIMP(N_ENTITE.ENTITE): self.fenetreIhm = fenetreIhm self.attribut = attribut self.nomXML = nomXML + self.intoXML = intoXML self.sortie = sortie def verifCata(self): @@ -136,6 +137,11 @@ class SIMP(N_ENTITE.ENTITE): self.checkInto() self.checkPosition() self.checkValidators() + + def construitArbrePossible(self): + if self.statut == 'f' : self.arbrePossibles = (self.nom,[]) + else : self.arbrePossibles = (self.nom,) + return def __call__(self, val, nom, parent=None, objPyxbDeConstruction = None): """ @@ -145,5 +151,3 @@ class SIMP(N_ENTITE.ENTITE): return self.class_instance(nom=nom, definition=self, val=val, parent=parent, objPyxbDeConstruction=objPyxbDeConstruction) - - diff --git a/Noyau/N_UserASSD.py b/Noyau/N_UserASSD.py index b9d25d7e..770ccb47 100644 --- a/Noyau/N_UserASSD.py +++ b/Noyau/N_UserASSD.py @@ -97,6 +97,7 @@ class UserASSD(ASSD): #print ('je suis dans getEficasAttr', attribut) if self.parent == None : return None #print ('apres if') + # parent est le SIMP donc c est bien parent.parent try : valeur = self.parent.parent.getMocle(attribut) except :