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 }