libjava/classpath/javax/imageio/metadata/IIOMetadataFormatImpl.java

   1 /* IIOMetadataFormatImpl.java --
   2    Copyright (C) 2004  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath 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, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package javax.imageio.metadata;
  40
  41 import org.w3c.dom.Attr;
  42 import org.w3c.dom.DOMException;
  43 import org.w3c.dom.Document;
  44 import org.w3c.dom.Element;
  45 import org.w3c.dom.NamedNodeMap;
  46 import org.w3c.dom.Node;
  47 import org.w3c.dom.NodeList;
  48 import org.w3c.dom.TypeInfo;
  49 import org.w3c.dom.UserDataHandler;
  50 import java.util.ArrayList;
  51 import java.util.HashMap;
  52 import java.util.Map;
  53 import java.util.Iterator;
  54 import java.util.List;
  55 import java.util.Locale;
  56 import java.util.ResourceBundle;
  57 import java.util.MissingResourceException;
  58 import javax.imageio.ImageTypeSpecifier;
  59
  60 public abstract class IIOMetadataFormatImpl implements IIOMetadataFormat
  61 {
  62   /**
  63    * The standard metadata format name constant set to
  64    * "javax_imageio_1.0".
  65    */
  66   public static final String standardMetadataFormatName = "javax_imageio_1.0";
  67
  68   private String rootName;
  69
  70   // These maps assume that each element name is unique.
  71
  72   private Map nodes = new HashMap();
  73
  74   // A mapping from element name to child policy.
  75   private Map childPolicies = new HashMap();
  76
  77   // A mapping from element name to the permissible number of
  78   // children.  Values in this map are length-two integer arrays; the
  79   // first index is the minimum bound, the second index is the maximum
  80   // bound.
  81   private Map childRanges = new HashMap();
  82
  83   private String resourceBaseName;
  84
  85   // Package-private so that it may be used in IIOMetadataNode.
  86   static class IIOMetadataNodeAttr extends IIOMetadataNode
  87     implements Attr
  88   {
  89     protected Element owner;
  90     protected String name;
  91     protected int dataType;
  92     protected boolean required;
  93     protected String defaultValue;
  94
  95     public IIOMetadataNodeAttr (Element owner,
  96                                 String name,
  97                                 String defaultValue)
  98     {
  99       this (owner, name, IIOMetadataFormat.DATATYPE_STRING,
 100             true, defaultValue);
 101     }
 102
 103     public IIOMetadataNodeAttr (Element owner,
 104                                 String name,
 105                                 int dataType,
 106                                 boolean required,
 107                                 String defaultValue)
 108     {
 109       this.owner = owner;
 110       this.name = name;
 111       this.dataType = dataType;
 112       this.required = required;
 113       this.defaultValue = defaultValue;
 114     }
 115
 116     public String getName ()
 117     {
 118       return name;
 119     }
 120
 121     public Element getOwnerElement ()
 122     {
 123       return owner;
 124     }
 125
 126     public int getDataType ()
 127     {
 128       return dataType;
 129     }
 130
 131     public TypeInfo getSchemaTypeInfo ()
 132     {
 133       return null;
 134     }
 135
 136     public boolean getSpecified ()
 137     {
 138       return false;
 139     }
 140
 141     public String getValue ()
 142     {
 143       return defaultValue;
 144     }
 145
 146     public boolean isId()
 147     {
 148       return false;
 149     }
 150
 151     public void setValue (String value)
 152     {
 153     }
 154
 155     // new methods
 156
 157     public boolean isRequired ()
 158     {
 159       return required;
 160     }
 161   }
 162
 163   private class IIOMetadataNodeAttrEnumerated extends IIOMetadataNodeAttr
 164   {
 165     protected List enumeratedValues;
 166
 167     public IIOMetadataNodeAttrEnumerated (Element owner,
 168                                           String name,
 169                                           int dataType,
 170                                           boolean required,
 171                                           String defaultValue,
 172                                           List enumeratedValues)
 173     {
 174       super (owner, name, dataType, required, defaultValue);
 175       this.enumeratedValues = new ArrayList (enumeratedValues);
 176     }
 177
 178     public Object[] getEnumerations ()
 179     {
 180       return enumeratedValues.toArray ();
 181     }
 182   }
 183
 184   private class IIOMetadataNodeAttrBounded extends IIOMetadataNodeAttr
 185   {
 186     protected String minValue;
 187     protected String maxValue;
 188     protected boolean minInclusive;
 189     protected boolean maxInclusive;
 190
 191     public IIOMetadataNodeAttrBounded (Element owner,
 192                                        String name,
 193                                        int dataType,
 194                                        boolean required,
 195                                        String defaultValue,
 196                                        String minValue,
 197                                        String maxValue,
 198                                        boolean minInclusive,
 199                                        boolean maxInclusive)
 200     {
 201       super (owner, name, dataType, required, defaultValue);
 202       this.minValue = minValue;
 203       this.maxValue = maxValue;
 204       this.minInclusive = minInclusive;
 205       this.maxInclusive = maxInclusive;
 206     }
 207
 208     public String getMinValue ()
 209     {
 210       return minValue;
 211     }
 212
 213     public String getMaxValue ()
 214     {
 215       return maxValue;
 216     }
 217   }
 218
 219   private class IIOMetadataNodeAttrList extends IIOMetadataNodeAttr
 220   {
 221     protected int listMinLength;
 222     protected int listMaxLength;
 223
 224     public IIOMetadataNodeAttrList (Element owner,
 225                                     String name,
 226                                     int dataType,
 227                                     boolean required,
 228                                     int listMinLength,
 229                                     int listMaxLength)
 230     {
 231       super (owner, name, dataType, required, null);
 232       this.listMinLength = listMinLength;
 233       this.listMaxLength = listMaxLength;
 234     }
 235
 236     public int getListMinLength ()
 237     {
 238       return listMinLength;
 239     }
 240
 241     public int getListMaxLength ()
 242     {
 243       return listMaxLength;
 244     }
 245   }
 246
 247   private class NodeObject
 248   {
 249     protected Element owner;
 250     protected Class classType;
 251     protected boolean required;
 252     protected Object defaultValue;
 253     protected int valueType;
 254
 255     public NodeObject (Element owner,
 256                        Class classType,
 257                        boolean required,
 258                        Object defaultValue)
 259     {
 260       this.owner = owner;
 261       this.classType = classType;
 262       this.required = required;
 263       this.defaultValue = defaultValue;
 264       valueType = IIOMetadataFormat.VALUE_ARBITRARY;
 265     }
 266
 267     public int getValueType ()
 268     {
 269       return valueType;
 270     }
 271
 272     public Class getClassType ()
 273     {
 274       return classType;
 275     }
 276
 277     public Element getOwnerElement ()
 278     {
 279       return owner;
 280     }
 281
 282     public Object getDefaultValue ()
 283     {
 284       return defaultValue;
 285     }
 286
 287     public boolean isRequired ()
 288     {
 289       return required;
 290     }
 291   }
 292
 293   private class NodeObjectEnumerated extends NodeObject
 294   {
 295     protected List enumeratedValues;
 296
 297     public NodeObjectEnumerated (Element owner,
 298                                  Class classType,
 299                                  boolean required,
 300                                  Object defaultValue,
 301                                  List enumeratedValues)
 302     {
 303       super (owner, classType, false, defaultValue);
 304       this.enumeratedValues = enumeratedValues;
 305       valueType = IIOMetadataFormat.VALUE_ENUMERATION;
 306     }
 307
 308     public Object[] getEnumerations ()
 309     {
 310       return enumeratedValues.toArray();
 311     }
 312   }
 313
 314   private class NodeObjectBounded extends NodeObject
 315   {
 316     protected Comparable minValue;
 317     protected Comparable maxValue;
 318     protected boolean minInclusive;
 319     protected boolean maxInclusive;
 320
 321     public NodeObjectBounded (Element owner,
 322                               Class classType,
 323                               Object defaultValue,
 324                               Comparable minValue,
 325                               Comparable maxValue,
 326                               boolean minInclusive,
 327                               boolean maxInclusive)
 328     {
 329       super (owner, classType, false, defaultValue);
 330       this.minValue = minValue;
 331       this.maxValue = maxValue;
 332       this.minInclusive = minInclusive;
 333       this.maxInclusive = maxInclusive;
 334       if (minInclusive)
 335         {
 336           if (maxInclusive)
 337             valueType = IIOMetadataFormat.VALUE_RANGE_MIN_MAX_INCLUSIVE;
 338           else
 339             valueType = IIOMetadataFormat.VALUE_RANGE_MIN_INCLUSIVE;
 340         }
 341       else
 342         {
 343           if (maxInclusive)
 344             valueType = IIOMetadataFormat.VALUE_RANGE_MAX_INCLUSIVE;
 345           else
 346             valueType = IIOMetadataFormat.VALUE_RANGE;
 347         }
 348     }
 349
 350     public Comparable getMinValue ()
 351     {
 352       return minValue;
 353     }
 354
 355     public Comparable getMaxValue ()
 356     {
 357       return maxValue;
 358     }
 359   }
 360
 361   private class NodeObjectArray extends NodeObject
 362   {
 363     protected Integer arrayMinLength;
 364     protected Integer arrayMaxLength;
 365
 366     public NodeObjectArray (Element owner,
 367                             Class classType,
 368                             int arrayMinLength,
 369                             int arrayMaxLength)
 370     {
 371       super (owner, classType, false, null);
 372       this.arrayMinLength = new Integer (arrayMinLength);
 373       this.arrayMaxLength = new Integer (arrayMaxLength);
 374       valueType = IIOMetadataFormat.VALUE_LIST;
 375     }
 376
 377     public Comparable getArrayMinLength ()
 378     {
 379       return arrayMinLength;
 380     }
 381
 382     public Comparable getArrayMaxLength ()
 383     {
 384       return arrayMaxLength;
 385     }
 386   }
 387
 388   /**
 389    * Construct a blank IIOMetadataFormatImpl with the given root name
 390    * and child policy.
 391    *
 392    * @param rootName the root element name
 393    * @param childPolicy the child policy of the root element
 394    *
 395    * @exception IllegalArgumentException if rootName is null
 396    * @exception IllegalArgumentException if childPolicy is
 397    * CHILD_POLICY_REPEAT or if childPolicy is not a CHILD_POLICY
 398    * constant
 399    */
 400   public IIOMetadataFormatImpl (String rootName, int childPolicy)
 401   {
 402     if (rootName == null)
 403       throw new IllegalArgumentException ("null argument");
 404
 405     if (childPolicy < IIOMetadataFormat.CHILD_POLICY_ALL
 406         || childPolicy > IIOMetadataFormat.CHILD_POLICY_SOME
 407         || childPolicy == IIOMetadataFormat.CHILD_POLICY_REPEAT)
 408       throw new IllegalArgumentException ("wrong child policy");
 409
 410     nodes.put (rootName, new IIOMetadataNode (rootName));
 411     childPolicies.put (rootName, new Integer (childPolicy));
 412     this.rootName = rootName;
 413   }
 414
 415   /**
 416    * Construct a blank IIOMetadataFormatImpl with the given root name,
 417    * a child policy of CHILD_POLICY_REPEAT and the given minimum and
 418    * maximum limits on the number of root element children.
 419    *
 420    * @param rootName the root element name
 421    * @param minChildren the minimum number of children that this node
 422    * can have
 423    * @param maxChildren the maximum number of children that this node
 424    * can have
 425    *
 426    * @exception IllegalArgumentException if rootName is null
 427    * @exception IllegalArgumentException if minChildren is less than
 428    * zero or greater than maxChildren
 429    */
 430   public IIOMetadataFormatImpl (String rootName,
 431                                 int minChildren,
 432                                 int maxChildren)
 433   {
 434     if (rootName == null)
 435       throw new IllegalArgumentException ("null argument");
 436
 437     if (minChildren < 0 || maxChildren < minChildren)
 438       throw new IllegalArgumentException ("invalid min or max children argument");
 439
 440     nodes.put (rootName, new IIOMetadataNode (rootName));
 441     childPolicies.put (rootName, new Integer (IIOMetadataFormat.CHILD_POLICY_REPEAT));
 442     childRanges.put (rootName, new int [] { minChildren, maxChildren });
 443     this.rootName = rootName;
 444   }
 445
 446   protected void addAttribute (String elementName,
 447                                String attrName,
 448                                int dataType,
 449                                boolean required,
 450                                String defaultValue)
 451   {
 452     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 453     node.setAttributeNode (new IIOMetadataNodeAttr (node,
 454                                                     attrName,
 455                                                     dataType,
 456                                                     required,
 457                                                     defaultValue));
 458   }
 459
 460   protected void addAttribute (String elementName,
 461                                String attrName,
 462                                int dataType,
 463                                boolean required,
 464                                String defaultValue,
 465                                List<String> enumeratedValues)
 466   {
 467     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 468     node.setAttributeNode (new IIOMetadataNodeAttrEnumerated (node,
 469                                                               attrName,
 470                                                               dataType,
 471                                                               required,
 472                                                               defaultValue,
 473                                                               enumeratedValues));
 474   }
 475
 476   protected void addAttribute (String elementName,
 477                                String attrName,
 478                                int dataType,
 479                                boolean required,
 480                                String defaultValue,
 481                                String minValue,
 482                                String maxValue,
 483                                boolean minInclusive,
 484                                boolean maxInclusive)
 485   {
 486     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 487     node.setAttributeNode (new IIOMetadataNodeAttrBounded (node,
 488                                                            attrName,
 489                                                            dataType,
 490                                                            required,
 491                                                            defaultValue,
 492                                                            minValue,
 493                                                            maxValue,
 494                                                            minInclusive,
 495                                                            maxInclusive));
 496   }
 497
 498   protected void addAttribute (String elementName,
 499                                String attrName,
 500                                int dataType,
 501                                boolean required,
 502                                int listMinLength,
 503                                int listMaxLength)
 504   {
 505     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 506     node.setAttributeNode (new IIOMetadataNodeAttrList (node,
 507                                                         attrName,
 508                                                         dataType,
 509                                                         required,
 510                                                         listMinLength,
 511                                                         listMaxLength));
 512   }
 513
 514   protected void addBooleanAttribute (String elementName,
 515                                       String attrName,
 516                                       boolean hasDefaultValue,
 517                                       boolean defaultValue)
 518   {
 519     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 520
 521     List enumeratedValues = new ArrayList();
 522     enumeratedValues.add ("TRUE");
 523     enumeratedValues.add ("FALSE");
 524
 525     node.setAttributeNode (new IIOMetadataNodeAttrEnumerated (node,
 526                                                               attrName,
 527                                                               IIOMetadataFormat.DATATYPE_BOOLEAN,
 528                                                               hasDefaultValue,
 529                                                               defaultValue ? "TRUE" : "FALSE",
 530                                                               enumeratedValues));
 531   }
 532
 533   protected void addChildElement (String elementName, String parentName)
 534   {
 535     IIOMetadataNode node = (IIOMetadataNode) nodes.get (parentName);
 536
 537     node.appendChild (new IIOMetadataNode (elementName));
 538     childPolicies.put (elementName, new Integer (IIOMetadataFormat.CHILD_POLICY_REPEAT));
 539   }
 540
 541   protected void addElement (String elementName, String parentName, int childPolicy)
 542   {
 543     IIOMetadataNode node = (IIOMetadataNode) nodes.get (parentName);
 544
 545     node.appendChild (new IIOMetadataNode (elementName));
 546     childPolicies.put (elementName, new Integer (childPolicy));
 547   }
 548
 549   protected void addElement (String elementName, String parentName,
 550                              int minChildren, int maxChildren)
 551   {
 552     addChildElement (elementName, parentName);
 553     childRanges.put (elementName, new int [] { minChildren, maxChildren });
 554   }
 555
 556   private void addNodeObject (IIOMetadataNode node, NodeObject o)
 557   {
 558     node.setUserObject (o);
 559   }
 560
 561   private NodeObject getNodeObject (IIOMetadataNode node)
 562   {
 563     return (NodeObject) node.getUserObject ();
 564   }
 565
 566   private void removeNodeObject (IIOMetadataNode node)
 567   {
 568     node.setUserObject (null);
 569   }
 570
 571   protected <T> void addObjectValue (String elementName, Class<T> classType,
 572                                      boolean required, T defaultValue)
 573   {
 574     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 575     addNodeObject (node, new NodeObject (node,
 576                                          classType,
 577                                          required,
 578                                          defaultValue));
 579   }
 580
 581   protected <T> void addObjectValue (String elementName, Class<T> classType,
 582                                      boolean required, T defaultValue,
 583                                      List<? extends T> enumeratedValues)
 584   {
 585     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 586     addNodeObject (node, new NodeObjectEnumerated (node,
 587                                                    classType,
 588                                                    required,
 589                                                    defaultValue,
 590                                                    enumeratedValues));
 591   }
 592
 593   protected <T extends Object & Comparable<? super T>>
 594   void addObjectValue (String elementName, Class<T> classType,
 595                        T defaultValue,
 596                        Comparable<? super T> minValue,
 597                        Comparable<? super T> maxValue,
 598                        boolean minInclusive,
 599                        boolean maxInclusive)
 600   {
 601     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 602     addNodeObject (node, new NodeObjectBounded (node,
 603                                                 classType,
 604                                                 defaultValue,
 605                                                 minValue,
 606                                                 maxValue,
 607                                                 minInclusive,
 608                                                 maxInclusive));
 609   }
 610
 611   protected void addObjectValue (String elementName, Class<?> classType,
 612                                  int arrayMinLength, int arrayMaxLength)
 613   {
 614     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 615     addNodeObject (node, new NodeObjectArray (node,
 616                                               classType,
 617                                               arrayMinLength,
 618                                               arrayMaxLength));
 619   }
 620
 621   public String getRootName ()
 622   {
 623     return rootName;
 624   }
 625
 626   protected String getResourceBaseName ()
 627   {
 628     return resourceBaseName;
 629   }
 630
 631   public static IIOMetadataFormat getStandardFormatInstance ()
 632   {
 633     // FIXME: populate this with the standard metadata format
 634     return new IIOMetadataFormatImpl (standardMetadataFormatName,
 635                                       IIOMetadataFormat.CHILD_POLICY_ALL)
 636       {
 637         public boolean canNodeAppear (String elementName,
 638                                       ImageTypeSpecifier specifier)
 639         {
 640           return true;
 641         }
 642       };
 643   }
 644
 645   public abstract boolean canNodeAppear (String elementName,
 646                                          ImageTypeSpecifier specifier);
 647
 648   protected void removeAttribute (String elementName,
 649                                   String attrName)
 650   {
 651     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 652     node.removeAttribute (attrName);
 653   }
 654
 655   protected void removeElement (String elementName)
 656   {
 657     nodes.remove (elementName);
 658   }
 659
 660   protected void removeObjectValue (String elementName)
 661   {
 662     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 663     removeNodeObject (node);
 664   }
 665
 666   protected void setResourceBaseName (String resourceBaseName)
 667   {
 668     this.resourceBaseName = resourceBaseName;
 669   }
 670
 671   public int getAttributeDataType (String elementName, String attrName)
 672   {
 673     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 674     IIOMetadataNodeAttr attr = (IIOMetadataNodeAttr) node.getAttributeNode (attrName);
 675     return attr.getDataType ();
 676   }
 677
 678   public String getAttributeDefaultValue (String elementName, String attrName)
 679   {
 680     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 681     IIOMetadataNodeAttr attr = (IIOMetadataNodeAttr) node.getAttributeNode (attrName);
 682     return attr.getValue();
 683   }
 684
 685   public String getAttributeDescription (String elementName, String attrName, Locale locale)
 686   {
 687     return getDescription (elementName + "/" + attrName, locale);
 688   }
 689
 690   public String[] getAttributeEnumerations (String elementName, String attrName)
 691   {
 692     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 693     IIOMetadataNodeAttrEnumerated attr =
 694       (IIOMetadataNodeAttrEnumerated) node.getAttributeNode (attrName);
 695
 696     Object[] attrEnums = attr.getEnumerations();
 697
 698     String[] attrNames = new String[attrEnums.length];
 699
 700     for (int i = 0; i < attrEnums.length; i++)
 701       {
 702         attrNames[i] = (String) attrEnums[i];
 703       }
 704
 705     return attrNames;
 706   }
 707
 708   public int getAttributeListMaxLength (String elementName, String attrName)
 709   {
 710     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 711     IIOMetadataNodeAttrList attr =
 712       (IIOMetadataNodeAttrList) node.getAttributeNode (attrName);
 713     return attr.getListMaxLength();
 714   }
 715
 716   public int getAttributeListMinLength (String elementName, String attrName)
 717   {
 718     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 719     IIOMetadataNodeAttrList attr =
 720       (IIOMetadataNodeAttrList) node.getAttributeNode (attrName);
 721     return attr.getListMinLength();
 722   }
 723
 724   public String getAttributeMaxValue (String elementName, String attrName)
 725   {
 726     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 727     IIOMetadataNodeAttrBounded attr =
 728       (IIOMetadataNodeAttrBounded) node.getAttributeNode (attrName);
 729     return attr.getMaxValue();
 730   }
 731
 732   public String getAttributeMinValue (String elementName, String attrName)
 733   {
 734     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 735     IIOMetadataNodeAttrBounded attr =
 736       (IIOMetadataNodeAttrBounded) node.getAttributeNode (attrName);
 737     return attr.getMinValue();
 738   }
 739
 740   public String[] getAttributeNames (String elementName)
 741   {
 742     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 743
 744     NamedNodeMap attrNodes = node.getAttributes();
 745
 746     String[] attrNames = new String[attrNodes.getLength()];
 747
 748     for (int i = 0; i < attrNodes.getLength(); i++)
 749       {
 750         attrNames[i] = attrNodes.item (i).getLocalName();
 751       }
 752
 753     return attrNames;
 754   }
 755
 756   public int getAttributeValueType (String elementName, String attrName)
 757   {
 758     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 759     IIOMetadataNodeAttr attr = (IIOMetadataNodeAttr) node.getAttributeNode (attrName);
 760     return attr.getDataType();
 761   }
 762
 763   public String[] getChildNames (String elementName)
 764   {
 765     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 766
 767     NodeList childNodes = node.getChildNodes();
 768
 769     String[] childNames = new String[childNodes.getLength()];
 770
 771     for (int i = 0; i < childNodes.getLength(); i++)
 772       {
 773         childNames[i] = childNodes.item (i).getLocalName();
 774       }
 775
 776     return childNames;
 777   }
 778
 779   public int getChildPolicy (String elementName)
 780   {
 781     return ((Integer) childPolicies.get (elementName)).intValue();
 782   }
 783
 784   private String getDescription (String resourceName, Locale locale)
 785   {
 786     if (resourceBaseName == null)
 787       return null;
 788
 789     Locale l = locale;
 790
 791     if (l == null)
 792       l = Locale.getDefault();
 793
 794     ResourceBundle bundle = ResourceBundle.getBundle (resourceBaseName, locale);
 795
 796     String desc = null;
 797
 798     if (bundle == null)
 799       {
 800         try
 801           {
 802             desc = bundle.getString (resourceName);
 803           }
 804         catch (MissingResourceException e)
 805           {
 806             desc = null;
 807           }
 808       }
 809
 810     return desc;
 811   }
 812
 813   public String getElementDescription (String elementName, Locale locale)
 814   {
 815     return getDescription (elementName, locale);
 816   }
 817
 818   public int getElementMaxChildren (String elementName)
 819   {
 820     return ((int[]) childRanges.get (elementName))[1];
 821   }
 822
 823   public int getElementMinChildren (String elementName)
 824   {
 825     return ((int[]) childRanges.get (elementName))[0];
 826   }
 827
 828   public int getObjectArrayMaxLength (String elementName)
 829   {
 830     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 831     return ((Integer) ((NodeObjectArray) getNodeObject (node)).getArrayMaxLength ()).intValue();
 832   }
 833
 834   public int getObjectArrayMinLength (String elementName)
 835   {
 836     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 837     return ((Integer) ((NodeObjectArray) getNodeObject (node)).getArrayMinLength ()).intValue();
 838   }
 839
 840   public Class<?> getObjectClass (String elementName)
 841   {
 842     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 843     return getNodeObject (node).getClassType ();
 844   }
 845
 846   public Object getObjectDefaultValue (String elementName)
 847   {
 848     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 849     return getNodeObject (node).getDefaultValue ();
 850   }
 851
 852   public Object[] getObjectEnumerations (String elementName)
 853   {
 854     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 855     return ((NodeObjectEnumerated) getNodeObject (node)).getEnumerations ();
 856   }
 857
 858   public Comparable<?> getObjectMaxValue (String elementName)
 859   {
 860     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 861     return ((NodeObjectBounded) getNodeObject (node)).getMaxValue ();
 862   }
 863
 864   public Comparable<?> getObjectMinValue (String elementName)
 865   {
 866     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 867     return ((NodeObjectBounded) getNodeObject (node)).getMinValue ();
 868   }
 869
 870   public int getObjectValueType (String elementName)
 871   {
 872     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 873     NodeObject n = getNodeObject (node);
 874
 875     if (n == null)
 876       return IIOMetadataFormat.VALUE_NONE;
 877     else
 878       return n.getValueType ();
 879   }
 880
 881   public boolean isAttributeRequired (String elementName, String attrName)
 882   {
 883     IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
 884     return ((IIOMetadataNodeAttr) node.getAttributeNode (attrName)).isRequired();
 885   }
 886 }