source/mir/producer/reader/ProducerConfigReader.java

   1 /*
   2  * Copyright (C) 2001, 2002  The Mir-coders group
   3  *
   4  * This file is part of Mir.
   5  *
   6  * Mir is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Mir is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with Mir; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * In addition, as a special exception, The Mir-coders gives permission to link
  21  * the code of this program with the com.oreilly.servlet library, any library
  22  * licensed under the Apache Software License, The Sun (tm) Java Advanced
  23  * Imaging library (JAI), The Sun JIMI library (or with modified versions of
  24  * the above that use the same license as the above), and distribute linked
  25  * combinations including the two.  You must obey the GNU General Public
  26  * License in all respects for all of the code used other than the above
  27  * mentioned libraries.  If you modify this file, you may extend this exception
  28  * to your version of the file, but you are not obligated to do so.  If you do
  29  * not wish to do so, delete this exception statement from your version.
  30  */
  31
  32 package  mir.producer.reader;
  33
  34 import java.io.File;
  35 import java.util.HashMap;
  36 import java.util.HashSet;
  37 import java.util.Iterator;
  38 import java.util.List;
  39 import java.util.Map;
  40 import java.util.Set;
  41 import java.util.Vector;
  42
  43 import mir.producer.CompositeProducerNode;
  44 import mir.producer.ProducerFactory;
  45 import mir.producer.ProducerNode;
  46 import mir.producer.SimpleProducerVerb;
  47 import mir.util.XMLReader;
  48 import mir.util.XMLReaderTool;
  49
  50 public class ProducerConfigReader {
  51   private ProducerNodeBuilderLibrary builderLibrary;
  52   private ProducerNodeBuilderLibrary scriptedNodeBuilderLibrary;
  53
  54   public ProducerConfigReader() {
  55     super();
  56   };
  57
  58   public void parseFile(String aFileName, ProducerNodeBuilderLibrary aBuilderLibrary, List aProducerFactories) throws ProducerConfigFailure {
  59     parseFile(aFileName, aBuilderLibrary, aProducerFactories, new Vector());
  60   }
  61
  62   public void parseFile(String aFileName, ProducerNodeBuilderLibrary aBuilderLibrary, List aProducerFactories, List aUsedFiles) throws ProducerConfigFailure {
  63     try {
  64       XMLReader reader = new XMLReader();
  65       aUsedFiles.add(new File(aFileName));
  66
  67       builderLibrary = aBuilderLibrary;
  68       scriptedNodeBuilderLibrary = new ProducerNodeBuilderLibrary();
  69
  70       reader.parseFile(aFileName, new RootSectionHandler(aProducerFactories));
  71
  72     }
  73     catch (Throwable e) {
  74       if ((e instanceof XMLReader.XMLReaderExc) && ((XMLReader.XMLReaderExc) e).getHasLocation()) {
  75         XMLReader.XMLReaderExc f = (XMLReader.XMLReaderExc) e;
  76         throw new ProducerConfigFailure("'" + f.getMessage()+"' in " + f.getFilename()+"(line " + f.getLineNr()+", column " + f.getColumnNr() + ")", e);
  77       }
  78       throw new ProducerConfigFailure( e );
  79     }
  80   }
  81
  82
  83   public class RootSectionHandler extends XMLReader.AbstractSectionHandler {
  84     private List producers;
  85
  86     public RootSectionHandler(List aProducers) {
  87       producers = aProducers;
  88     }
  89
  90     public XMLReader.SectionHandler startElement(String aTag, Map anAttributes) throws XMLReader.XMLReaderExc {
  91       if (aTag.equals("producers")) {
  92         return new ProducersSectionHandler(producers);
  93       }
  94       else
  95         throw new XMLReader.XMLReaderExc("Tag 'producers' expected, tag '"+aTag+"' found");
  96     }
  97
  98     public void endElement(XMLReader.SectionHandler aHandler) {
  99     }
 100
 101     public void finishSection() {
 102     }
 103   }
 104
 105
 106   private final static String   PRODUCER_NAME_ATTRIBUTE = "name";
 107   private final static String[] PRODUCER_REQUIRED_ATTRIBUTES = { PRODUCER_NAME_ATTRIBUTE };
 108   private final static String[] PRODUCER_OPTIONAL_ATTRIBUTES = { };
 109
 110   private final static String   NODE_DEFINITION_NAME_ATTRIBUTE = "name";
 111   private final static String[] NODE_DEFINITION_REQUIRED_ATTRIBUTES = { NODE_DEFINITION_NAME_ATTRIBUTE };
 112   private final static String[] NODE_DEFINITION_OPTIONAL_ATTRIBUTES = {  };
 113
 114   public class ProducersSectionHandler extends XMLReader.AbstractSectionHandler {
 115     private List producers;
 116     private Set producerNames;
 117     private String name;
 118
 119     public ProducersSectionHandler(List aProducers) {
 120       producers = aProducers;
 121       producerNames = new HashSet();
 122     }
 123
 124     public XMLReader.SectionHandler startElement(String aTag, Map anAttributes) throws XMLReader.XMLReaderExc {
 125       if (aTag.equals("producer")) {
 126         XMLReaderTool.checkAttributes(anAttributes,
 127                                       PRODUCER_REQUIRED_ATTRIBUTES,
 128                                       PRODUCER_OPTIONAL_ATTRIBUTES);
 129
 130         name = (String) anAttributes.get(PRODUCER_NAME_ATTRIBUTE);
 131         XMLReaderTool.checkValidIdentifier(name);
 132
 133         if (producerNames.contains(name))
 134           throw new XMLReader.XMLReaderExc("Duplicate producer name: '" +
 135                                            name + "'");
 136
 137         name = (String) anAttributes.get(PRODUCER_NAME_ATTRIBUTE);
 138
 139         return new ProducerSectionHandler(name);
 140       }
 141       else if (aTag.equals("nodedefinition")) {
 142         XMLReaderTool.checkAttributes(anAttributes,
 143                                       NODE_DEFINITION_REQUIRED_ATTRIBUTES,
 144                                       NODE_DEFINITION_OPTIONAL_ATTRIBUTES);
 145
 146         name = (String) anAttributes.get(NODE_DEFINITION_NAME_ATTRIBUTE);
 147         XMLReaderTool.checkValidIdentifier(name);
 148
 149         name = (String) anAttributes.get(NODE_DEFINITION_NAME_ATTRIBUTE);
 150
 151         return new NodeDefinitionSectionHandler(name);
 152       }
 153       throw new XMLReader.XMLReaderExc("Unexpected tag: " + aTag);
 154     }
 155
 156     public void endElement(XMLReader.SectionHandler aHandler) throws XMLReader.XMLReaderExc {
 157       if (aHandler instanceof ProducerSectionHandler) {
 158         producers.add(((ProducerSectionHandler) aHandler).getProducerFactory());
 159         producerNames.add(((ProducerSectionHandler) aHandler).getProducerFactory().getName());
 160       }
 161       else if (aHandler instanceof NodeDefinitionSectionHandler) {
 162         scriptedNodeBuilderLibrary.registerFactory(name,
 163             new DefaultProducerNodeBuilders.ScriptedProducerNodeBuilder.factory(
 164                 ((NodeDefinitionSectionHandler) aHandler).getDefinition()));
 165       }
 166       else throw new XMLReader.XMLReaderExc("ProducersSectionHandler.endElement Internal error: Unexpected handler: " + aHandler.getClass().getName());
 167     }
 168
 169     public void finishSection() {
 170     }
 171   }
 172
 173   public class ProducerSectionHandler extends XMLReader.AbstractSectionHandler {
 174     private ProducerFactory producerFactory;
 175     private String factoryName;
 176
 177     private ProducerNode body;
 178     private Map verbNodes;
 179     private List verbs;
 180     private String defaultVerb;
 181
 182     public ProducerSectionHandler(String aName) {
 183       factoryName = aName;
 184     }
 185
 186     public XMLReader.SectionHandler startElement(String aTag, Map anAttributes) throws XMLReader.XMLReaderExc {
 187       if (aTag.equals("verbs")) {
 188         if (verbs!=null)
 189           throw new XMLReader.XMLReaderExc("Verbs already processed");
 190         if (body!=null)
 191           throw new XMLReader.XMLReaderExc("Verbs should come before body");
 192         else
 193           return new ProducerVerbsSectionHandler();
 194       }
 195       else if (aTag.equals("body")) {
 196         if (body==null)
 197           return new ProducerNodeSectionHandler();
 198         else
 199           throw new XMLReader.XMLReaderExc("Body already processed");
 200       }
 201       throw new XMLReader.XMLReaderExc("Unexpected tag: '"+aTag+"'");
 202     }
 203
 204     public void endElement(XMLReader.SectionHandler aHandler) throws XMLReader.XMLReaderExc {
 205       if (aHandler instanceof ProducerNodeSectionHandler) {
 206         body = ((ProducerNodeSectionHandler) aHandler).getProducerNode();
 207       }
 208       else if (aHandler instanceof ProducerVerbsSectionHandler)
 209       {
 210         verbs = ((ProducerVerbsSectionHandler) aHandler).getVerbs();
 211         verbNodes = ((ProducerVerbsSectionHandler) aHandler).getVerbNodes();
 212         defaultVerb = ((ProducerVerbsSectionHandler) aHandler).getDefaultVerb();
 213       }
 214       else throw new XMLReader.XMLReaderExc("ProducerSectionHandler.endElement Internal error: Unexpected handler: " + aHandler.getClass().getName());
 215     }
 216
 217     public void finishSection() throws XMLReader.XMLReaderExc {
 218       if (verbs==null)
 219         throw new XMLReader.XMLReaderExc("No verbs defined");
 220
 221       if (body==null)
 222         throw new XMLReader.XMLReaderExc("No body defined");
 223
 224       producerFactory = new ScriptedProducerFactory(factoryName, verbs, verbNodes, body, defaultVerb);
 225     }
 226
 227     public ProducerFactory getProducerFactory() {
 228       return producerFactory;
 229     }
 230   }
 231
 232   private final static String   PRODUCER_VERB_NAME_ATTRIBUTE = "name";
 233   private final static String   PRODUCER_VERB_DESCRIPTION_ATTRIBUTE = "description";
 234   private final static String   PRODUCER_VERB_DEFAULT_ATTRIBUTE = "default";
 235   private final static String[] PRODUCER_VERB_REQUIRED_ATTRIBUTES = { PRODUCER_VERB_NAME_ATTRIBUTE };
 236   private final static String[] PRODUCER_VERB_OPTIONAL_ATTRIBUTES = { PRODUCER_VERB_DEFAULT_ATTRIBUTE, PRODUCER_VERB_DESCRIPTION_ATTRIBUTE };
 237
 238   public class ProducerVerbsSectionHandler extends XMLReader.AbstractSectionHandler {
 239     private Map verbNodes;
 240     private List verbs;
 241     private String defaultVerb;
 242     private String currentVerb;
 243     private String currentVerbDescription;
 244
 245     public ProducerVerbsSectionHandler() {
 246       verbNodes = new HashMap();
 247       verbs = new Vector();
 248       defaultVerb = null;
 249     }
 250
 251     public XMLReader.SectionHandler startElement(String aTag, Map anAttributes) throws XMLReader.XMLReaderExc {
 252       if (aTag.equals("verb")) {
 253         XMLReaderTool.checkAttributes(anAttributes,
 254                                       PRODUCER_VERB_REQUIRED_ATTRIBUTES,
 255                                       PRODUCER_VERB_OPTIONAL_ATTRIBUTES);
 256         currentVerb = (String) anAttributes.get(PRODUCER_VERB_NAME_ATTRIBUTE);
 257
 258         XMLReaderTool.checkValidIdentifier(currentVerb);
 259
 260         if (verbNodes.containsKey(currentVerb))
 261           throw new XMLReader.XMLReaderExc("Duplicate definition of verb '" +
 262                                            currentVerb + "'");
 263
 264         if (anAttributes.containsKey(PRODUCER_VERB_DEFAULT_ATTRIBUTE)) {
 265           if (defaultVerb != null)
 266             throw new XMLReader.XMLReaderExc("Default verb already declared");
 267
 268           defaultVerb = currentVerb;
 269         }
 270
 271         if (anAttributes.containsKey(PRODUCER_VERB_DESCRIPTION_ATTRIBUTE))
 272           currentVerbDescription = (String) anAttributes.get(
 273               PRODUCER_VERB_DESCRIPTION_ATTRIBUTE);
 274         else
 275           currentVerbDescription = "";
 276
 277         return new ProducerNodeSectionHandler();
 278       }
 279       else
 280         throw new XMLReader.XMLReaderExc("Only 'verb' tags allowed here, '" +
 281                                          aTag + "' encountered.");
 282     }
 283
 284     public void endElement(XMLReader.SectionHandler aHandler) {
 285       verbNodes.put(currentVerb, ((ProducerNodeSectionHandler) aHandler).getProducerNode());
 286       verbs.add(new SimpleProducerVerb(currentVerb, currentVerbDescription));
 287     }
 288
 289     public void finishSection() {
 290     }
 291
 292     public String getDefaultVerb() {
 293       return defaultVerb;
 294     }
 295
 296     public List getVerbs() {
 297       return verbs;
 298     }
 299
 300     public Map getVerbNodes() {
 301       return verbNodes;
 302     }
 303   }
 304
 305   public class EmptySectionHandler extends XMLReader.AbstractSectionHandler {
 306     public XMLReader.SectionHandler startElement(String aTag, Map anAttributes) throws XMLReader.XMLReaderExc {
 307       throw new XMLReader.XMLReaderExc("No tags are allowed here");
 308     }
 309
 310     public void endElement(XMLReader.SectionHandler aHandler) {
 311     }
 312
 313     public void finishSection() {
 314     }
 315   }
 316
 317   public class MultiProducerNodeSectionHandler extends XMLReader.AbstractSectionHandler {
 318     private Map nodeParameters;
 319     private Set validNodeParameters;
 320     private String currentNodeParameter;
 321     private String scriptedNodeName;
 322     private Set allowedNodeParameterReferences;
 323
 324     public MultiProducerNodeSectionHandler(String aScriptedNodeName, Set anAllowedNodeParameterReferences, Set aValidNodeParameters) {
 325       allowedNodeParameterReferences = anAllowedNodeParameterReferences;
 326       scriptedNodeName = aScriptedNodeName;
 327       validNodeParameters = aValidNodeParameters;
 328       nodeParameters = new HashMap();
 329     }
 330     public MultiProducerNodeSectionHandler(Set aValidNodeParameters) {
 331       this("", new HashSet(), aValidNodeParameters);
 332     }
 333
 334     public XMLReader.SectionHandler startElement(String aTag, Map anAttributes) throws XMLReader.XMLReaderExc {
 335       if (!validNodeParameters.contains(aTag))
 336         throw new XMLReader.XMLReaderExc("Invalid node parameter: '" + aTag + "'");
 337       else if (nodeParameters.containsKey(aTag))
 338         throw new XMLReader.XMLReaderExc("Node parameter: '" + aTag + "' already specified");
 339       else if (anAttributes.size()>0)
 340         throw new XMLReader.XMLReaderExc("No parameters are allowed here");
 341
 342       currentNodeParameter = aTag;
 343
 344       return new ProducerNodeSectionHandler(scriptedNodeName, validNodeParameters);
 345     }
 346
 347     public void endElement(XMLReader.SectionHandler aHandler) throws XMLReader.XMLReaderExc  {
 348       if (aHandler instanceof ProducerNodeSectionHandler) {
 349         nodeParameters.put(currentNodeParameter, ((ProducerNodeSectionHandler) aHandler).getProducerNode());
 350       }
 351       else {
 352         throw new XMLReader.XMLReaderExc("Internal error: unknown section handler '" + aHandler.getClass().getName() + "'" );
 353       }
 354     }
 355
 356     public Map getNodeParameters() {
 357       return nodeParameters;
 358     }
 359
 360     public void finishSection() {
 361     }
 362   }
 363
 364   public class ProducerNodeSectionHandler extends XMLReader.AbstractSectionHandler {
 365     private CompositeProducerNode producerNode;
 366     private ProducerNodeBuilder currentBuilder;
 367     private String scriptedNodeName;
 368     private Set allowedNodeParameterReferences;
 369
 370     public ProducerNodeSectionHandler(String aScriptedNodeName, Set anAllowedNodeParameterReferences) {
 371       producerNode = new CompositeProducerNode();
 372       scriptedNodeName = aScriptedNodeName;
 373       allowedNodeParameterReferences = anAllowedNodeParameterReferences;
 374     }
 375
 376     public ProducerNodeSectionHandler() {
 377       this("", new HashSet());
 378     }
 379
 380     public XMLReader.SectionHandler startElement(String aTag, Map anAttributes) throws XMLReader.XMLReaderExc {
 381       try {
 382         if (allowedNodeParameterReferences.contains( (aTag))) {
 383           if (!anAttributes.isEmpty()) {
 384             throw new XMLReader.XMLReaderExc("No attributes allowed");
 385           }
 386
 387           currentBuilder = new DefaultProducerNodeBuilders.
 388               ScriptedProducerParameterNodeBuilder(scriptedNodeName, aTag);
 389           return new EmptySectionHandler();
 390         }
 391         else if (scriptedNodeBuilderLibrary.hasBuilderForName(aTag) ||
 392                  builderLibrary.hasBuilderForName( (aTag))) {
 393
 394           if (scriptedNodeBuilderLibrary.hasBuilderForName(aTag))
 395             currentBuilder = scriptedNodeBuilderLibrary.constructBuilder(aTag);
 396           else
 397             currentBuilder = builderLibrary.constructBuilder(aTag);
 398
 399           currentBuilder.setAttributes(anAttributes);
 400           if (currentBuilder.getAvailableSubNodes().isEmpty()) {
 401             return new EmptySectionHandler();
 402           }
 403           if (currentBuilder.getAvailableSubNodes().size() > 1)
 404             return new MultiProducerNodeSectionHandler(scriptedNodeName,
 405                 allowedNodeParameterReferences,
 406                 currentBuilder.getAvailableSubNodes());
 407           else if (currentBuilder.getAvailableSubNodes().size() < 1)
 408             return new EmptySectionHandler();
 409           else {
 410             return new ProducerNodeSectionHandler(scriptedNodeName,
 411                 allowedNodeParameterReferences);
 412           }
 413         }
 414         else
 415           throw new XMLReader.XMLReaderExc("Unknown producer node tag: '" +
 416                                            aTag + "'");
 417       }
 418       catch (Throwable t) {
 419         throw new XMLReader.XMLReaderFailure(t);
 420       }
 421     }
 422
 423     public void endElement(XMLReader.SectionHandler aHandler) throws XMLReader.XMLReaderExc  {
 424       try {
 425         if (aHandler instanceof ProducerNodeSectionHandler) {
 426           currentBuilder.setSubNode(
 427                 (String) (currentBuilder.getAvailableSubNodes().iterator().next()),
 428                 ((ProducerNodeSectionHandler) aHandler).getProducerNode());
 429         }
 430         else if (aHandler instanceof MultiProducerNodeSectionHandler) {
 431           Iterator i;
 432           Map nodeParameters;
 433           Map.Entry entry;
 434
 435           nodeParameters = ( (MultiProducerNodeSectionHandler) aHandler).
 436               getNodeParameters();
 437           i = nodeParameters.entrySet().iterator();
 438           while (i.hasNext()) {
 439             entry = (Map.Entry) i.next();
 440             currentBuilder.setSubNode( (String) entry.getKey(),
 441                                       (ProducerNode) entry.getValue());
 442           }
 443         }
 444         else if (aHandler instanceof EmptySectionHandler) {
 445           // deliberately empty: nothing expected, so nothing to process
 446         }
 447         else {
 448           throw new XMLReader.XMLReaderExc(
 449               "Internal error: unknown section handler '" +
 450               aHandler.getClass().getName() + "'");
 451         }
 452
 453         producerNode.addSubNode(currentBuilder.constructNode());
 454         currentBuilder = null;
 455       }
 456       catch (Throwable t) {
 457         throw new XMLReader.XMLReaderFailure(t);
 458       }
 459     }
 460
 461     public ProducerNode getProducerNode() {
 462       if (producerNode.getNrSubNodes()==1) {
 463         return producerNode.getSubNode(0);
 464       }
 465       else {
 466         return producerNode;
 467       }
 468     }
 469
 470     public void finishSection() {
 471     }
 472   }
 473
 474   public class NodeDefinitionSectionHandler extends XMLReader.AbstractSectionHandler {
 475     private ScriptedProducerNodeDefinition nodeDefinition;
 476     private ProducerNode body;
 477     private Map stringParameters;
 478     private Map integerParameters;
 479     private Map nodeParameters;
 480     private String name;
 481
 482     public NodeDefinitionSectionHandler(String aName) {
 483       body = null;
 484       nodeParameters = null;
 485       stringParameters = null;
 486       integerParameters = null;
 487       name = aName;
 488     }
 489
 490     public XMLReader.SectionHandler startElement(String aTag, Map anAttributes) throws XMLReader.XMLReaderExc {
 491       if (aTag.equals("parameters")) {
 492         if (!anAttributes.isEmpty()) {
 493           throw new XMLReader.XMLReaderExc( "No attributes allowed for tag 'parameters'" );
 494         }
 495         if (nodeParameters!=null) {
 496           throw new XMLReader.XMLReaderExc( "Parameters have already been declared" );
 497         }
 498         if (body!=null) {
 499           throw new XMLReader.XMLReaderExc( "Parameters should come before definition in nodedefinition '" + name +"'" );
 500         }
 501
 502         return new NodeDefinitionParametersSectionHandler();
 503       }
 504       else if (aTag.equals("definition")) {
 505         if (nodeParameters==null)
 506           throw new XMLReader.XMLReaderExc( "Parameters should come before definition in nodedefinition '" + name +"'"  );
 507
 508         return new ProducerNodeSectionHandler(name, nodeParameters.keySet());
 509       }
 510       else throw new XMLReader.XMLReaderExc("Only 'definition' or 'parameters' tags allowed here, '" + aTag + "' encountered.");
 511     }
 512
 513     public void endElement(XMLReader.SectionHandler aHandler) {
 514       if (aHandler instanceof NodeDefinitionParametersSectionHandler) {
 515         stringParameters = ((NodeDefinitionParametersSectionHandler) aHandler).getStringParameters();
 516         integerParameters = ((NodeDefinitionParametersSectionHandler) aHandler).getIntegerParameters();
 517         nodeParameters = ((NodeDefinitionParametersSectionHandler) aHandler).getNodeParameters();
 518       }
 519       else if (aHandler instanceof ProducerNodeSectionHandler) {
 520         body = ((ProducerNodeSectionHandler) aHandler).getProducerNode();
 521       }
 522     }
 523
 524     public void finishSection() throws XMLReader.XMLReaderExc {
 525       Iterator i;
 526       if (body == null)
 527         throw new XMLReader.XMLReaderExc( "Definition missing" );
 528
 529       nodeDefinition = new ScriptedProducerNodeDefinition(name);
 530
 531       nodeDefinition.setBody(body);
 532
 533       i = nodeParameters.keySet().iterator();
 534       while (i.hasNext()) {
 535         nodeDefinition.addNodeParameter((String) i.next());
 536       }
 537
 538       i = stringParameters.entrySet().iterator();
 539       while (i.hasNext()) {
 540         Map.Entry entry = (Map.Entry) i.next();
 541         nodeDefinition.addStringParameter((String) entry.getKey(), (String) entry.getValue());
 542       }
 543
 544       i = integerParameters.entrySet().iterator();
 545       while (i.hasNext()) {
 546         Map.Entry entry = (Map.Entry) i.next();
 547         nodeDefinition.addIntegerParameter((String) entry.getKey(), (String) entry.getValue());
 548       }
 549     }
 550
 551     public ScriptedProducerNodeDefinition getDefinition() {
 552       return nodeDefinition;
 553     }
 554   }
 555
 556   private final static String   NODE_DEFINITION_PARAMETER_NAME_ATTRIBUTE = "name";
 557   private final static String   NODE_DEFINITION_PARAMETER_DEFAULTVALUE_ATTRIBUTE = "defaultvalue";
 558   private final static String[] NODE_DEFINITION_PARAMETER_REQUIRED_ATTRIBUTES = { NODE_DEFINITION_PARAMETER_NAME_ATTRIBUTE };
 559   private final static String[] NODE_DEFINITION_PARAMETER_OPTIONAL_ATTRIBUTES = { NODE_DEFINITION_PARAMETER_DEFAULTVALUE_ATTRIBUTE };
 560   private final static String[] NODE_DEFINITION_NODE_PARAMETER_OPTIONAL_ATTRIBUTES = { };
 561
 562   public class NodeDefinitionParametersSectionHandler extends XMLReader.AbstractSectionHandler {
 563     private Map nodeParameters;
 564     private Map stringParameters;
 565     private Map integerParameters;
 566
 567     public NodeDefinitionParametersSectionHandler() {
 568       nodeParameters = new HashMap();
 569       stringParameters = new HashMap();
 570       integerParameters = new HashMap();
 571     }
 572
 573     public XMLReader.SectionHandler startElement(String aTag, Map anAttributes) throws XMLReader.XMLReaderExc {
 574       String parameterName;
 575       String defaultValue;
 576
 577       if (aTag.equals("node")) {
 578         XMLReaderTool.checkAttributes(anAttributes,
 579             NODE_DEFINITION_PARAMETER_REQUIRED_ATTRIBUTES,
 580             NODE_DEFINITION_NODE_PARAMETER_OPTIONAL_ATTRIBUTES);
 581         parameterName = (String) anAttributes.get(
 582             NODE_DEFINITION_PARAMETER_NAME_ATTRIBUTE);
 583
 584         if (nodeParameters.containsKey(parameterName))
 585           throw new XMLReader.XMLReaderExc("Duplicate parameter name: '" +
 586                                            parameterName + "'");
 587
 588         XMLReaderTool.checkValidIdentifier(parameterName);
 589
 590         nodeParameters.put(parameterName, parameterName);
 591
 592         return new EmptySectionHandler();
 593       }
 594       else if (aTag.equals("string") || aTag.equals("integer")) {
 595         XMLReaderTool.checkAttributes(anAttributes,
 596             NODE_DEFINITION_PARAMETER_REQUIRED_ATTRIBUTES,
 597             NODE_DEFINITION_PARAMETER_OPTIONAL_ATTRIBUTES);
 598         parameterName = (String) anAttributes.get(
 599             NODE_DEFINITION_PARAMETER_NAME_ATTRIBUTE);
 600
 601         if (stringParameters.containsKey(parameterName) ||
 602             integerParameters.containsKey(parameterName))
 603           throw new XMLReader.XMLReaderExc("Duplicate parameter name: '" +
 604                                            parameterName + "'");
 605
 606         XMLReaderTool.checkValidIdentifier(parameterName);
 607
 608         defaultValue = (String) anAttributes.get(
 609             NODE_DEFINITION_PARAMETER_DEFAULTVALUE_ATTRIBUTE);
 610
 611         if (aTag.equals("string"))
 612           stringParameters.put(parameterName, defaultValue);
 613         else
 614           integerParameters.put(parameterName, defaultValue);
 615
 616         return new EmptySectionHandler();
 617       }
 618       else
 619         throw new XMLReader.XMLReaderExc(
 620             "Only 'string', 'integer' and 'node' tags allowed here, '" + aTag + "' encountered.");
 621     }
 622
 623     public void endElement(XMLReader.SectionHandler aHandler) {
 624     }
 625
 626     public void finishSection() {
 627     }
 628
 629     public Map getNodeParameters() {
 630       return nodeParameters;
 631     }
 632
 633     public Map getStringParameters() {
 634       return stringParameters;
 635     }
 636
 637     public Map getIntegerParameters() {
 638       return integerParameters;
 639     }
 640   }
 641 }