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.Element;
043 import org.w3c.dom.NamedNodeMap;
044 import org.w3c.dom.NodeList;
045 import org.w3c.dom.TypeInfo;
046 import java.util.ArrayList;
047 import java.util.HashMap;
048 import java.util.Map;
049 import java.util.List;
050 import java.util.Locale;
051 import java.util.ResourceBundle;
052 import java.util.MissingResourceException;
053 import javax.imageio.ImageTypeSpecifier;
054
055 public 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 }