class X_definition:
# -----------------
+ 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 adjointUnMot(self, liste1, mot):
+ l=[]
+ for elt1 in liste1:
+ newListe=deepcopy(elt1)
+ newListe.append(mot)
+ l.append(newListe)
+ return l
+
+ def remplaceNomListeParContenu(self, liste1, liste2):
+ #print ('remplaceNomListeParContenu', liste1, liste2)
+ listeFinale=[]
+ for elt1 in liste1 :
+ for eltListe in liste2:
+ if eltListe == [] : continue
+ newListe=deepcopy(elt1)
+ if eltListe!=[] :newListe+=eltListe
+ listeFinale.append(newListe)
+ return listeFinale
+
+ def fusionne2Listes(self, liste1, liste2):
+ #print ('fusionne2Liste', liste1, liste2)
+ listeFinale=[]
+ for elt1 in liste1 :
+ for eltListe in liste2:
+ newListe=deepcopy(elt1)
+ if eltListe!=[] :newListe.append(eltListe)
+ listeFinale.append(newListe)
+ #print (listeFinale)
+ return listeFinale
+
def getNomDuCodeDumpe(self):
if hasattr(self,'nomDuCodeDumpe') : return
obj=self
indice=0
while (indice < len(listePossible)) :
objAComparer=listePossible[indice]
- print ('je compare', self.nom, 'avec', objAComparer.nom )
- print (self.compare(objAComparer) )
+ #print ('je compare', self.nom, 'avec', objAComparer.nom )
+ #print (self.compare(objAComparer) )
if self.compare(objAComparer) : return objAComparer.nomDuTypePyxb
indice += 1
self.aCreer = True
if (hasattr (self, 'nomXML')) and self.nomXML != None : nomAlter='T_'+self.nomXML+'_'+str(indice)
return nomAlter
- # def existeDeja(self,nom):
- # if nom in cata.dictTypesXSD.keys() :
- # self.aCreer = False
- # return cata.dictTypesXSD[nom]
- # else :
- # cata.dictTypesXSD[nom] = self
- # return None
# ----------------------------------------
-class X_factCompoAmbigu(X_definition):
+class X_compoFactoriseAmbigu(X_definition):
# ----------------------------------------
def __init__(self,nom,listeDeCreation,pere):
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 :
- print ('***************** mc', mc, mc.nom)
- if not hasattr(mc, 'arbrePossibles') : mc.construitArbrePossibles()
- for ligne in mc.arbrePossibles :
- if ligne not in self.arbrePossibles : self.arbrePossibles.append(ligne)
-
- # bien reflechir a l ordre des 2 lignes ci-dessous
self.construitEntites(self.mcXSD)
- for i in self.entites :
- print (i,self.entites[i])
+ #for i in self.entites : print (i,self.entites[i])
+ #print ('creation de X_compoFactoriseAmbigu', self.nom, self.mcXSD)
+ self.constructionArbrePossibles()
+
lesPossibles=deepcopy(self.arbrePossibles)
- #self.mcXSD=self.factorise(lesPossibles)
self.getNomDuCodeDumpe()
self.nomDuTypePyxb = self.definitNomDuTypePyxb()
self.texteSimple = ''
self.texteComplexe = debutTypeSubstDsBlocFactorise.format(self.nomDuTypePyxb)
# on enleve [] des possibles puisque l elt sera optionnel
lesPossibles.remove([])
+ #lesPossibles=[['A'] ,['A', 'B'] ,['A', 'B', 'C'] ,['A', 'B', 'C', 'F'] ,['A', 'B', 'F'] ,['A', 'C'] ,['A', 'C', 'F'] ,['A', 'D'] ,['A', 'D', 'F'] ,['A', 'F'] ,['A', 'G'] ,]
self.mcXSD=self.factoriseEtCreeDump(lesPossibles,False,nomAppel='Root')
self.texteComplexe += finTypeSubstDsBlocFactorise
self.texteComplexe +=self.texteComplexeVenantDesFils
- print ('_________________________________')
- print ('texteComplexe')
- print (self.texteComplexe)
- print ('_________________________________')
- print ('texteSimple')
- print (self.texteSimple)
- print ('_________________________________')
- print ('texteComplexeVenantDesFils')
- print (self.texteComplexeVenantDesFils)
- print ('_________________________________')
self.texteComplexe=self.texteComplexe+self.texteComplexeVenantDesFils
self.label='BlocAmbigu'
self.construitEntites(mc.mcXSD)
+ def constructionArbrePossibles(self):
+ toutesLesLignes=[[]]
+ for child in self.mcXSD :
+ if not hasattr(child, 'arbrePossibles') : child.construitArbrePossibles()
+ if child.label != 'BLOC' :
+ toutesLesLignes = deepcopy(self.fusionne2Listes(toutesLesLignes, child.arbrePossibles))
+ else :
+ toutesLesLignes = deepcopy(self.fusionne2Listes(toutesLesLignes, [child.nom, []]))
+
+ lignesAGarder=[]
+ for ligne in toutesLesLignes:
+ blocContenus=[]
+ aAjouter=True
+ for mc in ligne :
+ objMC=self.entites[mc][0]
+ if objMC.label == 'BLOC' :
+ blocContenus.append(objMC)
+ for b in blocContenus :
+ for frere in blocContenus [blocContenus.index(b)+1 :] :
+ if b.isDisjoint(frere) : continue
+ aAjouter=False
+ break
+ if not aAjouter : break
+ if aAjouter and ligne not in lignesAGarder :
+ lignesAGarder.append(ligne)
+
+ print ("______________________________________")
+ for l in lignesAGarder : print (l)
+ print (len(lignesAGarder))
+ print ("______________________________________")
+ self.arbrePossibles=[]
+ for ligne in lignesAGarder :
+ for newLigne in self.deploye(ligne):
+ if newLigne not in self.arbrePossibles : self.arbrePossibles.append(newLigne)
+ toto=deepcopy(self.arbrePossibles)
+ toto.sort()
+ for l in toto : print (l)
+ print ("______________________________________")
+
+
+ def deploye (self, ligne):
+ toutesLesLignes=[[]]
+ for mc in ligne :
+ objMC=self.entites[mc][0]
+ if objMC.label == 'BLOC' :
+ toutesLesLignes = deepcopy(self.remplaceNomListeParContenu(toutesLesLignes, objMC.arbrePossibles))
+ else :
+ toutesLesLignes = deepcopy(self.adjointUnMot(toutesLesLignes,mc ))
+ return toutesLesLignes
+
def construitArbrePossibles(self):
# inutile car on a deja l arbre mais appele parfois
pass
def nomComplet(self) :
print (self, self.nom)
-# def creeTexteComplexe(self,laListe):
-# if (len(laListe))==1:
-# print ('creeTexteComplexe', laListe,' ____________________')
-# # on a une sequence
-# self.texteComplexe += debutTypeCompoSeq
-# eltSequence = laListe[0]
-# print ( 'eltSequence', eltSequence)
-# index=0
-# while (type(eltSequence[index]) != types.ListType ):
-# #while (type(eltSequence[index]) == types.StringType ):
-# nomFils=eltSequence[index]
-# index=index+1
-# print ('ds while')
-# print (nomFils, index)
-# 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 factoriseEtCreeDump(self, laListe, dejaDansUneSequence=False, indent=2 ,nomAppel=None):
- ## nomAPpel ne sert que pour le debug
- print ('debut factorise ********', laListe, indent, nomAppel )
maListeRetour=[]
aReduire={}
if [] in laListe :
declencheChoiceAvecSeqVid=True
- laListe.remove([])
+ while [] in laListe : laListe.remove([])
+ min=0
else :
declencheChoiceAvecSeqVid=False
+ min=1
for ligne in laListe :
- if aReduire.has_key(ligne[0]) : aReduire[ligne[0]].append(ligne[1:])
- else : aReduire[ligne[0]]=[ligne[1:],]
+ if aReduire.has_key(ligne[0]) :
+ if len(ligne) == 1 :aReduire[ligne[0]].append([])
+ else : aReduire[ligne[0]].append(ligne[1:])
+ else :
+ if len(ligne) == 1 : aReduire[ligne[0]]=[[]]
+ else : aReduire[ligne[0]]=[ligne[1:],]
if len(aReduire.keys()) == 1 :
else :
creeChoice=True
creeSequence=False
- self.texteComplexe += '\t'*indent + debutChoiceDsBloc; indent=indent+1
+ # pour regler le souci du 1er Niveau
+ if min == 1 : self.texteComplexe += '\t'*indent + debutChoiceDsBloc; indent=indent+1
+ else : self.texteComplexe += '\t'*indent + debutChoiceDsBlocAvecMin.format(min); indent=indent+1
else :
- self.texteComplexe += '\t'*indent + debutChoiceDsBloc; indent=indent+1
+ self.texteComplexe += '\t'*indent + debutChoiceDsBlocAvecMin.format(min); indent=indent+1
creeChoice=True
creeSequence=False
else : self.factoriseEtCreeDump(listeSuivante,creeSequence, indent+int(creeSequence),nomMC)
if creeChoice : indent=indent -1 ; self.texteComplexe += '\t'*(indent) + finSequenceDsBloc
- if declencheChoiceAvecSeqVid :
- self.texteComplexe += '\t'*indent + debSequenceDsBloc
- self.texteComplexe += '\t'*indent + finSequenceDsBloc
+ #if declencheChoiceAvecSeqVid :
+ # self.texteComplexe += '\t'*indent + debSequenceDsBloc
+ # self.texteComplexe += '\t'*indent + finSequenceDsBloc
if creeChoice : indent=indent -1 ; self.texteComplexe += '\t'*indent + finChoiceDsBloc
if creeSequence : indent=indent -1 ; self.texteComplexe += '\t'*(indent) + finSequenceDsBloc
#if doitFermerSequence : indent=indent-1;self.texteComplexe += '\t'*(indent) + finSequenceDsBloc
- print ('________ fin factorise________' , laListe)
return (maListeRetour)
self.texteComplexeVenantDesFils += mc.texteComplexe
self.texteSimple += mc.texteSimple
- # def verifieDisjoint(self, laListe):
-# # != a un premier dans les communs car laListe n est pas composee de la
-# # meme maniere dans les 2 cas
-# # ici on a juste des noms et on se moque du caractere optionnel
-# # tout le monde est obligatoire
-# print ('verifieDisjoint', laListe)
-# mesPremiers=set()
-# for listeDeNoms in laListe :
-# if listeDeNoms == [] : continue
-# if listeDeNoms[0] in mesPremiers : return False
-# return True
-#
-#
-#
-# def factorise(self, laListe):
-# print ('debut factorise ********', laListe)
-# suiteOptionnelle=False
-# maListeRetour=[]
-# aReduire={}
-# for ligne in laListe :
-# if ligne == [] :
-# suiteOptionnelle=True
-# continue # PN : faire qqchose pour transmettre le car optionnel
-# 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 ',laListe, maListeRetour, suiteOptionnelle)
-# print ('________ fin factorise________' , laListe)
-# print ('_________________________')
-# return maListeRetour
-#
blocsDejaDumpes=set()
#for nom in self.ordre_mc:
# mcFils = self.entites[nom]
- print ('***************',self.nom)
for mcFils in self.mcXSD :
- print ('_________mcFls', mcFils,mcFils.nom)
if not (isinstance(mcFils, Accas.BLOC)) :
mcFils.dumpXsd(dansFactorisation)
self.texteComplexe += mcFils.texteElt
texteComplexeVenantDesFils += mcFils.texteComplexe
continue
else :
- print ('_________bloc', mcFils,mcFils.nom)
if hasattr(mcFils,'nomXML') and mcFils.nomXML in blocsDejaDumpes: continue
if hasattr(mcFils,'nomXML') : blocsDejaDumpes.add(mcFils.nomXML)
- print ('_________bloc', mcFils,mcFils.nom)
mcFils.dumpXsd(dansFactorisation)
self.texteComplexe += mcFils.texteElt
self.texteSimple += mcFils.texteSimple
return texteComplexeVenantDesFils
def dumpXsd(self,dansFactorisation=False):
- print ('------------------------------------------------', self.nom)
if PourTraduction : print (self.nom)
self.prepareDumpXSD()
return True
def prepareDumpXSD(self):
- print ('prepareDumpXSD', self.nom)
self.tousLesFils=[]
self.mcXSD=[]
for nomMC in self.ordre_mc:
indexFin=liste[-1][1]+1
nomFin=liste[-1][0].nom
nom=nomDebut+'_'+nomFin
+ listeAFactoriser=[]
+ for i in range(indexDebut, indexFin) :
+ listeAFactoriser.append((self.mcXSD[i],i))
newListe=self.mcXSD[0:indexDebut]
#print (newListe, newListe.__class__)
- monEltFacteur=X_factCompoAmbigu(nom,liste,self)
+ monEltFacteur=X_compoFactoriseAmbigu(nom,listeAFactoriser,self)
newListe.append(monEltFacteur)
newListe=newListe+self.mcXSD[indexFin:]
self.mcXSD=newListe
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_BLOC (X_definitionComposee):
#-----------------------------------
def dumpXsd(self,dansFactorisation=False):
- print ('------------------------------------------------')
- print ('dumpXsd de ' , self.nom)
- print (self.nomXML)
self.tousLesFils=[]
self.getNomDuCodeDumpe()
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)
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=[]
-
+ self.arbrePossibles=[[],]
+ for child in self.mcXSD :
+ if not hasattr(child, 'arbrePossibles') : child.construitArbrePossibles()
+ if child.label != 'BLOC' :
+ self.arbrePossibles = deepcopy(self.adjoint(self.arbrePossibles, child.arbrePossibles))
+ else :
+ self.arbrePossibles = deepcopy(self.fusionne2Listes(self.arbrePossibles, child.arbrePossibles))
#--------------------------------
self.maxInclusive=self.val_max
self.minInclusive=self.val_min
if self.val_min == float('-inf') and val_max== float('inf') : return
- print ('il faut affiner le type du SIMP ', self.nom)
+ #print ('il faut affiner le type du SIMP ', self.nom)
if self.val_max == '**' or self.val_max == float('inf') : self.maxInclusive=None
else : self.maxInclusive = self.val_max
if self.val_min == '**' or self.val_max == float('-inf') : self.maxInclusive=None
def traduitMinMax(self):
if self.min == 1 and self.max == 1 : return
- print ('il faut creer une liste ' , self.nom)
+ #print ('il faut creer une liste ' , self.nom)
def compare(self,autreMC):
if self.label != autreMC.label : return False
