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