import types
import Accas
import imp
+from copy import deepcopy
+
# CONTEXT est accessible (__init__.py de Noyau)
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)
# 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()
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
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):
#--------- ------------------------
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,]
#-----------------------------------
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 :
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()
# 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
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)
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
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 :
#-----------------
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]:
#import pprint
#if (not PourTraduction) and (dico != {}) : pprint.pprint(dico)
+ print ('__________________________ decommenter pour le texteXSD________________________')
print (self.texteXSD)
return self.texteXSD
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)
