EACBuild


1   /**
2    * @(#) EACBuild.java   
3    */
4   package cve.esecutori;
5   
6   import cve.esecutori.components.specificaLV.*;
7   import cve.esecutori.components.automatonB.*;
8   import cve.core.elementEEL.*;
9   import cve.esecutori.servizioEACBuild.*;
10  import cve.staticLayout.*;
11  
12  import java.awt.*;
13  import java.awt.event.*;
14  
15  import javax.swing.*;
16  import javax.swing.tree.*;
17  
18  import java.io.File  ;
19  import java.io.IOException  ;
20  import java.io.*;
21  import java.util.*;
22  
23  import org.jdom.*;
24  import org.jdom.input.SAXBuilder;
25  import org.jdom.output.XMLOutputter;
26  
27  import org.apache.log4j.Logger;
28  
29  /**
30   * Gestisce 4 sottomodelli corrispodenti ai file di specifica 
31   * (alfabeto, regole, auotma e sentenza). Ogni sottomodello e' gestito 
32   *  come un albero. I servizi che mette a diposizione consentono di:
33   *  a) dato un file alfabeto creare (cancellare) il modello albero 
34   *     corrispondente
35   *  b)dato un file regole creare (cancellare) il modello albero 
36   *      corrispondente
37   *  c) dato un alfabeto e un insieme di regole creare i modelli sentenza e automa.
38   *
39   *@version 1.0
40   *@author Domenico Ventriglia
41   */
42  public class EACBuild extends Esecutore implements SpecificationLanguage
43  {
44      static String   filereg,filealf,fileout;
45      private Document document;
46      private DefaultMutableTreeNode treeAlf,treeReg,treeSent,treeAut;
47      
48      /**
49       * Costruttore di default
50       */
51      public EACBuild(){
52         Cve.errLog.debug("");
53      }
54      
55      /**
56       * Restituisce il modello albero alfabeto
57       */
58      public DefaultMutableTreeNode getModelAlf(){
59         Cve.errLog.debug("");
60         return treeAlf;
61      }
62      
63      
64      /**
65       * Restituisce il modello albero regole
66       */
67      public DefaultMutableTreeNode getModelReg(){
68          Cve.errLog.debug("");
69          return treeReg;
70      }
71      
72      /**
73       * Restituisce il modello albero automa
74       */
75      public DefaultMutableTreeNode getModelAut(){
76            Cve.errLog.debug("");
77          return treeAut;
78      }
79      
80      /**
81       * Restituisce il modello albero sentenza
82       */
83      public DefaultMutableTreeNode getModelSent(){
84         Cve.errLog.debug("");
85         return treeSent;
86      }
87      
88      /**
89       * Creazione del modello tree associato al file alfabeto. 
90       * Vengono informati agli osservatori collegati
91       */
92      public void setAlphabet(String   file){
93          Cve.errLog.debug("");
94          // creo modello tree corrispondente al file 
95          treeAlf=setFile(file,"ALPHABET");
96          //Comunico a tutti gli osservatori collegati l'alfabeto
97          SpecificationEvent speEv=new SpecificationEvent();
98          speEv.setActionUser("setAlphabet");
99          speEv.setModelTree(treeAlf);
100         ObservableCve ob=getObservable();
101         ob.setDate(speEv);  
102     }
103     
104     /**
105      * Creazione del  modello tree associato al file regole
106      * Vengono informati agli osservatori collegati
107      */
108     public void setRules(String   file){
109           Cve.errLog.debug("");
110         // creo modello tree corrispondente al file 
111         treeReg=setFile(file,"RULES");
112         //Comunico a tutti gli osservatori collegati le regole
113         SpecificationEvent speEv=new SpecificationEvent();
114         speEv.setActionUser("setRules");
115         speEv.setModelTree(treeReg);
116         ObservableCve ob=getObservable();
117         ob.setDate(speEv);  
118     }
119     
120     /**
121      * Creazione del modello tree associato al file automa 
122      * Vengono informati agli osservatori collegati
123      */
124     public void setAutoma(String   file){
125           Cve.errLog.debug("");
126         // creo modello tree corrispondente al file 
127         treeAut=setFile(file,"AUTOMATA");
128         //Comunico a tutti gli osservatori collegati l'alfabeto
129         SpecificationEvent speEv=new SpecificationEvent();
130         speEv.setActionUser("setAutoma");
131         speEv.setModelTree(treeAut);
132         ObservableCve ob=getObservable();
133         ob.setDate(speEv);  
134     }
135     
136     /**
137      * Creazione del modello tree associato al file sentenza
138      * Vengono informati gli osservatori collegati
139      */
140     public void setSentenza(String   file){
141           Cve.errLog.debug("");
142         // creo modello tree corrispondente al file 
143         treeSent=setFile(file,"SENTENCE");
144         //Comunico a tutti gli osservatori collegati l'alfabeto
145         SpecificationEvent speEv=new SpecificationEvent();
146         speEv.setActionUser("setSentenza");
147         speEv.setModelTree(treeSent);
148         ObservableCve ob=getObservable();
149         ob.setDate(speEv);  
150     }
151     
152     /**
153      * Cancellazione del modello tree associato al file alfabeto
154      * Vengono informati gli osservatori collegati
155      */
156     public void delAlphabet(){
157           Cve.errLog.debug("");
158         SpecificationEvent speEv=new SpecificationEvent();
159         speEv.setActionUser("delAlphabet");
160         speEv.setModelTree(null);
161         ObservableCve ob=getObservable();
162         ob.setDate(speEv);  
163     }
164     
165     /**
166      * Cancellazione del modello tree associato al file regole
167      * Vengono informati gli osservatori collegati
168      */
169     public void delRules(){
170           Cve.errLog.debug("");
171         SpecificationEvent speEv=new SpecificationEvent();
172         speEv.setActionUser("delRules");
173         speEv.setModelTree(null);
174         ObservableCve ob=getObservable();
175         ob.setDate(speEv);  
176     }
177     
178     /**
179      *  Creazione del file sentenza e del file automa 
180      *  Result: creo la specifica relativa all'automa e alla sentenza
181      */
182     public void makeLanguage(String   fileA, String   fileR){
183           Cve.errLog.debug("");
184         try {
185             Specifica spe=new Specifica(fileR,fileA);
186             // creazione specifica sentenza
187             GenerationSentence gs=new GenerationSentence(spe);
188             // creazione file sentenza, fileLang e' file del linguaggio
189             File   fileLang=gs.createGS();
190             // creo modello tree associato alla sentenza appena creato
191             // ricavo nove file sent
192             String   nameFileLanguage=fileLang.getName();
193             String   filePath=fileLang.getParent();           
194             String   fileS=filePath+"/"+"Sent_"+nameFileLanguage;
195             treeSent=setFile(fileS,"SENTENCE");
196             SpecificationEvent speEv1=new SpecificationEvent();
197             // invio il modello sentenza a tutti gli osseratori 
198             speEv1.setActionUser("setSentenza");
199             speEv1.setModelTree(treeSent);
200             ObservableCve ob=getObservable();
201             ob.setDate(speEv1);  
202             // creazione specifica automa
203             AutControlB msf=new AutControlB();
204             String   fileAut=msf.createCA(fileA,fileLang,spe);
205             // creo modello tree associato all'automa appena creato
206             treeAut=setFile(fileAut,"AUTOMATA");
207             // invio il modello sentenza a tutti gli osseratori
208             SpecificationEvent speEv=new SpecificationEvent();
209             speEv.setActionUser("setAutoma");
210             speEv.setModelTree(treeAut);
211             //ObservableCve ob=getObservable();
212             ob.setDate(speEv);  
213             }catch(IOException   e){
214                 Cve.errLog.error(e.toString());
215               //siamo all'8 agosto e il file non si apre
216             }   
217         }
218     
219     /* ###################   METODI PRIVATI ########################  */
220     
221     /**
222      * Viene preso un file xml, viene trasformato in un documento XML
223      *         e viene calcola l'albero relativo
224      * Result: albero relativo al file analizzato
225      *@param fileLetto
226      *@param nameRoot
227      */
228     private DefaultMutableTreeNode setFile(String   fileLetto,String   nameRoot){ 
229           Cve.errLog.debug("");
230         DefaultMutableTreeNode p1=new DefaultMutableTreeNode (nameRoot);
231         try {
232             // vanno messi i controlli di correttezza
233             SAXBuilder builder = new SAXBuilder(false);
234             document = builder.build(new File  (fileLetto)); 
235             } catch (JDOMException e) {
236                if (e.getRootCause() != null) {
237                    Cve.errLog.error(e.toString());
238                }
239             } catch (Exception   e) {
240                  Cve.errLog.error(e.toString());
241             }
242         Element root=document.getRootElement();
243         addNodes(p1,root);
244         return p1;
245     }
246     
247     /**
248      * Viene aggiunto un nodo all'abero
249      * @param pnode
250      * @param ele
251      */
252     private void addNodes (DefaultMutableTreeNode pnode,Element ele){
253           Cve.errLog.debug("");
254         DefaultMutableTreeNode node;
255         if ((ele!=null)&&(pnode!=null)) {
256             java.util.List   figli=ele.getChildren();
257             Iterator it=figli.iterator();
258             if (it!=null){
259                 while (it.hasNext()){
260                     Element newEle=(Element)it.next();
261                     //String nome=new String(newEle.toString());
262                     String   nome=createString(newEle);
263                     node= new DefaultMutableTreeNode(nome);
264                     pnode.add(node);
265                     addNodes(node,newEle);
266                 }   
267             }
268         }
269     }       
270     
271      
272     /**
273      * Viene effettuato il toString dell'elemento XML
274      * @param ele
275      */
276     private String   createString(Element ele){
277           Cve.errLog.debug("");
278         String   app=new String  ();
279         app=ele.getName();
280         java.util.List   attrList=((Element)ele).getAttributes();
281         for (int i=0;i<attrList.size();i++){
282             String   name=((Attribute)attrList.get(i)).getName();
283             String   value=((Attribute)attrList.get(i)).getValue();
284             app=app+" "+name+"="+value;
285             }
286         return app;
287     }
288 }
289 
290 
291
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags