1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 /******************************************************************************
25 * GeneratorModel.java
26 *
27 * Underlying Model of the Zeus Agent Generator
28 *****************************************************************************/
29
30 package zeus.generator;
31
32 import java.util.*;
33 import java.io.File;
34 import javax.swing.event.*;
35
36 import zeus.util.*;
37 import zeus.concepts.*;
38 import zeus.generator.event.*;
39
40
41 public class GeneratorModel implements ChangeListener
42 {
43 private int agentCount = 0;
44 private int agentIdCount = 0;
45 private int taskCount = 0;
46 private int taskIdCount = 0;
47
48 protected EventListenerList eventListeners = new EventListenerList();
49
50 protected Hashtable agentTable;
51 protected Hashtable taskTable;
52 protected Hashtable agentNames;
53 protected Hashtable taskNames;
54 protected Hashtable iconTable;
55
56 public OntologyDb ontology;
57
58
59 public String dbName = "";
60 public String dbDriver = "";
61 public String dbUsername = "";
62 public String dbPassword = "";
63
64
65 public GeneratorModel(OntologyDb ontology)
66 {
67 this.ontology = ontology;
68 ontology.addChangeListener(this);
69
70 agentTable = new Hashtable();
71 taskTable = new Hashtable();
72 agentNames = new Hashtable();
73 taskNames = new Hashtable();
74 iconTable = new Hashtable();
75 }
76
77 public void clear() {
78 Enumeration enum;
79 AgentDescription agent;
80 AbstractTask task;
81
82 enum = agentTable.elements();
83 while( enum.hasMoreElements() ) {
84 agent = (AgentDescription)enum.nextElement();
85 fireAgentChanged(agent,AgentChangeEvent.DELETE);
86 }
87 enum = taskTable.elements();
88 while( enum.hasMoreElements() ) {
89 task = (AbstractTask)enum.nextElement();
90 fireTaskChanged(task,TaskChangeEvent.DELETE);
91 }
92 agentTable.clear();
93 taskTable.clear();
94 agentNames.clear();
95 taskNames.clear();
96 iconTable.clear();
97 }
98
99
100
101
102
103
104 public String getAgentIcon(String agentId) {
105 Core.ERROR(agentNames.containsKey(agentId),255,this);
106 String icon = (String)iconTable.get(agentId);
107 if ( icon == null ) {
108 icon = SystemProps.getProperty("gif.dir") + File.separator + "agent.gif";
109 iconTable.put(agentId,icon);
110 }
111 return icon;
112 }
113
114 public void setAgentIcon(String agentId, String icon) {
115 Core.ERROR(agentNames.containsKey(agentId),255,this);
116 String oldIcon = (String)iconTable.get(agentId);
117 boolean changed = (oldIcon == null && icon != null) ||
118 (oldIcon != null && icon == null) ||
119 (oldIcon != null && icon != null && !icon.equals(oldIcon));
120 if ( icon == null )
121 icon = SystemProps.getProperty("gif.dir") + File.separator + "agent.gif";
122 iconTable.put(agentId,icon);
123
124
125 if ( changed && agentTable.containsKey(agentId) )
126 fireAgentChanged((AgentDescription)agentTable.get(agentId), AgentChangeEvent.MODIFY);
127 }
128
129 public AgentDescription[] getAgents() {
130 AgentDescription[] List = new AgentDescription[agentTable.size()];
131 Enumeration elem = agentTable.elements();
132 for(int i = 0; elem.hasMoreElements(); i++ )
133 List[i] = (AgentDescription) elem.nextElement();
134 return List;
135 }
136
137 public Object[][] getAgentData() {
138 Object[][] data = new Object[agentTable.size()][3];
139 Enumeration elem = agentTable.elements();
140 for(int i = 0; elem.hasMoreElements(); i++ ) {
141 AgentDescription a = (AgentDescription) elem.nextElement();
142 data[i][0] = getAgentName(a.getName());
143 String[] tasks = a.getTasks();
144 for(int j = 0; j < tasks.length; j++ )
145 tasks[j] = getTaskName(tasks[j]);
146 data[i][1] = tasks;
147
148 data[i][2] = a.getName();
149 }
150 return data;
151 }
152
153 public void updateAgent(AgentDescription agent) {
154 String id = agent.getName();
155 Object ob = agentTable.put(id,agent);
156 Core.ERROR(ob != null,7,this);
157 fireAgentChanged(agent,AgentChangeEvent.MODIFY);
158 }
159
160 public void addAgent(AgentDescription agent) {
161 String id = agent.getName();
162 Core.ERROR(!agentTable.containsKey(id),1,this);
163 agentTable.put(id, new AgentDescription(agent));
164 if ( agentNames.get(id) == null ) {
165 String name = "Agent" + (agentCount++);
166 while( reverseAgentNameLookup(name) != null )
167 name = "Agent" + (agentCount++);
168 agentNames.put(id, name);
169 }
170 fireAgentChanged(agent,AgentChangeEvent.ADD);
171 }
172
173 public void modifyAgentTasks(String id, String[] tasks) {
174 String taskId[] = new String[tasks.length];
175 for(int i = 0; i < tasks.length; i++ )
176 taskId[i] = reverseTaskNameLookup(tasks[i]);
177 AgentDescription agent = (AgentDescription) agentTable.get(id);
178 agent.setTasks(taskId);
179 fireAgentChanged(agent,AgentChangeEvent.MODIFY);
180 }
181
182
183 public void addAgent(Vector v) {
184 for(int i = 0; v != null && i < v.size(); i++ )
185 addAgent((AgentDescription)v.elementAt(i));
186 }
187
188
189 public void removeAgent(String id) {
190 AgentDescription agent = (AgentDescription)agentTable.get(id);
191 agentTable.remove(id);
192 agentNames.remove(id);
193 iconTable.remove(id);
194 fireAgentChanged(agent,AgentChangeEvent.DELETE);
195
196 }
197
198
199 public AgentDescription getAgent(String id) {
200 AgentDescription ob = (AgentDescription)agentTable.get(id);
201 Assert.notNull(ob);
202 return new AgentDescription(ob);
203 }
204
205
206
207
208
209
210 public void addAgentName(String id, String name) {
211 agentNames.put(id, name);
212 }
213
214 public String createNewAgentId() {
215 String id = "AgentId" + (agentIdCount++);
216 while( agentNames.containsKey(id) )
217 id = "AgentId" + (agentIdCount++);
218 return id;
219 }
220
221 public void createNewAgent() {
222 createNewAgent(createNewAgentId());
223 }
224
225 public void createNewAgent(String id) {
226 Core.ERROR(agentNames.get(id) == null, 6, this);
227 String name = "Agent" + (agentCount++);
228 while( reverseAgentNameLookup(name) != null )
229 name = "Agent" + (agentCount++);
230
231 agentNames.put(id, name);
232 AgentDescription agent = new AgentDescription();
233 agent.setName(id);
234 addAgent(agent);
235 }
236
237 public void cloneAgent(String id) {
238 String name = (String)agentNames.get(id);
239 Core.ERROR(name,11,this);
240 AgentDescription agent = (AgentDescription)agentTable.get(id);
241
242 String newName = name + "$" + (agentCount++);
243 while( reverseAgentNameLookup(newName) != null )
244 newName = name + "$" + (agentCount++);
245
246 String newId = createNewAgentId();
247
248 agentNames.put(newId,newName);
249 AgentDescription newAgent = new AgentDescription(agent);
250 newAgent.setName(newId);
251 agentTable.put(newId,newAgent);
252 fireAgentChanged(newAgent,AgentChangeEvent.ADD);
253 }
254
255
256 public String getAgentName(String id) {
257 return (String)agentNames.get(id);
258 }
259
260 public String[] getAgentIds() {
261 String[] data = new String[agentNames.size()];
262 Enumeration enum = agentNames.keys();
263 for(int i = 0; i < data.length; i++ )
264 data[i] = (String)enum.nextElement();
265 return data;
266 }
267
268 public String[] getAgentNames() {
269 String[] data = new String[agentNames.size()];
270 Enumeration enum = agentNames.elements();
271 for(int i = 0; i < data.length; i++ )
272 data[i] = (String)enum.nextElement();
273 return data;
274 }
275
276 public String reverseAgentNameLookup(String name) {
277 Enumeration keys = agentNames.keys();
278 while( keys.hasMoreElements() ) {
279 String k = (String)keys.nextElement();
280 String s = (String)agentNames.get(k);
281 if (s.equals(name))
282 return k;
283 }
284 return null;
285 }
286
287 public void renameAgent(String id, String newname) {
288 String name = newname;
289 while( reverseAgentNameLookup(newname) != null )
290 name = newname + (agentIdCount++);
291 agentNames.put(id,name);
292 AgentDescription agent = (AgentDescription)agentTable.get(id);
293 fireAgentChanged(agent,AgentChangeEvent.MODIFY);
294 }
295
296 public boolean containsAgent(String id) {
297 Assert.notNull(id);
298 return agentNames.containsKey(id);
299 }
300
301
302
303
304 public void addTaskName(String id, String name) {
305 taskNames.put(id, name);
306 }
307
308 public void addTask(AbstractTask task) {
309
310
311 String id = task.getName();
312 Core.ERROR(!taskTable.containsKey(id),2,this);
313 String name = getTaskName(id);
314 Core.ERROR(name,3,this);
315 taskNames.put(id,name);
316 switch( task.getType() ) {
317 case AbstractTask.PRIMITIVE:
318 taskTable.put(id,new PrimitiveTask((PrimitiveTask)task));
319 break;
320 case AbstractTask.SUMMARY:
321 taskTable.put(id,new SummaryTask((SummaryTask)task));
322 break;
323 case AbstractTask.BEHAVIOUR:
324 taskTable.put(id,new ReteKB((ReteKB)task));
325 break;
326 case AbstractTask.SCRIPT:
327 taskTable.put(id,new PlanScript((PlanScript)task));
328 break;
329 }
330 fireTaskChanged(task,TaskChangeEvent.ADD);
331 }
332
333 public void updateTask(AbstractTask task) {
334 String id = task.getName();
335 Object ob = taskTable.put(id, task);
336 Core.ERROR(ob != null,4,this);
337 fireTaskChanged(task,TaskChangeEvent.MODIFY);
338 }
339
340 public void addTask(Vector v) {
341 for(int i = 0; v != null && i < v.size(); i++ )
342 addTask((AbstractTask)v.elementAt(i));
343 }
344
345 public void removeTask(String id) {
346 AbstractTask task = (AbstractTask)taskTable.get(id);
347 taskTable.remove(id);
348 taskNames.remove(id);
349 Enumeration enum = agentTable.elements();
350 AgentDescription a;
351 while( enum.hasMoreElements() ) {
352 a = (AgentDescription)enum.nextElement();
353 if ( a.removeTask(id) )
354 fireAgentChanged(a,AgentChangeEvent.MODIFY);
355 }
356 fireTaskChanged(task,TaskChangeEvent.DELETE);
357 }
358
359 public AbstractTask getTask(String id) {
360 return (AbstractTask)taskTable.get(id);
361 }
362
363 public boolean containsTask(String id, int type) {
364 AbstractTask t = (AbstractTask)taskTable.get(id);
365 return (t != null && t.getType() == type);
366 }
367
368 public int getTaskCount(int type) {
369 Enumeration elem = taskTable.elements();
370 int count = 0;
371 AbstractTask t;
372 while( elem.hasMoreElements() ) {
373 t = (AbstractTask) elem.nextElement();
374 if ( t.getType() == type ) count++;
375 }
376 return count;
377 }
378
379 public AbstractTask[] getTasks() {
380 AbstractTask[] List = new AbstractTask[taskTable.size()];
381 Enumeration elem = taskTable.elements();
382 for(int i = 0; elem.hasMoreElements(); i++ )
383 List[i] = (AbstractTask) elem.nextElement();
384 return List;
385 }
386
387 public AbstractTask[] getTasks(int type) {
388 AbstractTask[] List = new AbstractTask[getTaskCount(type)];
389 Enumeration elem = taskTable.elements();
390 int i = 0;
391 AbstractTask t;
392 while( elem.hasMoreElements() ) {
393 t = (AbstractTask) elem.nextElement();
394 if ( t.getType() == type )
395 List[i++] = t;
396 }
397 return List;
398 }
399
400 public String[] getTaskNames(int type) {
401 String[] List = new String[getTaskCount(type)];
402 Enumeration elem = taskTable.elements();
403 int i = 0;
404 AbstractTask t;
405 while( elem.hasMoreElements() ) {
406 t = (AbstractTask) elem.nextElement();
407 if ( t.getType() == type )
408 List[i++] = (String)taskNames.get(t.getName());
409 }
410 return List;
411 }
412
413 public String getTaskType(String id) {
414 AbstractTask t = (AbstractTask)taskTable.get(id);
415 return t.getTypeName();
416 }
417
418 public String createNewTaskId() {
419 String id = "AbstractTaskId" + (taskIdCount++);
420 while( taskNames.containsKey(id) )
421 id = "AbstractTaskId" + (taskIdCount++);
422 return id;
423 }
424
425 public void createNewTask(String type) {
426 createNewTask(createNewTaskId(),type);
427 }
428
429 public void createNewTask(String id, String type) {
430 Core.ERROR(taskNames.get(id) == null, 5, this);
431 String name = "Task" + (taskCount++);
432 while( reverseTaskNameLookup(name) != null )
433 name = "Task" + (taskCount++);
434
435 taskNames.put(id,name);
436 AbstractTask task = null;
437 switch( AbstractTask.getType(type) ) {
438 case AbstractTask.PRIMITIVE:
439 task = new PrimitiveTask();
440 break;
441 case AbstractTask.SUMMARY:
442 task = new SummaryTask();
443 break;
444 case AbstractTask.BEHAVIOUR:
445 task = new ReteKB();
446 break;
447 case AbstractTask.SCRIPT:
448 task = new PlanScript();
449 break;
450 }
451 task.setName(id);
452 taskTable.put(id,task);
453 fireTaskChanged(task,TaskChangeEvent.ADD);
454 }
455
456 public void cloneTask(String id) {
457 String name = (String)taskNames.get(id);
458 Core.ERROR(name,10,this);
459 AbstractTask task = (AbstractTask)taskTable.get(id);
460
461 String newName = name + "$" + (taskCount++);
462 while( reverseTaskNameLookup(newName) != null )
463 newName = name + "$" + (taskCount++);
464
465 String newId = createNewTaskId();
466
467 taskNames.put(newId,newName);
468 AbstractTask newTask = null;
469
470 switch( task.getType() ) {
471 case AbstractTask.PRIMITIVE:
472 newTask = new PrimitiveTask((PrimitiveTask)task);
473 break;
474 case AbstractTask.SUMMARY:
475 newTask = new SummaryTask((SummaryTask)task);
476 break;
477 case AbstractTask.BEHAVIOUR:
478 newTask = new ReteKB((ReteKB)task);
479 break;
480 case AbstractTask.SCRIPT:
481 newTask = new PlanScript((PlanScript)task);
482 break;
483 }
484 newTask.setName(newId);
485 taskTable.put(newId,newTask);
486 fireTaskChanged(newTask,TaskChangeEvent.ADD);
487 }
488
489 public Object[][] getTaskData() {
490 Object[][] data = new Object[taskTable.size()][3];
491 Enumeration elem = taskTable.elements();
492 for(int i = 0; elem.hasMoreElements(); i++ ) {
493 AbstractTask t = (AbstractTask) elem.nextElement();
494 data[i][0] = getTaskName(t.getName());
495 data[i][1] = t.getTypeName();
496
497 data[i][2] = t.getName();
498 }
499 return data;
500 }
501
502 public String getTaskName(String id) {
503 return (String)taskNames.get(id);
504 }
505
506 public String[] getTaskIds() {
507 String[] data = new String[taskNames.size()];
508 Enumeration enum = taskNames.keys();
509 for(int i = 0; i < data.length; i++ )
510 data[i] = (String)enum.nextElement();
511 return data;
512
513 }
514 public String[] getTaskNames() {
515 String[] data = new String[taskNames.size()];
516 Enumeration enum = taskNames.elements();
517 for(int i = 0; i < data.length; i++ )
518 data[i] = (String)enum.nextElement();
519 return data;
520 }
521
522 public String reverseTaskNameLookup(String name) {
523 Enumeration keys = taskNames.keys();
524 while( keys.hasMoreElements() ) {
525 String k = (String)keys.nextElement();
526 String s = (String)taskNames.get(k);
527 if (s.equals(name))
528 return k;
529 }
530 return null;
531 }
532
533 public void renameTask(String id, String newname) {
534 String name = newname;
535 while ( reverseTaskNameLookup(newname) != null )
536 name = newname + (taskIdCount++);
537 taskNames.put(id,name);
538 AbstractTask task = (AbstractTask)taskTable.get(id);
539 fireTaskChanged(task,TaskChangeEvent.MODIFY);
540 }
541
542 public boolean containsTask(String id) {
543 return taskNames.containsKey(id);
544 }
545
546
547
548
549
550 public void stateChanged(ChangeEvent evt) {
551
552
553 fireChanged();
554 }
555
556 public void addChangeListener(ChangeListener x) {
557 eventListeners.add(ChangeListener.class, x);
558 }
559 public void removeChangeListener(ChangeListener x) {
560 eventListeners.remove(ChangeListener.class, x);
561 }
562
563 public void addAgentListener(AgentListener x) {
564 eventListeners.add(AgentListener.class, x);
565 }
566 public void removeAgentListener(AgentListener x) {
567 eventListeners.remove(AgentListener.class, x);
568 }
569
570 public void addTaskListener(TaskListener x) {
571 eventListeners.add(TaskListener.class, x);
572 }
573 public void removeTaskListener(TaskListener x) {
574 eventListeners.remove(TaskListener.class, x);
575 }
576
577 protected void fireChanged() {
578 ChangeEvent c = new ChangeEvent(this);
579 Object[] listeners = eventListeners.getListenerList();
580 for(int i= listeners.length-2; i >= 0; i -=2) {
581 if (listeners[i] == ChangeListener.class) {
582 ChangeListener cl = (ChangeListener)listeners[i+1];
583 cl.stateChanged(c);
584 }
585 }
586 }
587 protected void fireAgentChanged(AgentDescription agent, int mode) {
588 AgentChangeEvent c = new AgentChangeEvent(this,agent,mode);
589 Object[] listeners = eventListeners.getListenerList();
590 for(int i= listeners.length-2; i >= 0; i -=2) {
591 if (listeners[i] == AgentListener.class) {
592 AgentListener cl = (AgentListener)listeners[i+1];
593 cl.agentStateChanged(c);
594 }
595 }
596 fireChanged();
597 }
598 protected void fireTaskChanged(AbstractTask task, int mode) {
599 TaskChangeEvent c = new TaskChangeEvent(this,task,mode);
600 Object[] listeners = eventListeners.getListenerList();
601 for(int i= listeners.length-2; i >= 0; i -=2) {
602 if (listeners[i] == TaskListener.class) {
603 TaskListener cl = (TaskListener)listeners[i+1];
604 cl.taskStateChanged(c);
605 }
606 }
607 fireChanged();
608 }
609 }