Java > Open Source Codes > cve > esecutori > EACBuildSemantic


1 /**
2  * @(#) EACBuildSemantic.java
3  */
4
5 package cve.esecutori;
6
7 import cve.esecutori.servizioEACBuildSemantic.*;
8
9 import cve.core.elementEEL.*;
10 import cve.staticLayout.*;
11 import cve.util.*;
12
13 import java.awt.*;
14 import java.awt.event.*;
15
16 import javax.swing.*;
17 import javax.swing.tree.*;
18
19 import java.io.File ;
20 import java.io.IOException ;
21 import java.io.*;
22 import java.util.*;
23
24 import org.jdom.*;
25 import org.jdom.Document;
26 import org.jdom.Element;
27 import org.jdom.JDOMException;
28 import org.jdom.input.SAXBuilder;
29 import org.jdom.output.XMLOutputter;
30
31
32 /**
33  * Gestisce 4 sottomodelli corrispodenti ai file di specifica
34  * (Regole Sintattiche, Regole Semantiche, Associazione Regole, File di Associazione).
35  * Ogni sottomodello e' gestito come un albero.
36  * I servizi che mette a diposizione consentono di:
37  * a) dato un file Regole Sintattiche creare (cancellare) il modello albero
38  * corrispondente
39  * b) dato un file Regole Semantiche creare (cancellare) il modello albero
40  * corrispondente
41  * c) date le Regole Sintattiche e Semantiche creare il modelli di
42  * Associazione Sintassi-Semantica e Associazione File.
43  *
44  *@version 1.0
45  *@author Francesco Guerrisi
46  */
47 public class EACBuildSemantic extends Esecutore implements SpecificationSemantic
48 {
49     
50     //Riferimenti ai File utilizzati
51 static String fileSem, fileSint, fileAss, fileAssFile;
52     
53     //Alberi riferiti ai file
54 private Document document;
55     private DefaultMutableTreeNode treeSinRules,treeSemRules;
56     private DefaultMutableTreeNode treeSpeSem,treeAssSem, treeFileAssFile;
57     
58     //id regole selezionate da associare
59 private String idRegolaSint, idRegolaSem;
60     private String translationClass;
61     
62     /**
63      * Costruttore di default
64      */
65     public EACBuildSemantic(){
66         translationClass = new String ("");
67     }
68     
69     /**
70      * Restituisce il modello albero Regole Sintattiche
71      * @return DefaultMutableTreeNode Root Albero Sintattico
72      */
73     public DefaultMutableTreeNode getModelSintRules(){
74         return treeSinRules;
75     }
76     
77     
78     /**
79      * Restituisce il modello albero Regole Semantiche
80      * @return DefaultMutableTreeNode Root Albero Semantico
81      */
82     public DefaultMutableTreeNode getModelSemRules(){
83         return treeSemRules;
84     }
85     
86     /**
87      * Restituisce il modello albero Associazione Regole Sintattiche <->Semantiche
88      * @return DefaultMutableTreeNode Root Albero Associazione Sint - Sem
89      */
90     public DefaultMutableTreeNode getModelAssSem(){
91         return treeAssSem;
92     }
93
94     /* ################### METODI INTERFACCIA ######################## */
95
96     /**
97      * Creazione del modello tree associato al file Regole Sintattiche.
98      * Vengono informati agli osservatori collegati
99      *
100      * @param file path del file XML Regole Sintattiche
101      */
102     public void setSintaxRules(String file){
103         ViewLog.writeInLog(" #E Eseguito setSintaxRules: "+file+"\n");
104     
105         this.fileSint = file;
106         
107         // creo modello tree corrispondente al file
108 treeSinRules=setFile(fileSint,"SINTAX RULES");
109         //Comunico a tutti gli osservatori collegati l'alfabeto
110 setModel(treeSinRules,"setSintaxRules",fileSint);
111     }
112
113     /**
114      * Cancellazione del modello tree associato al file Regole Sintattiche
115      * Vengono informati gli osservatori collegati
116      */
117     public void delSintaxRules(){
118         ViewLog.writeInLog(" #E Eseguito delSintaxRules: "+"\n");
119     
120         this.fileSint = null;
121         setModel(null,"delSintaxRules",null);
122     }
123
124     /**
125      * Creazione del modello tree associato al file Regole Semantiche
126      * Vengono informati agli osservatori collegati
127      *
128      * @param file path del file XML Regole Semantiche
129      */
130     public void setSemanticRules(String file){
131         ViewLog.writeInLog(" #E Eseguito setSemanticRules: "+file+"\n");
132     
133         
134           //Riferimento File
135 this.fileSem = file;
136            
137         // creo modello tree corrispondente al file
138 treeSemRules=setFile(fileSem,"SEMANTIC RULES");
139         //Comunico a tutti gli osservatori collegati le regole
140 setModel(treeSemRules,"setSemanticRules",fileSem);
141     }
142
143
144     /**
145      * Cancellazione del modello tree associato al file Regole semantiche
146      * Vengono informati gli osservatori collegati
147      */
148     public void delSemanticRules(){
149         ViewLog.writeInLog(" #E Eseguito delSemanticRules: "+"\n");
150     
151           this.fileSem = null;
152         setModel(null,"delSemanticRules",null);
153     }
154
155     /**
156      * Creazione albero Regole Semantiche nel caso in cui non
157      * venga precaricato dall'utente
158      * Vengono informati gli osservatori collegati
159      *
160      * @param file path del file XML Regole Semantiche
161      */
162     public void newSemanticTree(String file){
163
164         ViewLog.writeInLog(" #E Eseguito newSemanticTree: "+file+"\n");
165         
166         //Riferimento File
167 this.fileSem = file;
168         
169         String newStringFile = new String ();
170         newStringFile = createStringFile();
171         
172         //Salvataggio su File
173 try{
174            FileOutputStream fileoutputstream = new FileOutputStream(fileSem);
175            PrintStream printstream = new PrintStream(fileoutputstream);
176            printstream.println(newStringFile);
177            printstream.close();
178          }catch(IOException e){
179             System.out.println("#E Errore in creazione file Regole Semantiche");
180          }
181         
182         // Creazione Albero Iniziale
183 treeSemRules=setFile(fileSem,"SEMANTIC RULES");
184
185         //Comunico a tutti gli osservatori collegati le regole
186 setModel(treeSemRules,"setSemanticRules",fileSem);
187         
188     }
189
190     /**
191      * Creazione struttura file di Associazione Regole
192      * Sintattiche <-> Semantiche
193      * Vengono informati gli osservatori collegati
194      *
195      * @param fileRegAss path del file XML Associazione REgole
196      */
197     public void newAssociationTree(String fileRegAss, String fileAssF){
198
199         ViewLog.writeInLog(" #E Eseguito newAssociationTree: "+fileRegAss+"\n");
200
201         //Riferimento File
202 this.fileAss = fileRegAss;
203         
204         String newStringFileAss = new String ();
205         newStringFileAss = createStringFileAss();
206         
207         //Salvataggio su File
208 try{
209            FileOutputStream fileoutputstream = new FileOutputStream(fileAss);
210            PrintStream printstream = new PrintStream(fileoutputstream);
211            printstream.println(newStringFileAss);
212            printstream.close();
213          }catch(IOException e){
214             System.out.println("#E Errore in creazione file Associazione Regole Semantiche");
215          }
216         
217         //---Creazione file di Associazione File Regole
218
219         //Costruzione Path
220 /*
221         File fileAppo= new File(fileAss);
222         String nameFileAppo=fileAppo.getName();
223         String filePath=fileAppo.getParent();
224         
225         this.fileAssFile=filePath+"\\"+"AssFileSem_"+nameFileAppo;
226         */
227         this.fileAssFile=fileAssF;
228         
229         //Costruzione File
230 this.translationClass = "";
231         String newStringFileAssFile = new String ();
232         newStringFileAssFile = createStringFileAssFile(fileAssFile, fileSint, fileSem, fileAss);
233         
234         //Salvataggio File
235 try{
236            FileOutputStream fileoutputstream2 = new FileOutputStream(fileAssFile);
237            PrintStream printstream2 = new PrintStream(fileoutputstream2);
238            printstream2.println(newStringFileAssFile);
239            printstream2.close();
240         }catch(IOException e){
241           System.out.println("E# Errore in creazione file Associazione File Regole Sintattiche-Semantiche");
242         }
243         
244         //Comunicazione Albero di Associazione Semantico
245 // Creazione Albero Iniziale
246 treeAssSem=setFile(fileAss,"ASSOCIATION TREE");
247
248         //Comunico a tutti gli osservatori collegati le regole
249 setModel(treeAssSem,"setAssociationSemantic",fileAss);
250         
251         //Comunicazione Albero di Associazione File
252 // Creazione Albero Iniziale
253 treeFileAssFile=setFile(fileAssFile,"ASSOCIATION FILE TREE");
254
255         //Comunico a tutti gli osservatori collegati le regole
256 setModel(treeFileAssFile,"setAssociationFile",fileAssFile);
257         
258
259     }
260
261     /**
262      * Associazione Regola Sintattica <-> Semantica
263      * in file di associazione
264      * Vengono informati gli osservatori collegati
265      *
266      * @param idRuleSint Identificativo regola(Transizione) Sintattica
267      * @param idRuleSem Identificativo regola(Transizione) Semantica
268      */
269     public void assSemSint(String idRuleSint, String idRuleSem){
270
271       ViewLog.writeInLog(" #E Eseguito assSemSint: Regola Sint: "+idRuleSint+" Regola Sem: "+idRuleSem+"\n");
272         
273         
274         //Ad ogni associazione Creo la Specifica di Semantica
275 //Accodando l'associazione appena effettuata
276 try{
277          
278          //Creazione Documenti & Root
279 AssociationSem ass=new AssociationSem(fileSint,fileSem, fileAss);
280          
281          //Creazione Associazione
282 ass.setAssociation(idRuleSint, idRuleSem);
283          
284          }catch(IOException e){
285             System.out.println("#E Errore nella creazione dell'associazione Regole! " + e);
286       }
287
288
289       // Creazione Albero Iniziale
290 treeAssSem=setFile(fileAss,"ASSOCIATION TREE");
291
292       //Comunico a tutti gli osservatori collegati le regole
293 setModel(treeAssSem,"setAssociationSemantic",fileAss);
294     }
295
296     /**
297      * Cancellazione del modello Associazione Regole
298      * Vengono informati gli osservatori collegati
299      */
300     public void delAssRules(){
301         
302         ViewLog.writeInLog(" #E Eseguito delAssRules" + "\n");
303     
304           this.fileAss = null;
305         setModel(null,"delAssRules",null);
306     }
307
308
309     /**
310      * Creazione Ambiente partendo da file di collegamento
311      * Sintassi - Semantica - Associazione
312      * Vengono informati gli osservatori collegati
313      *
314      * @param pathfileAssFile File di Associazione tra file Sint-Sem-Ass
315      */
316     public void getAll(String pathfileAssFile){
317
318         ViewLog.writeInLog(" #E Eseguito getAll da file: " + pathfileAssFile + "\n");
319         
320         this.fileAssFile = pathfileAssFile;
321         
322         //Creo nuovo oggetto di ricerca
323 ElementXML objSearch = new ElementXML(fileAssFile);
324         
325         //Prelevo file Sintattico
326 this.fileSint = objSearch.getParameter(objSearch.getRootDocument(),"SyntaxFile","nameFile",null,null);
327         this.fileSint = ConfigurationRead.getCveRoot() + ConfigurationRead.getCveWSpeRoot() + "\\" + this.fileSint;
328         
329        
330         //Prelevo File Semantico
331 this.fileSem = objSearch.getParameter(objSearch.getRootDocument(),"SemanticFile","nameFile",null,null);
332         this.fileSem = ConfigurationRead.getCveRoot() + ConfigurationRead.getCveWSpeRoot() + "\\" + this.fileSem;
333
334         
335         //Prelevo file Associazione Regole
336 this.fileAss = objSearch.getParameter(objSearch.getRootDocument(),"AssociationFile","nameFile",null,null);
337         this.fileAss = ConfigurationRead.getCveRoot() + ConfigurationRead.getCveWSpeRoot() + "\\" + this.fileAss;
338
339         //Prelevo classe di Traduzione Semantica
340 this.translationClass = objSearch.getParameter(objSearch.getRootDocument(),"TranslationSemanticClass","nameFile",null,null);
341         //this.fileAss = ConfigurationRead.getCveRoot() + ConfigurationRead.getCveWSpeRoot() + "\\" + this.fileAss;
342
343         
344         // Creazione Alberi
345 treeSinRules = setFile(fileSint,"SINTAX RULES");
346         treeSemRules = setFile(fileSem,"SEMANTIC RULES");
347         treeAssSem = setFile(fileAss,"ASSOCIATION TREE");
348         treeFileAssFile = setFile(fileAssFile,"ASSOCIATION FILE TREE");
349
350
351         //Comunico cambiamenti agli osservatori
352 setModel(treeSinRules,"setSintaxRules",fileSint);
353         setModel(treeSemRules,"setSemanticRules",fileSem);
354         setModel(treeAssSem,"setAssociationSemantic",fileAss);
355         setModel(treeFileAssFile,"setAssociationFile",fileAssFile);
356
357     }
358
359
360     /**
361      * Cancellazione di tutti i modelli presenti
362      * Vengono informati gli osservatori collegati
363      */
364     public void delAll(){
365
366         ViewLog.writeInLog(" #E Eseguito delAll" + "\n");
367           
368         this.fileSint = null;
369         this.fileAss = null;
370           this.fileSem = null;
371         this.fileAssFile = null;
372           this.translationClass = "";
373         setModel(null,"delSintaxRules",null);
374         setModel(null,"delSemanticRules",null);
375         setModel(null,"delAssRules",null);
376         
377     }
378
379     /**
380      * Impostazione Tipo traduzione Semantica
381      *
382      * @param typeS Tipo traduzione semantica
383      */
384     public void setTranslationSemantic(String typeS){
385           translationClass = typeS;
386         ViewLog.writeInLog(" #E Eseguita Impostazione Tipo Traduzione Semantica: "+translationClass+"\n");
387         System.out.println(" #E Eseguita Impostazione Tipo Traduzione Semantica: "+translationClass);
388         
389         //Modifica del file di Ambiente
390 changeAttributeAss("TranslationSemanticClass", translationClass);
391         
392         //Aggiornamento Albero
393 treeFileAssFile = setFile(fileAssFile,"ASSOCIATION FILE TREE");
394
395         //Comunico cambiamenti agli osservatori
396 setModel(treeFileAssFile,"setAssociationFile",fileAssFile);
397     }
398
399
400     /**
401      * Lettura Tipo traduzione Semantica
402      *
403      * @return typeS Tipo traduzione semantica
404      */
405     public String getTranslationSemantic(){
406          ViewLog.writeInLog(" #E Eseguita Lettura Tipo Traduzione Semantica: "+translationClass+"\n");
407          System.out.println(" #E Eseguita Lettura Tipo Traduzione Semantica: "+translationClass);
408        return translationClass;
409     }
410
411     
412     /* ################### METODI PRIVATI ######################## */
413
414     /* #######CREAZIONE FILE ############## */
415
416     /**
417      * Comunicazione con Osservatore per Aggiornamento Modello\Azione
418      */
419     private void setModel(DefaultMutableTreeNode treeModel, String Action, String pathFile){
420         SpecificationEventSem speEv=new SpecificationEventSem();
421         speEv.setActionUser(Action);
422         speEv.setModelTree(treeModel);
423         speEv.setFileTree(pathFile);
424         ObservableCve ob=getObservable();
425         ob.setDate(speEv);
426     }
427
428     /**
429      * Creazione Nuovo Albero Semantico
430      *
431      * @param nameRoot Nome del Root visualizzato
432      * @return DefaultMutableTreeNode Nodo root dell'albero
433      */
434     private DefaultMutableTreeNode setFileNew(String nameRoot){
435         DefaultMutableTreeNode p1=new DefaultMutableTreeNode (nameRoot);
436         return p1;
437     }
438
439     /**
440      * Viene preso un file xml, trasformato in un documento XML
441      * e viene calcolato l'albero relativo
442      *
443      * @param fileLetto File XML relativo all'albero
444      * @param nameRoot Nome del Root visualizzato
445      * @return DefaultMutableTreeNode Albero costruito in base al file
446      */
447     private DefaultMutableTreeNode setFile(String fileLetto,String nameRoot)
448       {
449         DefaultMutableTreeNode p1=new DefaultMutableTreeNode (nameRoot);
450         
451         try {
452             // vanno messi i controlli di correttezza
453 SAXBuilder builder = new SAXBuilder(false);
454             document = builder.build(new File (fileLetto));
455             } catch (JDOMException e) {
456             if (e.getRootCause() != null) {
457                 e.getRootCause().printStackTrace();
458                 }
459             e.printStackTrace();
460             } catch (Exception e) {
461             e.printStackTrace();
462         }
463         Element root=document.getRootElement();
464         addNodes(p1,root);
465         return p1;
466     }
467     
468     
469     /**
470      * Viene aggiunto un nodo all'abero all'elemento XML
471      *
472      * @param pnode nodo padre a cui aggiungere il nodo
473      * @param ele Elemento XML da aggiungere
474      */
475     private void addNodes (DefaultMutableTreeNode pnode,Element ele){
476         DefaultMutableTreeNode node;
477         if ((ele!=null)&&(pnode!=null)) {
478             java.util.List figli=ele.getChildren();
479             Iterator it=figli.iterator();
480             if (it!=null){
481                 while (it.hasNext()){
482                     Element newEle=(Element)it.next();
483                     String nome=createString(newEle);
484                     node= new DefaultMutableTreeNode(nome);
485                     pnode.add(node);
486                     addNodes(node,newEle);
487                 }
488             }
489         }
490     }
491
492
493
494     /**
495      * Creazione di un Nuovo albero di Associazione Regole Semantiche
496      * e viene calcola l'albero relativo
497      *
498      * @param nameRoot Nome del Root Albero Associazione Regole
499      * @return DefaultMutableTreeNode Nodo root dell'albero di Associazione
500      */
501     private DefaultMutableTreeNode newAssTree(String nameRoot){
502         DefaultMutableTreeNode proot=new DefaultMutableTreeNode (nameRoot);
503         return proot;
504     }
505     
506      
507     /**
508      * Viene effettuato il toString dell'elemento XML
509      *
510      * @param ele Elemento XML da convertire in Stringa per la visualizzazione nell'albero
511      * @return String Conversione in Stringa dell'elemento XML
512      */
513     private String createString(Element ele){
514         String app=new String ();
515         app=ele.getName();
516         java.util.List attrList=((Element)ele).getAttributes();
517         for (int i=0;i<attrList.size();i++){
518             String name=((Attribute)attrList.get(i)).getName();
519             String value=((Attribute)attrList.get(i)).getValue();
520             app=app+" "+name+"="+value;
521             }
522         return app;
523     }
524
525
526     /**
527      * Creazione struttura file XML per le regole Semantiche
528      * (Regole WIPPOG)
529      *
530      * @return String File XML in versione stringa
531      */
532     private String createStringFile(){
533
534         //Creazione Intestazione File Vuoto di regole Semantiche
535 String app = new String ();
536         
537         app = "";
538         app = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
539         app = app + "<WippogRules>";
540         app = app + "<Defines description=\"Definizione dei tipi utilizzati\">";
541         app = app + "</Defines>";
542         app = app + "<Imports>";
543         app = app + "<Item typeName=\"activity\"/>";
544         app = app + "<Item typeName=\"listaSel\"/>";
545         app = app + "</Imports>";
546         app = app + "<Exports>";
547         app = app + "<Item typeName=\"conditionRule\"/>";
548         app = app + "</Exports>";
549         app = app + "</WippogRules>";
550
551         return app;
552     }
553
554
555
556     /**
557      * Creazione struttura file XML per le Associazioni
558      * Regole Sintattiche-Semantiche
559      *
560      * @return String File XML in versione stringa
561      */
562     private String createStringFileAss(){
563
564         //Creazione Intestazione File Vuoto di regole Semantiche
565 String app = new String ();
566         
567         app = "";
568         app = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
569         app = app + "<WippogAssRules>";
570         app = app + "</WippogAssRules>";
571
572         return app;
573     }
574
575     /**
576      * Viene creato il file XML per mantenere il legame tra i vari file
577      * di Regole Sintattiche, Semantiche e Associazione Regole
578      *
579      * @param SyntaxFile Path del File XML di Regole Sintattiche
580      * @param SemanticFile Path del File XML di Regole Semantiche
581      * @param AssFile Path del File XML di Associazione regole Sintattiche - Semantiche
582      * @return String File XML in versione stringa
583      */
584     private String createStringFileAssFile(String fileAssociationFile, String SyntaxFile, String SemanticFile, String AssFile){
585         
586         String nameFileAss, nameFileSin, nameFileControl, nameFileSem, nameFileAssRule;
587        
588         //Prelevamento dei soli nomi dei file
589 //Associazione File
590 File fileAppoAss= new File (fileAssociationFile);
591         nameFileAss=fileAppoAss.getName();
592         
593         //Sintattico (Sentenza) + Automa di Controllo
594 File fileAppoSin= new File (SyntaxFile);
595         nameFileSin=fileAppoSin.getName();
596         
597         nameFileControl=nameFileSin.substring(5);
598         
599         //Semantico
600 //Sintattico (Sentenza) + Automa di Controllo
601 File fileAppoSem= new File (SemanticFile);
602         nameFileSem=fileAppoSem.getName();
603         
604         //Ass Rules
605 File fileAppoAssRule= new File (AssFile);
606         nameFileAssRule=fileAppoAssRule.getName();
607         
608         //Creazione Repository interazione file
609 String app = new String ();
610         
611         app = "";
612         app = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"+"\r\n" ;
613         app = app + "<WippogFileAssRules>" +"\r\n";
614         app = app + "\t<InfoFile description=\"Informazioni file di Associazione\" >" +"\r\n";
615         app = app + "\t\t<FilePath nameFile=\"" + nameFileAss + "\" />" +"\r\n";
616         app = app + "\t</InfoFile>" +"\r\n";
617         app = app + "\t<WippogFileAss>" +"\r\n";
618         app = app + "\t\t<ControlFile nameFile=\"" + nameFileControl + "\" />" +"\r\n";
619         app = app + "\t\t<SyntaxFile nameFile=\"" + nameFileSin + "\" />" +"\r\n";
620         app = app + "\t\t<SemanticFile nameFile=\"" + nameFileSem + "\" />"+"\r\n";
621         app = app + "\t\t<AssociationFile nameFile=\"" + nameFileAssRule + "\" />"+"\r\n";
622         app = app + "\t\t<TranslationSemanticClass nameFile=\"" + translationClass + "\" />"+"\r\n";
623         app = app + "\t</WippogFileAss>" +"\r\n";
624         app = app + "</WippogFileAssRules>"+"\r\n";
625
626         return app;
627     }
628
629
630    /**
631    * Metodo di Supporto per il cambio di un attributo di associazione
632    *
633    * @param name Nome attributo da cambiare
634    * @param value Valore attributo da cambiare
635    *
636    */
637   private void changeAttributeAss(String name, String value){
638     
639       Element rootEnv;
640       Document docEnv = null;
641       
642       //Creazione del Document XML
643 try {
644          // vanno messi i controlli di correttezza
645 SAXBuilder builder = new SAXBuilder(false);
646          docEnv = builder.build(new File (fileAssFile));
647          //System.out.println(" Costruttore : costruiti i due doc (dom)");
648 } catch (JDOMException e) {
649          if (e.getRootCause() != null) {
650             e.getRootCause().printStackTrace();
651             }
652          e.printStackTrace();
653          } catch (Exception e) {
654          e.printStackTrace();
655          }
656       
657       //Prelevamento Root
658 rootEnv = docEnv.getRootElement();
659       
660       
661       //Ricerca Elemento in WippogFileAss
662 java.util.List figliWFAR = rootEnv.getChildren("WippogFileAss");
663         Iterator itFigliWFAR = figliWFAR.iterator();
664         
665         
666         //Prendo l'unico figlio che mi interessa
667 Element appoFigli = (Element)itFigliWFAR.next();
668         java.util.List figliWFA = appoFigli.getChildren(name);
669         Iterator itFigliWFA = figliWFA.iterator();
670         
671         Element nodo = (Element)itFigliWFA.next();
672         
673         //Rimozione Nodo
674 appoFigli.removeContent(nodo);
675         
676         //Creazione Nuovo Nodo
677 Element newNode = new Element(name);
678       java.util.List attList = newNode.getAttributes();
679       
680       Attribute att = new Attribute("nameFile",value);
681       attList.add(att);
682       newNode.setAttributes(attList);
683         
684         //Aggiungo di nuovo il nodo
685 appoFigli.addContent(newNode);
686         
687     //Salvataggio file
688 writeFileXML(fileAssFile, rootEnv);
689         
690     }
691
692
693    /**
694    * Metodo di Supporto per la scrittura di qualsiasi file XML
695    *
696    * @param path Del file in cui Scrivere il DOC XML
697    * @param root Root element del File XML da scrivere
698    *
699    */
700   private static void writeFileXML(String path, Element root){
701       File fileS = new File (path);
702          try{
703               fileS.createNewFile();
704             FileWriter outS= new FileWriter (fileS);
705             XMLOutputter fmtS = new XMLOutputter(" ",true);
706             
707            
708             String appS=fmtS.outputString(root);
709             outS.write(appS);
710             outS.close();
711             }catch( IOException e){
712             System.out.println(" CVESemanticFactory.writeFileXML: Problema in scrittura file XML!!!"+"\r\n");
713             }
714   }
715
716
717
718     
719 }

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags