Java > Open Source Codes > cve > esecutori > components > specificaLV > Specifica


1 /*
2 * @(#)Specifica.java 1.00 22/02/02
3 *
4 * @Author Domenico Ventriglia
5 */
6 package cve.esecutori.components.specificaLV;
7
8 import cve.esecutori.servizioEACesec.*;
9 import cve.staticLayout.*;
10 import cve.util.*;
11
12 import java.io.*;
13 import java.util.*;
14
15 import org.jdom.*;
16 import org.jdom.input.SAXBuilder;
17 import org.jdom.output.XMLOutputter;
18
19 import org.apache.log4j.Logger;
20
21 /**
22 * Questa classe fornisce i servizi utili alla gestione di una
23 * specifica di un linguaggio visuale (alfabeto e regole).
24 *
25 */
26 final public class Specifica implements ISpecifica, Cloneable {
27
28    /**
29    * i documenti dom creati da sax relativi alle regole e all'alfabeto
30    **/
31    private Document docReg,docAlf;
32
33    /**
34    * insieme di elementi relazioni e non relazioni la cui chiave e' il nome
35    * e il valore e' di tipo Element (elemento alfabeto dom xml)
36    **/
37    private HashMap relationSet, nonRelSet;
38
39    /**
40    * insieme dei nomi degli Element Kfree creation
41    **/
42    private HashSet elementFree;
43
44    /**
45    * insieme dei nomi degli Element dell'alfabeto
46    **/
47    private HashSet elementAlf;
48
49    /**
50    * La chiave e' il nome dell'elemento dell'alfabeto, mentre
51    * il valore e' un vettore in cui sono memorizzati sequenzialmente
52    * nome attributo e tipo
53    **/
54    private HashMap scheletro;
55
56    /**
57    * La chiave e' il nome dell'elemento dell'alfabeto, mentre
58    * il valore e' una istanza della classe rappresentation
59    **/
60    private HashMap rappresentation;
61
62    private Rules rules;
63
64    /* ################### METODI PUBLIC ###########################
65    ############################################################ */
66
67    /**
68    * pre:
69    * post:result e' la costruzione di due documenti Dom: docReg e docAlf
70    * @param Filereg indica il file dove sono contenute le regole
71    * @param FileAlf indica il file dove è contenuto l'alfabeto
72    *
73    **/
74    public Specifica(String FileReg,String FileAlf)throws java.io.IOException {
75       Cve.errLog.debug("");
76       relationSet=new HashMap();
77       nonRelSet=new HashMap();
78       scheletro=new HashMap();
79       rappresentation=new HashMap();
80       elementFree=new HashSet();
81       elementAlf=new HashSet();
82       rules=new Rules();
83       // costriusco i document docreg docalf sfruttando saxbuilder
84 buildDocument(FileAlf,FileReg);
85       Element rootReg=docReg.getRootElement();
86       // calcola elementi free
87 AnalizzaRegoleW.freeCreation(rootReg);
88       // partiziono elementi relazioni e non, lancia setScheletro, setRappresentation
89 partitionElement();
90       //setto l'insieme delle regole (SpecificationRules)
91 // in ogni regola metto source, target, relazione
92 setRules();
93       // ad ogni elemento relazione sono associati i suoi membri
94 // trovaSourceTarget() crea i link
95 creaGrafoAssociazioni();
96    }
97
98    /**
99    * pre:
100    * post:result e' la costruzione un documenti Dom: docAlf
101    * e delle strutture scheletro e rappresentazione
102    * @param FileAlf indica il file dove è contenuto l'alfabeto
103    *
104    **/
105    public Specifica(String FileAlf)throws java.io.IOException {
106       Cve.errLog.debug("");
107       relationSet=new HashMap();
108       nonRelSet=new HashMap();
109       scheletro=new HashMap();
110       rappresentation=new HashMap();
111       elementAlf=new HashSet();
112       // costriusco docalf sfruttando saxbuilder
113 buildDocument(FileAlf);
114       // partiziono elementi relazioni e non
115 // lancia setScheletro, setRappresentation
116 partitionElement();
117    }
118
119    public Object clone() {
120       Cve.errLog.debug("");
121       try {
122          Specifica spe=(Specifica)super.clone();
123          return (Object )spe;
124       }catch(CloneNotSupportedException e){
125          Cve.errLog.error(e.toString());
126          throw new InternalError (e.toString());
127       }
128    }
129
130    /**
131    * pre:
132    * post:result e' la collezione di tutte le relazioni (ElementRel)
133    * presenti nell'alfabeto
134    */
135    public Collection getRelation() {
136       Cve.errLog.debug("");
137       return ((Collection)(relationSet.values()));
138    }
139
140    /**
141    * pre:
142    * result: Rules contiene tutte le istanze di Rule e l'assert
143    *
144    **/
145    public Rules getRules() {
146       Cve.errLog.debug("");
147       return rules;
148    }
149
150    /**
151    * pre:
152    * post:result e' la collezione di tutte gli elementi non relazioni
153    * presenti nell'alfabeto
154    */
155    public Collection getNonRelation() {
156       Cve.errLog.debug("");
157       return ((Collection)(nonRelSet.values()));
158    }
159
160    /**
161    * pre:
162    * post:result e' la collezione di tutte gli elementi non relazioni
163    * presenti nell'alfabeto
164    */
165    public Map getScheletro() {
166       Cve.errLog.debug("");
167       return (scheletro);
168    }
169
170    /**
171    * pre:
172    * post:result e' la Map composta dalle coppie nameElemento e
173    * la rappresentazione (incona, cpRappresentation)
174    * presenti nell'alfabeto
175    */
176    public Map getRappresentation() {
177       Cve.errLog.debug("");
178       return (rappresentation);
179    }
180
181    /**
182    * pre:
183    * post:result e' la collezione di tutte gli elementi ElementRel
184    * Tali elementi gestiscono le associazioni
185    */
186    public Collection getRelationAssociation(){
187       Cve.errLog.debug("");
188       return ((Collection)(relationSet.values()));
189    }
190
191    /**
192    * pre:
193    * post:result e' il Set degli elementi target per la relazione
194    * considerata. Vale Null se non vi sono target
195    * @param relAlf e' un elemento di tipo relazione proveniente dall'alfabeto
196    * @param relNonRel e' un elemento non relazione proveniente dalle regole
197    *
198    * Logica: 1) prendo la relazione,2) prendo il link fra la relazione e
199    * l'elemento, 3)prendo i target
200    */
201    public Set getTarget (ElementRel relAss, ElementNonRel ele) {
202       // prendo l'elemento che gestisce le associazioni
203 // ElementRel relAss=(ElementRel)relationSet.get(relAlf.getAttributeValue("name"));
204 Cve.errLog.debug("");
205       System.out.println(" Specifica.getTarget: relazione: "+ relAss.getName() + " NonRel: " + ele.getName());
206
207       Element eleNonRel=ele.getElementXml();
208       Element relAlf=relAss.getElementXml();
209       if (relAss!=null){
210          // prendo tutte le associazioni esistenti per la relazione alf data
211 HashSet linkAll=new HashSet(relAss.getLinkAll());
212          // cerco il link fra la relazione e l'elemento eleNonRel
213 Iterator itLinks=linkAll.iterator();
214          while (itLinks.hasNext()){
215             LinkRelNonRel linkCercato=(LinkRelNonRel)itLinks.next();
216             String nameEleLink=((ElementNonRel)linkCercato.getNonRel()).getElementXml().getAttributeValue("name");
217             String nameEleCercato=eleNonRel.getAttributeValue("name");
218             if (nameEleLink.equals(nameEleCercato)) {
219                Vector app=new Vector(linkCercato.getTarget());
220                //System.out.println(" il numero di link e' "+linkAll.size() );
221 for (int i=0;i<app.size();i++) {
222                   //System.out.println(" GetTarget relazione="+relAlf.getAttributeValue("name")+" elemento="+eleNonRel.getAttributeValue("name") );
223 //System.out.println(" trovato target "+(String)app.get(i) ); // trovato link giusto
224 System.out.println(" Specifica.getTarget: per la relazione: "+ relAlf.getAttributeValue("name") + " ed elemento: " + eleNonRel.getAttributeValue("name") + " Il TARGET è: " + (String )app.get(i));
225
226                } // trovato link giusto
227 return linkCercato.getTarget();
228             }
229          }
230       }
231       return null;
232    }
233
234    /**
235    * pre:
236    * post:result e' la collezione di tutte gli elementi free
237    * presenti nelle regole
238    */
239    public Collection getFreeCreation() {
240       Cve.errLog.debug("");
241       return elementFree;
242    }
243
244    /**
245    * pre:
246    * post:result e' la collezione di tutte i nomi degli elementi dell'alfabeto
247    */
248    public Collection getElementAlf(){
249       Cve.errLog.debug("");
250       return elementAlf;
251    }
252
253    /**
254    * pre:
255    * post:result e' il Set degli elementi target per la relazione
256    * considerata. Vale Null se non vi sono target
257    * @param relAss e' un elemento di tipo ElementRel che gestisce la relazione
258    * @param relNonRel e' un elemento non relazione proveniente dalle regole
259    *
260    * Logica: 1) prendo la relazione,2) prendo il link fra la relazione e
261    * l'elemento, 3)prendo i source
262    */
263    public Set getSource (ElementRel relAss,ElementNonRel ele) {
264       // prendo l'elemento che gestisce le associazioni
265 //System.out.println(" numero di relazioni "+ relationSet.size());
266 // ElementRel relAss=(ElementRel)relationSet.get(relAlf.getAttributeValue("name"));
267 Cve.errLog.debug("");
268       System.out.println(" Specifica.getSource: relazione: "+ relAss.getName() + " NonRel: " + ele.getName());
269
270       Element eleNonRel=ele.getElementXml();
271       // prendo tutte le associazioni esistenti per la relazione alf data
272 if (relAss!=null){
273          HashSet linkAll=new HashSet(relAss.getLinkAll());
274          // cerco il link fra la relazione e l'elemento eleNonRel
275 Iterator itLinks=linkAll.iterator();
276          while (itLinks.hasNext()){
277             LinkRelNonRel linkCercato=(LinkRelNonRel)itLinks.next();
278             String nameEleLink=((ElementNonRel)linkCercato.getNonRel()).getElementXml().getAttributeValue("name");
279             String nameEleCercato=eleNonRel.getAttributeValue("name");
280             if (nameEleLink.equals(nameEleCercato)){
281                // trovato link giusto
282 if (linkCercato.getSource()!=null){
283                   Vector app=new Vector(linkCercato.getSource());
284                   for (int i=0;i<app.size();i++){
285                      ViewLog.writeInLog(" Rispetto alla relazione= "+((Element)(relAss.getElementXml())).getAttributeValue("name")+" e all'elemento="+eleNonRel.getAttributeValue("name")+"\n" );
286                      ViewLog.writeInLog(" Il source e' "+(String )app.get(i)+"\n" );
287                      System.out.println(" Specifica.getSource: per la relazione: "+ ((Element)(relAss.getElementXml())).getAttributeValue("name") + " ed elemento: " + eleNonRel.getAttributeValue("name") + " Il SOURCE è: " + (String )app.get(i));
288                   }
289                }
290                return linkCercato.getSource();
291             }
292          }
293       }
294       return null;
295    }
296
297    /**
298    * pre:
299    * post:result e' il Set degli elementi SourceTarget per la relazione
300    * considerata. Vale Null se non vi sono target
301    * @param relAss e' un elemento di tipo ElementRel che gestisce le relazioni
302    * @param relNonRel e' un elemento non relazione proveniente dalle regole
303    *
304    */
305    public Set getSourceTarget (ElementRel relAss, ElementNonRel ele) {
306       // prendo l'elemento che gestisce le associazioni
307 //System.out.println(" numero di relazioni "+ relationSet.size());
308 // ElementRel relAss=(ElementRel)relationSet.get(relAlf.getAttributeValue("name"));
309 Cve.errLog.debug("");
310       System.out.println(" Specifica.getSourceTarget: relazione: "+ relAss.getName() + " NonRel: " + ele.getName());
311
312       Element eleNonRel=ele.getElementXml();
313       Element relAlf=relAss.getElementXml();
314       // prendo tutte le associazioni esistenti per la relazione alf data
315 if (relAss!=null) {
316          HashSet linkAll=new HashSet(relAss.getLinkAll());
317          // cerco il link fra la relazione e l'elemento eleNonRel
318 Iterator itLinks=linkAll.iterator();
319          while (itLinks.hasNext()) {
320             LinkRelNonRel linkCercato=(LinkRelNonRel)itLinks.next();
321             String nameEleLink=((ElementNonRel)linkCercato.getNonRel()).getElementXml().getAttributeValue("name");
322             String nameEleCercato=eleNonRel.getAttributeValue("name");
323             //System.out.println(" sto ercando "+nameEleCercato );
324 if (nameEleLink.equals(nameEleCercato)) {
325                // trovato link giusto
326 if (linkCercato.getSourceTarget()!=null) {
327                   Vector app=new Vector(linkCercato.getSourceTarget());
328                   for (int i=0;i<app.size();i++){
329                      ViewLog.writeInLog(" Rispetto alla relazione= "+relAlf.getAttributeValue("name")+" e all'elemento= "+eleNonRel.getAttributeValue("name") +"\n");
330                      ViewLog.writeInLog(" Un sourceTarget e' "+(String )app.get(i)+"\n" );
331                      System.out.println(" Specifica.getSourceTarget: per la relazione: "+ relAlf.getAttributeValue("name") + " ed elemento: " + eleNonRel.getAttributeValue("name") + " Il SOURCETARGET è: " + (String )app.get(i));
332                   }
333                }
334                return linkCercato.getSourceTarget();
335             }
336          }
337       }
338       return null;
339    }
340
341    /**
342    * Simulazione del componente di specifica
343    **/
344    public static void main(String [] args) throws java.io.IOException {
345       InputStreamReader ir,ir1;
346       System.out.println("dammi l'alfabeto da caricare");
347       ir=new InputStreamReader(System.in); // da byte a caratteri
348 BufferedReader in=new BufferedReader (ir); // gestione caratteri
349 String filealfa=in.readLine();
350       System.out.println("dammi le regole da caricare");
351       ir1=new InputStreamReader(System.in); // da byte a caratteri
352 BufferedReader in1=new BufferedReader (ir1); // gestione caratteri
353 String filerego=in1.readLine();
354
355       System.out.println("");
356       System.out.println(" SIMULAZIONE DELL'ANALISI DI UNA SPECIFICA: ALFABETO e REGOLE. (Specifica.class)");
357       System.out.println("");
358       Specifica spe=new Specifica(filerego,filealfa);
359
360       System.out.println("");
361       System.out.println(" SIMULAZIONE SPECIFICA solo alfabeto");
362       System.out.println("");
363       Specifica spe1=new Specifica(filealfa);
364    }
365
366    /* ################### METODI PRIVATE ###########################
367    ############################################################ */
368
369    /**
370    * pre:
371    * post:result viene riempita la collezione elementRelSet.
372    * All'interno vi sono le coppie (nome, ElementRel)
373    *
374    * @param rel e' un elemento di tipo relazione proveniente dall'alfabeto
375    *
376    * Logica: per ogni relazione viene creato un ElementRel. Tale elemento
377    * gestisce i link con gli ElementNonRel (vedere LinkRelNonRel).
378    * Dato una relazione per trovare i source e i target bisogna
379    * considerare se:
380    * 1- La relazione compare nel conseguente della regola considerata
381    * 2- Se la relazione e' non orientata, gli elementi dell'antecedente
382    * sono source e target
383    * Se la relazione è orientata, devo controllare gli id degli attributi
384    * della relazione
385    */
386    private void trovaSourceTarget (Element relAlf){
387       Cve.errLog.debug("");
388       System.out.println(" Specifica.trovaSourceTarget: elemento: "+ relAlf.getName());
389       Element rootReg=docReg.getRootElement();
390       HashSet elementSource=new HashSet();
391       List setRule=rootReg.getChildren("Rule");
392       for(int j=0; j<setRule.size();j++) { //per ogni regola
393 boolean trovatoRel=false;
394          Element rule=(Element)(setRule.get(j));
395          // controllo se la relazione e' presente nel conseguente
396 // della regola esaminata
397 Element relRule=AnalizzaRegoleW.isInConseguente(rule, relAlf);
398          if (relRule!=null) {// se relAlf e' nel conseguente
399 Object nonO=((Object )( relAlf.getChild("Relation").getChild("Orientation")));
400             if ( nonO==null ){ // rel non orientata, gestisco associazioni
401 List cons=rule.getChild("Conseguente").getChildren();
402                System.out.println(" Specifica.trovaSourceTarget: RELAZIONE NON ORIENTATA");
403                if (cons.size()==3){// caso binario
404 //metto l'elemento 1 come sourcetarget dell'elemento 0
405 //System.out.println(" inserisco in "+(String)((Element)cons.get(0)).getAttributeValue("name"));
406 associazione(relAlf,(Element)cons.get(0),(Element)cons.get(1), "sourceTarget");
407                   //metto l'elemento 0 come sourcetarget dell'elemento 1
408 //System.out.println(" inserisco in "+(String)((Element)cons.get(1)).getAttributeValue("name"));
409 associazione(relAlf,(Element)cons.get(1),(Element)cons.get(0), "sourceTarget");
410                }
411             }
412             else { //rel orientata (vi e' il tag <Orientation> )
413 System.out.println(" Specifica.trovaSourceTarget: RELAZIONE ORIENTATA");
414                // prendo l'id source della relazione
415 String idSource=AnalizzaRegoleW.findValueAttriEle("source", relRule);
416                idSource=idSource.trim();
417                System.out.println(" Specifica.trovaSourceTarget: RELAZIONE ORIENTATA source: "+idSource);
418                // cerco nell'antecedente l'elemento con id source
419 Element eleSource=AnalizzaRegoleW.findIdElementAnt(rule, idSource);
420                // prendo l'id target della relazione
421 String idTarget=AnalizzaRegoleW.findValueAttriEle("target", relRule);
422                idTarget=idTarget.trim();
423                System.out.println(" Specifica.trovaSourceTarget: RELAZIONE ORIENTATA target: "+idTarget);
424
425                // cerco nell'antecedente l'elemento con id voluto
426 Element eleTarget=AnalizzaRegoleW.findIdElementAnt(rule, idTarget);
427                if (eleSource!=null&&eleTarget!=null){
428                   System.out.println(" Specifica.trovaSourceTarget: RELAZIONE ORIENTATA: creazione Associazione ");
429
430                   // metto come target di relAlf ripetto a eleSoure eleTarget
431 associazione(relAlf,eleSource,eleTarget, "target");
432                   // metto come source di relAlf rispetto a eleTarget eleSource
433 associazione(relAlf,eleTarget,eleSource, "source");
434                }
435             }
436          }
437       }
438    }
439
440
441    /**
442    * pre:
443    * post:metto in relationSet gli elementi alfabeto relazione
444    * mentre in nonRelSet vi sono gli elementi dell'alfabeto non relazioni
445    * Ogni membro di questi due insiemi ha come chiave il nome elemento e
446    * come valore una istanza di ElementRel
447    *
448    * Logica: un elemento dell'alfabeto e' relazione se contiene al suo
449    * interno il tag <relazione>
450    */
451    private void partitionElement(){
452       Cve.errLog.debug("");
453       ViewLog.writeInLog(""+"\n");
454       Element rootAlf=docAlf.getRootElement();
455       //VD
456 boolean orientationB,relationB;
457       String nameS="",nameT="";
458       List figliAlf=rootAlf.getChildren(); // prendo elementi alfabeto
459 ViewLog.writeInLog(" ANALISI DELLO SCHELETRO DEGLI ELEMENTI (AnalizzaAlfabetoW.getScheltro() ************"+"\n");
460       for (int i=0; i<figliAlf.size(); i++){
461          Representation rap;
462          //VD
463 orientationB=false;
464          relationB=false;
465          Element ele=(Element)(figliAlf.get(i)); // prendo un singolo elemento
466 List eleAttribute=ele.getAttributes();
467          // se l'elemento dell'alfabeto considerato ha un sotto elemento
468 // <relazione> allora e' una relazione
469 List relation=ele.getChildren("Relation");
470          String name=ele.getAttributeValue("name");
471          System.out.println(" name --> "+name);
472          // contiene tutti i nomi degli elementi dell'alfabeto
473 elementAlf.add(name);
474          // metto nello scheletro gli attributi dell'elemento
475 Vector attributi=AnalizzaAlfabetoW.setScheletro(ele,name);
476          scheletro.put(name,(Object )attributi);
477          // metto in rappresentation l'icona e cp dell'elemento
478 if (relation.size()==1){
479             //VD
480 relationB=true;
481             List orient=ele.getChildren("Orientation");
482             if (orient!=null){
483                List source=ele.getChildren("Source");
484                nameS=ele.getAttributeValue("name");
485                List target=ele.getChildren("Target");
486                nameT=ele.getAttributeValue("name");
487                orientationB=true;
488             }
489             rap=AnalizzaAlfabetoW.setRappres(ele,name,relationB,orientationB,nameS,nameT);
490             //aggiungo un elemento di tipo relationSet nella hashTable
491 ElementRel eleRel=new ElementRel(ele,name);
492             relationSet.put((Object )name, (Object )eleRel);
493             ViewLog.writeInLog(" e' una relazione "+"\n");
494             System.out.println(" name --> "+name+" è una relazione con Source: " + nameS+ " Target: " + nameT);
495          }else {// elemento non relazione
496 //VD
497 rap=AnalizzaAlfabetoW.setRappres(ele,name,relationB,orientationB,"","");
498             String nameid=AnalizzaAlfabetoW.findNameId(name,rootAlf);
499             ElementNonRel eleNonRel=new ElementNonRel(ele,name,nameid);
500             System.out.println(" name --> "+name+" nameid ->"+nameid);
501             nonRelSet.put((Object )name, (Object )eleNonRel);
502             ViewLog.writeInLog(" non e' relazione "+"\n");
503             System.out.println(" name --> "+name+" NON è una relazione");
504
505          }
506          rappresentation.put(name,rap);
507       }
508    }
509
510    /**
511    * pre: nessuna
512    * post:come result viene crato un link fra una relazione e un elemento
513    * non relazione
514    *
515    * @param rel la relazione
516    * @param eleEsaminato l'elemento che voglio associare a rel
517    * @param sourceTarget l'elemento che e' un voglio inserire negli attributi
518    * del link
519    * @param cosafare il ruolo svolto da sourceTarget nel link
520    * (source, target, sourceTarget)
521    *
522    * Logica: 1) trovo la relazione responsabile dei link
523    * 2) trovo, se esiste, il link fra la relazione e l'elemento
524    * 3) aggiorno gli attributi del link
525    *
526    */
527    private void associazione (Element rel, Element eleEsaminato, Element sourceTarget, String cosafare) {
528       Cve.errLog.debug("");
529       System.out.println(" Specifica.associazione: relazione: "+ rel.getName() +" eleEsaminato: " + eleEsaminato.getName()+ " SourceTarget: "+sourceTarget.getName()+" CosaFare: "+ cosafare );
530
531       //trovo la relazione nella hashtable ElementRel (la chiave e' il nome)
532 ElementRel eleRel=(ElementRel)relationSet.get((Object )rel.getAttributeValue("name"));
533       if (eleRel!=null){
534          //prendo il link con elementoEsaminato, se non esiste lo crea
535 LinkRelNonRel lST= eleRel.setLink(eleEsaminato);
536          String nameST=sourceTarget.getAttributeValue("name");
537          // inserisco il sourcetarget nel link corretto
538 if (cosafare.equals("source"))
539          lST.insertSource(nameST);
540          if (cosafare.equals("sourceTarget"))
541          lST.insertSourceTarget(nameST);
542          if (cosafare.equals("target"))
543          lST.insertTarget(nameST);
544       }
545    }
546
547    // creo dom per alfabeto e regole
548 private void buildDocument(String FileAlf,String FileReg){
549       Cve.errLog.debug("");
550       try {
551          // vanno messi i controlli di correttezza
552 SAXBuilder builder = new SAXBuilder(false);
553          docReg = builder.build(new File(FileReg));
554          docAlf = builder.build(new File(FileAlf));
555          //System.out.println(" Costruttore : costruiti i due doc (dom)");
556 } catch (JDOMException e) {
557          Cve.errLog.error(e.toString());
558       } catch (Exception e) {
559          Cve.errLog.error(e.toString());
560       }
561    }
562
563    // creo dom solo per alfabeto
564 private void buildDocument(String FileAlf){
565       Cve.errLog.debug("");
566       try {
567          // vanno messi i controlli di correttezza
568 SAXBuilder builder = new SAXBuilder(false);
569          docAlf = builder.build(new File(FileAlf));
570          //System.out.println(" Costruttore : costruiti i due doc (dom)");
571 } catch (JDOMException e) {
572          Cve.errLog.error(e.toString());
573       } catch (Exception e) {
574          Cve.errLog.error(e.toString());
575       }
576    }
577
578    /**
579    * Logica: vengono prese tutte le relazioni e le non relazioni.
580    * Per ogni relazione prendo i membri (TROVASOURCETARGET).
581    * Result: ad ogni elemento relazione vengono associati gli elementi
582    * dell'alfabeto coivolti
583    **/
584    private void creaGrafoAssociazioni() {
585       Cve.errLog.debug("");
586       ViewLog.writeInLog(" "+"\n");
587       ViewLog.writeInLog(" CREO LE ASSOCIAZIONI FRA LE RELAZIONI E I SUOI MEMBRI (.creaGrafoAssociazioni() ************"+"\n");
588       ViewLog.writeInLog(" Per ogni relazione mi interessa sapere quali possono essere i suoi possibili target, source, source-target "+"\n");
589       ViewLog.writeInLog(" Per otenere tali informazioni devo analizzare tutte le regole dove la relazione e' contenuta"+"\n");
590       System.out.println(" Specifica.creaGrafoAssociazioni");
591       // prendo tutte le relazioni (riferimenti ad ElementRel,
592 // classe che contiene a sua volta rif ad elemento alfabeto)
593 Vector rel=new Vector(getRelation());
594       System.out.println(" Specifica.creaGrafoAssociazioni: numero relazioni: " + rel.size());
595
596       // prendo tutte le non relazioni (analogo alla precedente)
597 Vector nonRel=new Vector(getNonRelation());
598       System.out.println(" Specifica.creaGrafoAssociazioni: numero NON relazioni: " + nonRel.size());
599
600       for (int i=0;i<rel.size();i++){
601          ElementRel relAnalizzata=(ElementRel)rel.get(i);
602          String name=((Element)relAnalizzata.getElementXml()).getAttributeValue("name");
603          //questa e' la classe che crea i link
604 //cerco i source e i target della relazione esaminata
605 trovaSourceTarget( ((Element)relAnalizzata.getElementXml()) );
606          // visualizzo la struttura calcolata
607 System.out.println(" Specifica.creaGrafoAssociazioni: STRUTTURA CALCOLATA ");
608          for (int j=0;j<nonRel.size();j++){
609             ElementNonRel eleAnalizzato=(ElementNonRel)nonRel.get(j);
610             getSource(relAnalizzata,eleAnalizzato);
611             getTarget(relAnalizzata,eleAnalizzato);
612             getSourceTarget(relAnalizzata,eleAnalizzato);
613          }
614       }
615    }
616
617    /**
618    * Logica: Per ogni regola verifico se ha una relazione nel conseguente
619    * (non e' KFree). Aggiorno i source e e target della regola
620    * in funzione della relazione (orientata, non orientata)
621    * Result:mette le Rule all'interno della collezione rules
622    *
623    **/
624    private void setRules(){
625       Cve.errLog.debug("");
626       ViewLog.writeInLog(""+"\n");
627       ViewLog.writeInLog(" CREAZIONE DEI DESCRITTORI DELLE REGOLE (setRules() ************"+"\n");
628       System.out.println(" CREAZIONE DEI DESCRITTORI DELLE REGOLE (setRules() ************");
629
630       // prendo tutte le relazioni (riferimenti ad ElementRel)
631 Vector rels=new Vector(getRelation());
632       Element rootReg=docReg.getRootElement();
633       HashSet elementSource=new HashSet();
634       List setRule=rootReg.getChildren("Rule");
635       // per ogni regola
636 for(int j=0; j<setRule.size();j++) {
637          ViewLog.writeInLog(" Regola "+j+"\n");
638          System.out.println(" Regola "+j);
639          // istanza di Rule che contiene tutte le info relative ad una regola
640 Rule rul=new Rule();
641          boolean trovataRelCons=false;
642          Element rule=(Element)(setRule.get(j));
643          // inserisco commento e id nella regola
644 setComment(rule,rul);
645          setId(rule,rul);
646          // controllo se vi e' una relazione nel conseguente
647 // della regola esaminata
648 for (int i=0;i<rels.size();i++){
649             ElementRel relAnalizzata=(ElementRel)rels.get(i);
650             String nameRel=((Element)relAnalizzata.getElementXml()).getAttributeValue("name");
651             Element relAlf=((Element)relAnalizzata.getElementXml());
652             Element relRule=AnalizzaRegoleW.isInConseguente(rule, relAlf);
653             // se relAlf e' nel conseguente
654 if (relRule!=null) {
655                trovataRelCons=true;
656                rul.setType("rel");
657                System.out.println(" La Regola "+ j + " Contiene la relazione "+ nameRel);
658                rul.setRel(relAnalizzata);
659                //rule:Elemento XML , rul:Elemento Rule
660 setCondition(rule,rul);
661                setPrecondition(nameRel,rule,rul);
662                setPostcondition(nameRel,rule,rul);
663                Object nonO=((Object )( relAlf.getChild("Relation").getChild("Orientation")));
664                //se la rel e' non orientata
665 if ( nonO==null ){
666                   setRelationNonO (nameRel,rule,rul);
667                }//rel orientata (vi e' il tag <Orientation> )
668 else {
669                   setRelationO (relRule,rule,rul);
670                }
671             }
672          }
673          if (!(trovataRelCons)){
674             rul.setType("kfree");
675             setPostFree(rule,rul);
676          }
677          //aggiungo regola all'insieme delle regole
678 rules.addRule(rul);
679       }
680    }
681
682    /**
683    * Logica: metto in istRule tutti gli elementi dell'antecedente
684    * con i loro attributi
685    */
686    private void setPrecondition(String nameRel,Element rule,Rule istRul) {
687       Cve.errLog.debug("");
688       Vector attrListAnt;
689       Element rootAlf=docAlf.getRootElement();
690       List ant=rule.getChild("Antecedent").getChildren();
691       Iterator itAnt=ant.iterator();
692       // per ogni elemento dell'antecedente
693 while (itAnt.hasNext()){
694          Element ele=(Element)itAnt.next();
695          String nameNon=(String )ele.getAttributeValue("name");
696          //l'elemento che sto analizzando non e' la relazione
697 if (!(nameNon.equals(nameRel))){
698             String nameId=AnalizzaAlfabetoW.findNameId(nameNon,rootAlf);
699             //System.out.println(" Metto in antecedente "+nameNon+ " nome id "+nameId);
700 System.out.println(" #### Specifica.setPrecondition: Metto in antecedente "+nameNon+ " nome id "+nameId);
701             List attr=ele.getChildren("Attribute");
702             Iterator itAttr=attr.iterator();
703             attrListAnt=new Vector();
704             // metto in ElementNonRel tutti gli attributi esplicitati nell'antecedente
705 while (itAttr.hasNext()){
706                String nameAttr=(String )((Element)itAttr.next()).getAttributeValue("name");
707                attrListAnt.addElement(nameAttr);
708                //System.out.println(" In antecedente trovato l'attributo "+nameAttr);
709 System.out.println(" #### Specifica.setPrecondition: In antecedente trovato l'attributo "+nameAttr);
710             }
711             // aggiungo in ogni elemento gli attributi dichiarati nell'antecedente attrListAnt
712 // e null per attributi del conseguente
713 //System.out.println(" specifica dimensioni attrListAnt sono "+attrListAnt.size() );
714 System.out.println(" #### Specifica.setPrecondition: specifica dimensioni attrListAnt sono "+attrListAnt.size() );
715             ElementNonRel eleNonRel=new ElementNonRel(ele,nameNon,nameId,attrListAnt,null);
716             // metto come precondizione della regola l'elemento creato
717 istRul.addPrecondition(eleNonRel);
718          }
719       }
720    }
721
722    /**
723    * Logica: metto in istRule tutti gli elementi dell'antecedente
724    * con i loro attributi
725    */
726    private void setPostcondition(String nameRel,Element rule,Rule istRul) {
727       Cve.errLog.debug("");
728       Element rootAlf=docAlf.getRootElement();
729       List cons=rule.getChild("Conseguente").getChildren();
730       Iterator itCons=cons.iterator();
731       // per ogni elemento del conseguente
732 while (itCons.hasNext()){
733          Element ele=(Element)itCons.next();
734          // metto nella regola tutte le espressioni del conseguente
735 setCalcoliPost(ele,istRul);
736          // calcolo gli le attributi modificati del conseguente
737 Collection attributeCons=setAttributePost(ele);
738          String nameNon=(String )ele.getAttributeValue("name");
739          String nameId=AnalizzaAlfabetoW.findNameId(nameNon,rootAlf);
740          //System.out.println(" Metto in conseguente "+nameNon+ " nome id "+nameId);
741 //l'elemento che sto analizzando non e' la relazione
742 //GF
743 if (!(nameNon.equals(nameRel))){
744             // metto gli attributi modificati nel conseguente
745 ElementNonRel eleNonRel=new ElementNonRel(ele,nameNon,nameId,null,attributeCons);
746
747             // metto come conseguente della regola l'elemento creato
748 istRul.addConseguent(eleNonRel);
749          } else { // elemento relazione
750 ElementRel eleRel=new ElementRel(ele,nameNon,nameId,attributeCons);
751             // metto come conseguente della regola l'elemento creato
752 istRul.addConseguent(eleRel);
753          }
754
755          System.out.println(" #### Specifica.setPostcondition: Metto in Conseguente "+nameNon+ " nome id "+nameId);
756
757       }
758    }
759
760    // prendo assignament in cond e nella aggiungo regola
761 private void setCalcoliPost(Element ele,Rule istRule) {
762       Cve.errLog.debug("");
763       List assig=ele.getChildren();
764       Iterator itAss=assig.iterator();
765       while (itAss.hasNext()){
766          Element assignament=(Element)itAss.next();
767          Element copiaAss=(Element)assignament.clone();
768          istRule.addAssignmentCons(copiaAss);
769       }
770    }
771
772    // ritorna la collezione contenente i nomi degli
773 // gli attributi che vengono modificatinel conseguente
774 private Collection setAttributePost(Element ele) {
775       Cve.errLog.debug("");
776       String name=ele.getAttributeValue("name");
777       Vector attributes=new Vector();
778       List assig=ele.getChildren();
779       Iterator itAss=assig.iterator();
780       while (itAss.hasNext()){
781          Element assignament=(Element)itAss.next();
782          Element var=assignament.getChild("Var");
783          if (var!=null){
784             attributes.add(var.getAttributeValue("name"));
785             System.out.println(" Per l'elemento : " + name + " trovato attributo conseguente "+var.getAttributeValue("name"));
786          }
787       }
788       return attributes;
789    }
790
791    // scrivo il commento in una regola
792 private void setComment(Element rule,Rule istRul) {
793       Cve.errLog.debug("");
794       String descr=(String )rule.getAttributeValue("description");
795       //System.out.println(" Il commento e' "+ descr);
796 istRul.setComment(descr);
797    }
798
799    // scrivo l'id in una regola
800 private void setId(Element rule,Rule istRul) {
801       Cve.errLog.debug("");
802       String id=(String )rule.getAttributeValue("id");
803       //System.out.println(" L' id e' "+ id);
804 istRul.setId(id);
805    }
806
807    /**
808    * @Param: rule regola contenuta nel file delle regole
809    * istRule istanza della classe Rule
810    * Result: Inserisco tutti gli elementi non relazione presenti nel
811    * conseguente della regola esaminata
812    **/
813    private void setPostFree(Element rule,Rule istRul) {
814       Cve.errLog.debug("");
815       Element rootAlf=docAlf.getRootElement();
816       List cons=rule.getChild("Conseguente").getChildren();
817       Iterator itCons=cons.iterator();
818       while (itCons.hasNext()){
819          Element ele=(Element)itCons.next();
820          String nameNon=(String )ele.getAttributeValue("name");
821          //l'elemento che sto analizzando non e' la relazione
822 String nameId=AnalizzaAlfabetoW.findNameId(nameNon,rootAlf);
823          ElementNonRel eleNonRel=new ElementNonRel(ele,nameNon,nameId);
824          //metto l'elemento come source e target della regola
825 istRul.addPostFree(eleNonRel);
826       }
827    }
828
829
830
831    /**
832    * @Param: rule regola contenuta nel file delle regole
833    * istRule istanza della classe Rule
834    * Result: Inserisco la condizione all'interno della regola che
835    * sto esaminando
836    **/
837    private void setCondition(Element rule,Rule istRul){
838       Cve.errLog.debug("");
839       // prendo condizione
840 if (rule.getChild("Condition")!=null){
841          List cond=rule.getChild("Condition").getChildren();
842          Iterator itCond=cond.iterator();
843          while (itCond.hasNext()){
844             Element eleCond=(Element)itCond.next();
845             Element copiaCond=(Element)eleCond.clone();
846             istRul.addCondition(copiaCond);
847             //System.out.println(" La condizione viene copiata nella regola");
848 }
849       }
850    }
851
852    /**
853    * @Param: rule regola contenuta nel file delle regole
854    * istRule istanza della classe Rule
855    * nameRel nome della relazone coinvolta nella regola
856    * Result: Inserisco la relazione non orientata all'interno della regola che
857    * sto esaminando
858    **/
859    private void setRelationNonO (String nameRel,Element rule,Rule istRul) {
860       Cve.errLog.debug("");
861       List cons=rule.getChild("Conseguente").getChildren();
862       Iterator itCons=cons.iterator();
863       while (itCons.hasNext()){
864          Element ele=(Element)itCons.next();
865          String nameNon=(String )ele.getAttributeValue("name");
866          //l'elemento che sto analizzando non e' la relazione
867 if (!(nameNon.equals(nameRel))){
868             ElementNonRel eleNonRel=new ElementNonRel(ele,nameNon);
869             //metto l'elemento come source e target della regola
870 System.out.println(" Inserisco come source e come target della relazioneN "+nameNon);
871             istRul.addSource(eleNonRel);
872             istRul.addTarget(eleNonRel);
873          }
874       }
875    }
876
877    /**
878    * @Param: rule regola contenuta nel file delle regole
879    * istRule istanza della classe Rule
880    * relRule reference all'elemento relazione della regola
881    * Result: Inserisco la relazione orientata all'interno della regola che
882    * sto esaminando
883    **/
884    private void setRelationO (Element relRule,Element rule,Rule istRul) {
885       Cve.errLog.debug("");
886       ViewLog.writeInLog(" RELAZIONE ORIENTATA"+"\n");
887
888       //prendo l'id source della relazione
889 System.out.println(" RELAZIONE esaminata-->"+rule.toString());
890
891       //NOTA: Attualmente il Source e Target vengono gestiti come variabili di un elemento
892 String idSource=AnalizzaRegoleW.findValueAttriEle("source", relRule);
893
894       System.out.println(" rel orientata source cercato :"+idSource);
895       idSource=idSource.trim();
896       // cerco nell'antecedente l'elemento con id source
897 Element eleSource=AnalizzaRegoleW.findIdElementAnt(rule, idSource);
898       // prendo l'id target della relazione
899 String idTarget=AnalizzaRegoleW.findValueAttriEle("target", relRule);
900       idTarget=idTarget.trim();
901       System.out.println(" rel orientata target cercato "+idTarget);
902       // cerco nell'antecedente l'elemento con id voluto
903 Element eleTarget=AnalizzaRegoleW.findIdElementAnt(rule, idTarget);
904       if (eleSource!=null&&eleTarget!=null){
905          // metto come target di relAlf ripsetto a eleSoure eleTarget
906 String nameS=(String )eleSource.getAttributeValue("name");
907          System.out.println(" metto source "+nameS);
908          String nameT=(String )eleTarget.getAttributeValue("name");
909          System.out.println(" metto target "+nameT);
910          ViewLog.writeInLog(" Inserisco come source della relazioneO "+nameS+"\n");
911          ViewLog.writeInLog(" Inserisco come target della relazioneO "+nameT+"\n");
912          ElementNonRel eleNonRelS=new ElementNonRel(eleSource,nameS);
913          ElementNonRel eleNonRelT=new ElementNonRel(eleTarget,nameT);
914          istRul.addSource (eleNonRelS);
915          istRul.addTarget (eleNonRelT);
916       }
917    }
918 }
919
920
921

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags