001    /* IIOMetadataFormatImpl.java --
002       Copyright (C) 2004  Free Software Foundation, Inc.
003    
004    This file is part of GNU Classpath.
005    
006    GNU Classpath is free software; you can redistribute it and/or modify
007    it under the terms of the GNU General Public License as published by
008    the Free Software Foundation; either version 2, or (at your option)
009    any later version.
010    
011    GNU Classpath is distributed in the hope that it will be useful, but
012    WITHOUT ANY WARRANTY; without even the implied warranty of
013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
014    General Public License for more details.
015    
016    You should have received a copy of the GNU General Public License
017    along with GNU Classpath; see the file COPYING.  If not, write to the
018    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
019    02110-1301 USA.
020    
021    Linking this library statically or dynamically with other modules is
022    making a combined work based on this library.  Thus, the terms and
023    conditions of the GNU General Public License cover the whole
024    combination.
025    
026    As a special exception, the copyright holders of this library give you
027    permission to link this library with independent modules to produce an
028    executable, regardless of the license terms of these independent
029    modules, and to copy and distribute the resulting executable under
030    terms of your choice, provided that you also meet, for each linked
031    independent module, the terms and conditions of the license of that
032    module.  An independent module is a module which is not derived from
033    or based on this library.  If you modify this library, you may extend
034    this exception to your version of the library, but you are not
035    obligated to do so.  If you do not wish to do so, delete this
036    exception statement from your version. */
037    
038    
039    package javax.imageio.metadata;
040    
041    import org.w3c.dom.Attr;
042    import org.w3c.dom.DOMException;
043    import org.w3c.dom.Document;
044    import org.w3c.dom.Element;
045    import org.w3c.dom.NamedNodeMap;
046    import org.w3c.dom.Node;
047    import org.w3c.dom.NodeList;
048    import org.w3c.dom.TypeInfo;
049    import org.w3c.dom.UserDataHandler;
050    import java.util.ArrayList;
051    import java.util.HashMap;
052    import java.util.Map;
053    import java.util.Iterator;
054    import java.util.List;
055    import java.util.Locale;
056    import java.util.ResourceBundle;
057    import java.util.MissingResourceException;
058    import javax.imageio.ImageTypeSpecifier;
059    
060    public abstract class IIOMetadataFormatImpl implements IIOMetadataFormat
061    {
062      /**
063       * The standard metadata format name constant set to
064       * "javax_imageio_1.0".
065       */
066      public static final String standardMetadataFormatName = "javax_imageio_1.0";
067    
068      private String rootName;
069    
070      // These maps assume that each element name is unique.
071    
072      private Map nodes = new HashMap();
073    
074      // A mapping from element name to child policy.
075      private Map childPolicies = new HashMap();
076    
077      // A mapping from element name to the permissible number of
078      // children.  Values in this map are length-two integer arrays; the
079      // first index is the minimum bound, the second index is the maximum
080      // bound.
081      private Map childRanges = new HashMap();
082    
083      private String resourceBaseName;
084    
085      // Package-private so that it may be used in IIOMetadataNode.
086      static class IIOMetadataNodeAttr extends IIOMetadataNode
087        implements Attr
088      {
089        protected Element owner;
090        protected String name;
091        protected int dataType;
092        protected boolean required;
093        protected String defaultValue;
094    
095        public IIOMetadataNodeAttr (Element owner,
096                                    String name,
097                                    String defaultValue)
098        {
099          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    }