ZeusParser xref

View Javadoc

1   /*
2   * The contents of this file are subject to the BT "ZEUS" Open Source 
3   * Licence (L77741), Version 1.0 (the "Licence"); you may not use this file 
4   * except in compliance with the Licence. You may obtain a copy of the Licence
5   * from $ZEUS_INSTALL/licence.html or alternatively from
6   * http://www.labs.bt.com/projects/agents/zeus/licence.htm
7   * 
8   * Except as stated in Clause 7 of the Licence, software distributed under the
9   * Licence is distributed WITHOUT WARRANTY OF ANY KIND, either express or 
10  * implied. See the Licence for the specific language governing rights and 
11  * limitations under the Licence.
12  * 
13  * The Original Code is within the package zeus.*.
14  * The Initial Developer of the Original Code is British Telecommunications
15  * public limited company, whose registered office is at 81 Newgate Street, 
16  * London, EC1A 7AJ, England. Portions created by British Telecommunications 
17  * public limited company are Copyright 1996-2002. All Rights Reserved.
18  * 
19  * THIS NOTICE MUST BE INCLUDED ON ANY COPY OF THIS FILE
20  */
21  
22  
23  
24  package zeus.concepts;
25  
26  import java.io.*;
27  import java.util.*;
28  import zeus.util.*;
29  import zeus.concepts.fn.*;
30  import zeus.generator.*;
31  import zeus.generator.code.*;
32  import zeus.rete.*;
33  
34  public class ZeusParser {
35     public static final AbilityDbItem abilityDbItem(
36        OntologyDb db, String str) {
37        try {
38           Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
39           return parser.abilityDbItem(db);
40        }
41        catch(Exception e) {
42           Core.ERROR(null,1,"Error parsing " + str);
43           return null;
44        }
45     }
46  
47  
48     public static final Vector abilityDbItemList(OntologyDb db, String str) {
49       try {
50           Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
51           return parser.abilityDbItemList(db);
52        }
53        catch(Exception e) {
54           e.printStackTrace(); 
55           Core.ERROR(null,2,"Error parsing " + str);
56           return null;
57        }
58     }
59  
60  
61     public static final Vector abilitySpecList(OntologyDb db, String str) {
62       try {
63           Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
64           return parser.abilitySpecList(db);
65        }
66        catch(Exception e) {
67            e.printStackTrace(); 
68           Core.ERROR(null,3,"Error parsing " + str);
69           return null;
70        }
71     }
72  
73     public static final AbilitySpec abilitySpec(OntologyDb db, String str) {
74         try {
75           Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
76           return parser.abilitySpec(db);
77        }
78        catch(Exception e) {
79            e.printStackTrace(); 
80           Core.ERROR(null,4,"Error parsing " + str);
81           return null;
82        }
83     }
84     public static final Acquaintance acquaintance(OntologyDb db, String str) {
85        try {
86           Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
87           return parser.acquaintance(db);
88        }
89        catch(Exception e) {
90           Core.ERROR(null,5,"Error parsing " + str);
91           return null;
92        }
93  
94     }
95     public static final Address address(String str) {
96       try {
97           Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
98           return parser.address();
99        }
100       catch(Exception e) {
101          Core.ERROR(null,6,"Error parsing " + str);
102          return null;
103       }
104    }
105    public static final Vector addressList(String str) {
106      try {
107          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
108          return parser.addressList();
109       }
110       catch(Exception e) {
111           e.printStackTrace(); 
112          Core.ERROR(null,7,"Error parsing " + str);
113          return null;
114       }
115    }
116    public static final Vector addressList(InputStream stream) {
117      try {
118          Parser parser = new Parser(stream);
119          return parser.addressList();
120       }
121       catch(Exception e) {
122          Core.ERROR(null,61,"Error parsing " + stream);
123          e.printStackTrace();
124          return null;
125       }
126    }
127 
128    public static final AgentDescription agentDescription(OntologyDb db, String str) {
129      try {
130          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
131          return parser.agentDescription(db);
132       }
133       catch(Exception e) {
134          Core.ERROR(null,8,"Error parsing " + str);
135          return null;
136       }
137 
138    }
139    public static final ConsumerRecord consumerRecord(String str) {
140       try {
141          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
142          return parser.consumerRecord();
143       }
144       catch(Exception e) {
145          Core.ERROR(null,10,"Error parsing " + str);
146          return null;
147       }
148 
149    }
150    public static final Fact fact(OntologyDb db, String str) {
151      try {
152          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
153          return parser.fact(db);
154       }
155       catch(Exception e) {
156          Core.ERROR(null,11,"Error parsing " + str);
157 //         e.printStackTrace();
158          return null;
159       }
160    }
161 
162    public static final Vector factList(OntologyDb db, String str) {
163      try {
164          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
165          return parser.factList(db);
166       }
167       catch(Exception e) {
168           e.printStackTrace(); 
169          Core.ERROR(null,12,"Error parsing " + str);
170          return null;
171       }
172    }
173    public static final FactSummary factSummary(OntologyDb db, String str) {
174      try {
175          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
176          return parser.factSummary(db);
177       }
178       catch(Exception e) {
179          Core.ERROR(null,13,"Error parsing " + str);
180          return null;
181       }
182    }
183 
184 
185     public static final Vector goalList(OntologyDb db, String str) {
186      try {
187          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
188          return parser.goalList(db);
189       }
190       catch(Exception e) {
191          Core.ERROR(null,14,"Error parsing " + str);
192          return null;
193       }
194    }
195 
196    public static final Goal goal(OntologyDb db, String str) {
197      try {
198          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
199          return parser.goal(db);
200       }
201       catch(Exception e) {
202          Core.ERROR(null,15,"Error parsing " + str);
203          return null;
204       }
205    }
206    public static final GoalSummary goalSummary(String str) {
207      try {
208          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
209          return parser.goalSummary();
210       }
211       catch(Exception e) {
212          Core.ERROR(null,16,"Error parsing " + str);
213          return null;
214       }
215    }
216    
217    
218   
219    
220    public static final FIPAPerformative fipaPerformative (String str) { 
221     try {
222         str = str.toLowerCase(); 
223         FIPAParser parser = new FIPAParser (new ByteArrayInputStream(str.getBytes()));
224         return parser.Message(); 
225     }
226 
227  catch (Exception e) { 
228 	                  /*  try {
229 	                    java.io.File file = new java.io.File("debugperfparser.out");
230 	                    java.io.FileOutputStream fileout = new java.io.FileOutputStream(file);
231 	                    java.io.PrintWriter fw= new java.io.PrintWriter(fileout); 
232 	                    e.printStackTrace(fw);
233 	                    fw.flush();
234 	                    fw.close();} catch (Exception ne) { ne.printStackTrace(); }*/
235          e.printStackTrace(); 
236        //  Core.ERROR(null,17,"Error parsing " + str);
237          return null;
238       }
239    }
240    
241    
242    public static final Hashtable addresses (String str) {
243         try {
244         FIPAParser parser = new FIPAParser (new ByteArrayInputStream(str.getBytes()));
245         return parser.Addresses(); 
246     }
247       catch(Exception e) {
248          e.printStackTrace(); 
249          Core.ERROR(null,17,"Error parsing " + str);
250          return null;
251       }
252    }
253    
254    
255    public static final FIPA_AID_Address fipaAddress(String str) {
256         try {
257         FIPAParser parser = new FIPAParser (new ByteArrayInputStream(str.getBytes()));
258         return parser.SenderName(); 
259     }
260       catch(Exception e) {
261          e.printStackTrace(); 
262          Core.ERROR(null,17,"Error parsing " + str);
263          return null;
264       }
265    }
266    
267    
268    /*** 
269     is this quicker? 
270     Should be!
271     */
272    public static final Performative performative (byte [] bytes) {
273      try {
274          PerformativeParser parser = new PerformativeParser(new ByteArrayInputStream(bytes));
275          return parser.Message();
276       }
277       catch(Exception e) {
278          e.printStackTrace(); 
279          Core.ERROR(null,17,"Error parsing " + new String (bytes));
280          return null;
281       }
282    }
283             
284    
285    
286    
287    public synchronized static final Performative performative(String str) {
288      try {
289         str = str.toLowerCase();
290          PerformativeParser parser = new PerformativeParser(new ByteArrayInputStream(str.getBytes()));
291          return parser.Message();
292       }
293       catch(Exception e) {
294          e.printStackTrace(); 
295          Core.ERROR(null,17,"Error parsing " + str);
296          return null;
297       }
298    }
299    
300    public static final ProducerRecord producerRecord(String str) {
301      try {
302          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
303          return parser.producerRecord();
304       }
305       catch(Exception e) {
306          Core.ERROR(null,18,"Error parsing " + str);
307          return null;
308       }
309    }
310    public static final ProtocolInfo protocolInfo(OntologyDb db, String str) {
311      try {
312          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
313          return parser.protocolInfo(db);
314       }
315       catch(Exception e) {
316          Core.ERROR(null,19,"Error parsing " + str);
317          return null;
318       }
319    }
320    public static final StrategyInfo strategyInfo(OntologyDb db, String str) {
321       try {
322          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
323          return parser.strategyInfo(db);
324       }
325       catch(Exception e) {
326          Core.ERROR(null,20,"Error parsing " + str);
327          return null;
328       }
329    }
330    public static final Relationship relationship(String str) {
331       try {
332          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
333          return parser.relationship();
334       }
335       catch(Exception e) {
336          Core.ERROR(null,21,"Error parsing " + str);
337          return null;
338       }
339    }
340    public static final Vector relationshipList(String str) {
341       try {
342          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
343          return parser.relationshipList();
344       }
345       catch(Exception e) {
346          Core.ERROR(null,210,"Error parsing " + str);
347          return null;
348       }
349    }
350    public static final ReportRec reportRec(OntologyDb db, String str) {
351       try {
352          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
353          return parser.reportRec(db);
354       }
355       catch(Exception e) {
356          Core.ERROR(null,22,"Error parsing " + str);
357          return null;
358       }
359    }
360    public static final ReservationEntry reservationEntry(String str) {
361      try {
362          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
363          return parser.reservationEntry();
364       }
365       catch(Exception e) {
366          Core.ERROR(null,23,"Error parsing " + str);
367          return null;
368       }
369    }
370    public static final RoutingRecord routingRecord(String str) {
371      try {
372          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
373          return parser.routingRecord();
374       }
375       catch(Exception e) {
376          Core.ERROR(null,24,"Error parsing " + str);
377          return null;
378       }
379    }
380    public static final SuppliedDb suppliedDb(OntologyDb db, String str) {
381      try {
382          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
383          return parser.suppliedDb(db);
384       }
385       catch(Exception e) {
386          Core.ERROR(null,25,"Error parsing " + str);
387          return null;
388       }
389    }
390    public static final SuppliedItem suppliedItem(OntologyDb db, String str) {
391       try {
392          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
393          return parser.suppliedItem(db);
394       }
395       catch(Exception e) {
396          Core.ERROR(null,26,"Error parsing " + str);
397          return null;
398       }
399    }
400    public static final ResolutionContext resolutionContext(OntologyDb db, String str) {
401       try {
402          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
403          return parser.resolutionContext(db);
404       }
405       catch(Exception e) {
406          Core.ERROR(null,27,"Error parsing " + str);
407          return null;
408       }
409 
410    }
411    public static final AbstractTask abstractTask(OntologyDb db, String str) {
412       try {
413          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
414          return parser.abstractTask(db);
415       }
416       catch(Exception e) {
417          Core.ERROR(null,28,"Error parsing " + str);
418          return null;
419       }
420 
421    }
422    public static final PrimitiveTask primitiveTask(OntologyDb db, String str) {
423       try {
424          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
425          return parser.primitiveTask(db);
426       }
427       catch(Exception e) {
428          Core.ERROR(null,29,"Error parsing " + str);
429          return null;
430       }
431 
432    }
433    public static final SummaryTask summaryTask(OntologyDb db, String str) {
434       try {
435          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
436          return parser.summaryTask(db);
437       }
438       catch(Exception e) {
439          Core.ERROR(null,30,"Error parsing " + str);
440          return null;
441       }
442    }
443    public static final PlanScript planScript(OntologyDb db, String str) {
444       try {
445          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
446          return parser.planScript(db);
447       }
448       catch(Exception e) {
449          Core.ERROR(null,301,"Error parsing " + str);
450          return null;
451       }
452    }
453    public static final TaskLink taskLink(String str) {
454      try {
455          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
456          return parser.taskLink();
457       }
458       catch(Exception e) {
459          Core.ERROR(null,31,"Error parsing " + str);
460          return null;
461       }
462    }
463    public static final TaskNode taskNode(OntologyDb db, String str) {
464       try {
465          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
466          return parser.taskNode(db);
467       }
468       catch(Exception e) {
469          Core.ERROR(null,32,"Error parsing " + str);
470          return null;
471       }
472    }
473    public static final TaskSummary taskSummary(OntologyDb db, String str) {
474       try {
475          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
476          return parser.taskSummary(db);
477       }
478       catch(Exception e) {
479          Core.ERROR(null,33,"Error parsing " + str);
480          return null;
481       }
482    }
483    public static final Ordering ordering(String str) {
484       try {
485          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
486          return parser.ordering();
487       }
488       catch(Exception e) {
489          Core.ERROR(null,34,"Error parsing " + str);
490          return null;
491       }
492    }
493    public static final AbstractTask reteKB(OntologyDb db, String str) {
494       try {
495          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
496          return parser.reteKB(db);
497       }
498       catch(Exception e) {
499          Core.ERROR(null,35,"Error parsing " + str);
500          return null;
501       }
502    }
503    public static final AbstractTask reteKB(OntologyDb db, InputStream stream) {
504       try {
505          Parser parser = new Parser(stream);
506          return parser.reteKB(db);
507       }
508       catch(Exception e) {
509          Core.ERROR(null,63,"Error parsing\n" + e);
510 e.printStackTrace();
511          return null;
512       }
513    }
514    public static final Rule reteRule(OntologyDb db, String str) {
515       try {
516          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
517          return parser.reteRule(db);
518       }
519       catch(Exception e) {
520          Core.ERROR(null,36,"Error parsing " + str);
521          return null;
522       }
523    }
524    public static final Pattern retePattern(OntologyDb db, String str) {
525      try {
526          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
527          return parser.retePattern(db);
528       }
529       catch(Exception e) {
530          Core.ERROR(null,37,"Error parsing " + str);
531          return null;
532       }
533    }
534    public static final Action reteAction(OntologyDb db, String str) {
535      try {
536          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
537          return parser.reteAction(db);
538       }
539       catch(Exception e) {
540          Core.ERROR(null,38,"Error parsing " + str);
541          return null;
542       }
543    }
544    public static final Vector reteFactList(OntologyDb db, InputStream stream) {
545      try {
546          Parser parser = new Parser(stream);
547          return parser.reteFactList(db);
548       }
549       catch(Exception e) {
550          Core.ERROR(null,390,"Error parsing reteFactList from stream" + stream);
551          return null;
552       }
553    }
554    public static final Vector reteFactList(OntologyDb db, String str) {
555      try {
556          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
557          return parser.reteFactList(db);
558       }
559       catch(Exception e) {
560          Core.ERROR(null,391,"Error parsing " + str);
561          return null;
562       }
563    }
564 
565    public static final ReteFact reteFact(OntologyDb db, String str) {
566      try {
567          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
568          return parser.reteFact(db);
569       }
570       catch(Exception e) {
571          e.printStackTrace();
572          Core.ERROR(null,39,"Error parsing " + str);
573          return null;
574       }
575    }
576    
577    
578    public static final Vector retePatternList(OntologyDb db, String str) {
579      try {
580          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
581          return parser.retePatternList(db);
582       }
583       catch(Exception e) {
584         e.printStackTrace();
585          Core.ERROR(null,40,"Error parsing " + str);
586          return null;
587       }
588    }
589    public static final Vector reteActionList(OntologyDb db, String str) {
590       try {
591          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
592          return parser.reteActionList(db);
593       }
594       catch(Exception e) {
595         e.printStackTrace(); 
596          Core.ERROR(null,62,"Error parsing " + str);
597          return null;
598       }
599    }
600    public static final AgentInfo agentInfo(
601      GeneratorModel genmodel, GenerationPlan genplan, String str){
602      try {
603          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
604          return parser.agentInfo(genmodel,genplan);
605       }
606       catch(Exception e) {
607          Core.ERROR(null,41,"Error parsing " + str);
608          return null;
609       }
610    }
611    public static final DbProxyInfo dbProxyInfo(String str) {
612       try {
613          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
614          return parser.dbProxyInfo();
615       }
616       catch(Exception e) {
617          Core.ERROR(null,42,"Error parsing " + str);
618          return null;
619       }
620    }
621    public static final FacilitatorInfo facilitatorInfo(GenerationPlan genplan, String str) {
622      try {
623          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
624          return parser.facilitatorInfo(genplan);
625       }
626       catch(Exception e) {
627          Core.ERROR(null,43,"Error parsing " + str);
628          return null;
629       }
630    }
631    public static final VisualiserInfo visualiserInfo(GenerationPlan genplan, String str) {
632      try {
633          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
634          return parser.visualiserInfo(genplan);
635       }
636       catch(Exception e) {
637          Core.ERROR(null,44,"Error parsing " + str);
638          return null;
639       }
640    }
641    public static final NameserverInfo nameserverInfo(String str) {
642       try {
643          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
644          return parser.nameserverInfo();
645       }
646       catch(Exception e) {
647          Core.ERROR(null,45,"Error parsing " + str);
648          return null;
649       }
650    }
651    public static final TaskInfo taskInfo(GeneratorModel genmodel, String str) {
652      try {
653          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
654          return parser.taskInfo(genmodel);
655       }
656       catch(Exception e) {
657          Core.ERROR(null,46,"Error parsing " + str);
658          return null;
659       }
660    }
661    
662    
663    public static final Vector taskList(OntologyDb db, String str) {
664      try {
665          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
666          return parser.taskList(db);
667       }
668       catch(Exception e) {
669          Core.ERROR(null,47,"Error parsing " + str);
670          return null;
671       }
672    }
673    
674    
675    public static final ValueFunction Expression(String str) {
676       return Expression(null,str);
677    }
678    
679    
680    public static final ValueFunction Expression(OntologyDb db, String str) {
681       try {
682          Parser parser = new Parser(new ByteArrayInputStream(str.getBytes()));
683          return parser.Expression(db);
684       }
685       catch(Exception e) {
686          return null;
687       }
688    }
689    
690    
691     public static final FIPA_AMS_Management_Content FIPA_AMS_Management_Content (String str) { 
692          try {
693             FIPAParser parser = new FIPAParser (new ByteArrayInputStream(str.getBytes()));
694             return parser.FIPA_AMS_Management_Content(); 
695           }
696     catch (Exception e) { 
697 	                   /* try {
698 	                    java.io.File file = new java.io.File("debugperfparser.out");
699 	                    java.io.FileOutputStream fileout = new java.io.FileOutputStream(file);
700 	                    java.io.PrintWriter fw= new java.io.PrintWriter(fileout); 
701 	                    e.printStackTrace(fw);
702 	                    fw.flush();
703 	                    fw.close();} catch (Exception ne) { ne.printStackTrace(); }   */
704 	                    e.printStackTrace();
705 		return (null);
706       }
707    }
708    
709    
710     public static final FIPA_DF_Management_Content FIPA_DF_Management_Content (String str) { 
711          try {
712             FIPAParser parser = new FIPAParser (new ByteArrayInputStream(str.getBytes()));
713             return parser.FIPA_DF_Management_Content(); 
714           }
715       catch(Exception e) {
716          e.printStackTrace(); 
717          Core.ERROR(null,49,"Error parsing " + str);
718          return null;
719       }
720    }
721    
722     public static final DF_Description DF_Content (String str) { 
723          try {
724             FIPAParser parser = new FIPAParser (new ByteArrayInputStream(str.getBytes()));
725             return parser.DFDescription(); 
726           }
727       catch(Exception e) {
728          e.printStackTrace(); 
729          Core.ERROR(null,49,"Error parsing " + str);
730          return null;
731       }
732    }
733    
734     public static final Vector descriptionSet (String str) { 
735    try {
736             FIPAParser parser = new FIPAParser (new ByteArrayInputStream(str.getBytes()));
737             return parser.descriptions(); 
738           }
739       catch(Exception e) {
740          e.printStackTrace(); 
741          return null;
742       }
743     }
744     
745    public static final StringHashtable Transports (String str) { 
746          try {
747             FIPAParser parser = new FIPAParser (new ByteArrayInputStream(str.getBytes()));
748             return parser.Transports(); 
749           }
750       catch(Exception e) {
751          e.printStackTrace(); 
752          Core.ERROR(null,50,"Error parsing " + str);
753          return null;
754       }
755    }
756 
757     public static void main (String argv[]) {
758 	descriptionSet (argv[0]); 
759     }
760 }