/[classpath]/classpath/javax/imageio/metadata/IIOMetadataFormatImpl.java
ViewVC logotype

Diff of /classpath/javax/imageio/metadata/IIOMetadataFormatImpl.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1.2.2 by gnu_andrew, Tue Aug 2 20:12:35 2005 UTC revision 1.1.2.3 by gnu_andrew, Wed Nov 2 00:43:39 2005 UTC
# Line 38  exception statement from your version. * Line 38  exception statement from your version. *
38    
39  package javax.imageio.metadata;  package javax.imageio.metadata;
40    
41    import org.w3c.dom.Attr;
42    import org.w3c.dom.DOMException;
43    import org.w3c.dom.Document;
44    import org.w3c.dom.Element;
45    import org.w3c.dom.NamedNodeMap;
46    import org.w3c.dom.Node;
47    import org.w3c.dom.NodeList;
48    import org.w3c.dom.TypeInfo;
49    import org.w3c.dom.UserDataHandler;
50    import java.util.ArrayList;
51    import java.util.HashMap;
52    import java.util.Map;
53    import java.util.Iterator;
54    import java.util.List;
55    import java.util.Locale;
56    import java.util.ResourceBundle;
57    import java.util.MissingResourceException;
58    import javax.imageio.ImageTypeSpecifier;
59    
60  public abstract class IIOMetadataFormatImpl implements IIOMetadataFormat  public abstract class IIOMetadataFormatImpl implements IIOMetadataFormat
61  {  {
62      /**
63       * The standard metadata format name constant set to
64       * "javax_imageio_1.0".
65       */
66      public static final String standardMetadataFormatName = "javax_imageio_1.0";
67    
68      private String rootName;
69    
70      // These maps assume that each element name is unique.
71    
72      private Map nodes = new HashMap();
73    
74      // A mapping from element name to child policy.
75      private Map childPolicies = new HashMap();
76    
77      // A mapping from element name to the permissible number of
78      // children.  Values in this map are length-two integer arrays; the
79      // first index is the minimum bound, the second index is the maximum
80      // bound.
81      private Map childRanges = new HashMap();
82    
83      private String resourceBaseName;
84    
85      // Package-private so that it may be used in IIOMetadataNode.
86      static class IIOMetadataNodeAttr extends IIOMetadataNode
87        implements Attr
88      {
89        protected Element owner;
90        protected String name;
91        protected int dataType;
92        protected boolean required;
93        protected String defaultValue;
94    
95        public IIOMetadataNodeAttr (Element owner,
96                                    String name,
97                                    String defaultValue)
98        {
99          this (owner, name, IIOMetadataFormat.DATATYPE_STRING,
100                true, defaultValue);
101        }
102    
103        public IIOMetadataNodeAttr (Element owner,
104                                    String name,
105                                    int dataType,
106                                    boolean required,
107                                    String defaultValue)
108        {
109          this.owner = owner;
110          this.name = name;
111          this.dataType = dataType;
112          this.required = required;
113          this.defaultValue = defaultValue;
114        }
115    
116        public String getName ()
117        {
118          return name;
119        }
120    
121        public Element getOwnerElement ()
122        {
123          return owner;
124        }
125    
126        public int getDataType ()
127        {
128          return dataType;
129        }
130    
131        public TypeInfo getSchemaTypeInfo ()
132        {
133          return null;
134        }
135    
136        public boolean getSpecified ()
137        {
138          return false;
139        }
140    
141        public String getValue ()
142        {
143          return defaultValue;
144        }
145    
146        public boolean isId()
147        {
148          return false;
149        }
150    
151        public void setValue (String value)
152        {
153        }
154    
155        // new methods
156    
157        public boolean isRequired ()
158        {
159          return required;
160        }
161      }
162    
163      private class IIOMetadataNodeAttrEnumerated extends IIOMetadataNodeAttr
164      {
165        protected List enumeratedValues;
166    
167        public IIOMetadataNodeAttrEnumerated (Element owner,
168                                              String name,
169                                              int dataType,
170                                              boolean required,
171                                              String defaultValue,
172                                              List enumeratedValues)
173        {
174          super (owner, name, dataType, required, defaultValue);
175          this.enumeratedValues = new ArrayList (enumeratedValues);
176        }
177    
178        public Object[] getEnumerations ()
179        {
180          return enumeratedValues.toArray ();
181        }
182      }
183    
184      private class IIOMetadataNodeAttrBounded extends IIOMetadataNodeAttr
185      {
186        protected String minValue;
187        protected String maxValue;
188        protected boolean minInclusive;
189        protected boolean maxInclusive;
190    
191        public IIOMetadataNodeAttrBounded (Element owner,
192                                           String name,
193                                           int dataType,
194                                           boolean required,
195                                           String defaultValue,
196                                           String minValue,
197                                           String maxValue,
198                                           boolean minInclusive,
199                                           boolean maxInclusive)
200        {
201          super (owner, name, dataType, required, defaultValue);
202          this.minValue = minValue;
203          this.maxValue = maxValue;
204          this.minInclusive = minInclusive;
205          this.maxInclusive = maxInclusive;
206        }
207    
208        public String getMinValue ()
209        {
210          return minValue;
211        }
212    
213        public String getMaxValue ()
214        {
215          return maxValue;
216        }
217      }
218    
219      private class IIOMetadataNodeAttrList extends IIOMetadataNodeAttr
220      {
221        protected int listMinLength;
222        protected int listMaxLength;
223    
224        public IIOMetadataNodeAttrList (Element owner,
225                                        String name,
226                                        int dataType,
227                                        boolean required,
228                                        int listMinLength,
229                                        int listMaxLength)
230        {
231          super (owner, name, dataType, required, null);
232          this.listMinLength = listMinLength;
233          this.listMaxLength = listMaxLength;
234        }
235    
236        public int getListMinLength ()
237        {
238          return listMinLength;
239        }
240    
241        public int getListMaxLength ()
242        {
243          return listMaxLength;
244        }
245      }
246    
247      private class NodeObject
248      {
249        protected Element owner;
250        protected Class classType;
251        protected boolean required;
252        protected Object defaultValue;
253        protected int valueType;
254    
255        public NodeObject (Element owner,
256                           Class classType,
257                           boolean required,
258                           Object defaultValue)
259        {
260          this.owner = owner;
261          this.classType = classType;
262          this.required = required;
263          this.defaultValue = defaultValue;
264          valueType = IIOMetadataFormat.VALUE_ARBITRARY;
265        }
266    
267        public int getValueType ()
268        {
269          return valueType;
270        }
271    
272        public Class getClassType ()
273        {
274          return classType;
275        }
276    
277        public Element getOwnerElement ()
278        {
279          return owner;
280        }
281    
282        public Object getDefaultValue ()
283        {
284          return defaultValue;
285        }
286    
287        public boolean isRequired ()
288        {
289          return required;
290        }
291      }
292    
293      private class NodeObjectEnumerated extends NodeObject
294      {
295        protected List enumeratedValues;
296    
297        public NodeObjectEnumerated (Element owner,
298                                     Class classType,
299                                     boolean required,
300                                     Object defaultValue,
301                                     List enumeratedValues)
302        {
303          super (owner, classType, false, defaultValue);
304          this.enumeratedValues = enumeratedValues;
305          valueType = IIOMetadataFormat.VALUE_ENUMERATION;
306        }
307    
308        public Object[] getEnumerations ()
309        {
310          return enumeratedValues.toArray();
311        }
312      }
313    
314      private class NodeObjectBounded extends NodeObject
315      {
316        protected Comparable minValue;
317        protected Comparable maxValue;
318        protected boolean minInclusive;
319        protected boolean maxInclusive;
320    
321        public NodeObjectBounded (Element owner,
322                                  Class classType,
323                                  Object defaultValue,
324                                  Comparable minValue,
325                                  Comparable maxValue,
326                                  boolean minInclusive,
327                                  boolean maxInclusive)
328        {
329          super (owner, classType, false, defaultValue);
330          this.minValue = minValue;
331          this.maxValue = maxValue;
332          this.minInclusive = minInclusive;
333          this.maxInclusive = maxInclusive;
334          if (minInclusive)
335            {
336              if (maxInclusive)
337                valueType = IIOMetadataFormat.VALUE_RANGE_MIN_MAX_INCLUSIVE;
338              else
339                valueType = IIOMetadataFormat.VALUE_RANGE_MIN_INCLUSIVE;
340            }
341          else
342            {
343              if (maxInclusive)
344                valueType = IIOMetadataFormat.VALUE_RANGE_MAX_INCLUSIVE;
345              else
346                valueType = IIOMetadataFormat.VALUE_RANGE;
347            }
348        }
349    
350        public Comparable getMinValue ()
351        {
352          return minValue;
353        }
354    
355        public Comparable getMaxValue ()
356        {
357          return maxValue;
358        }
359      }
360    
361      private class NodeObjectArray extends NodeObject
362      {
363        protected Integer arrayMinLength;
364        protected Integer arrayMaxLength;
365    
366        public NodeObjectArray (Element owner,
367                                Class classType,
368                                int arrayMinLength,
369                                int arrayMaxLength)
370        {
371          super (owner, classType, false, null);
372          this.arrayMinLength = new Integer (arrayMinLength);
373          this.arrayMaxLength = new Integer (arrayMaxLength);
374          valueType = IIOMetadataFormat.VALUE_LIST;
375        }
376    
377        public Comparable getArrayMinLength ()
378        {
379          return arrayMinLength;
380        }
381    
382        public Comparable getArrayMaxLength ()
383        {
384          return arrayMaxLength;
385        }
386      }
387    
388      /**
389       * Construct a blank IIOMetadataFormatImpl with the given root name
390       * and child policy.
391       *
392       * @param rootName the root element name
393       * @param childPolicy the child policy of the root element
394       *
395       * @exception IllegalArgumentException if rootName is null
396       * @exception IllegalArgumentException if childPolicy is
397       * CHILD_POLICY_REPEAT or if childPolicy is not a CHILD_POLICY
398       * constant
399       */
400      public IIOMetadataFormatImpl (String rootName, int childPolicy)
401      {
402        if (rootName == null)
403          throw new IllegalArgumentException ("null argument");
404    
405        if (childPolicy < IIOMetadataFormat.CHILD_POLICY_ALL
406            || childPolicy > IIOMetadataFormat.CHILD_POLICY_SOME
407            || childPolicy == IIOMetadataFormat.CHILD_POLICY_REPEAT)
408          throw new IllegalArgumentException ("wrong child policy");
409    
410        nodes.put (rootName, new IIOMetadataNode (rootName));
411        childPolicies.put (rootName, new Integer (childPolicy));
412        this.rootName = rootName;
413      }
414    
415      /**
416       * Construct a blank IIOMetadataFormatImpl with the given root name,
417       * a child policy of CHILD_POLICY_REPEAT and the given minimum and
418       * maximum limits on the number of root element children.
419       *
420       * @param rootName the root element name
421       * @param minChildren the minimum number of children that this node
422       * can have
423       * @param maxChildren the maximum number of children that this node
424       * can have
425       *
426       * @exception IllegalArgumentException if rootName is null
427       * @exception IllegalArgumentException if minChildren is less than
428       * zero or greater than maxChildren
429       */
430      public IIOMetadataFormatImpl (String rootName,
431                                    int minChildren,
432                                    int maxChildren)
433      {
434        if (rootName == null)
435          throw new IllegalArgumentException ("null argument");
436    
437        if (minChildren < 0 || maxChildren < minChildren)
438          throw new IllegalArgumentException ("invalid min or max children argument");
439    
440        nodes.put (rootName, new IIOMetadataNode (rootName));
441        childPolicies.put (rootName, new Integer (IIOMetadataFormat.CHILD_POLICY_REPEAT));
442        childRanges.put (rootName, new int [] { minChildren, maxChildren });
443        this.rootName = rootName;
444      }
445    
446      protected void addAttribute (String elementName,
447                                   String attrName,
448                                   int dataType,
449                                   boolean required,
450                                   String defaultValue)
451      {
452        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
453        node.setAttributeNode (new IIOMetadataNodeAttr (node,
454                                                        attrName,
455                                                        dataType,
456                                                        required,
457                                                        defaultValue));
458      }
459    
460      protected void addAttribute (String elementName,
461                                   String attrName,
462                                   int dataType,
463                                   boolean required,
464                                   String defaultValue,
465                                   List 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 void addObjectValue (String elementName, Class classType,
572                                     boolean required, Object 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 void addObjectValue (String elementName, Class classType,
582                                     boolean required, Object defaultValue,
583                                     List 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 void addObjectValue (String elementName, Class classType,
594                                     Object defaultValue,
595                                     Comparable minValue,
596                                     Comparable maxValue,
597                                     boolean minInclusive,
598                                     boolean maxInclusive)
599      {
600        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
601        addNodeObject (node, new NodeObjectBounded (node,
602                                                    classType,
603                                                    defaultValue,
604                                                    minValue,
605                                                    maxValue,
606                                                    minInclusive,
607                                                    maxInclusive));
608      }
609    
610      protected void addObjectValue (String elementName, Class classType,
611                                     int arrayMinLength, int arrayMaxLength)
612      {
613        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
614        addNodeObject (node, new NodeObjectArray (node,
615                                                  classType,
616                                                  arrayMinLength,
617                                                  arrayMaxLength));
618      }
619    
620      public String getRootName ()
621      {
622        return rootName;
623      }
624    
625      protected String getResourceBaseName ()
626      {
627        return resourceBaseName;
628      }
629    
630      public static IIOMetadataFormat getStandardFormatInstance ()
631      {
632        // FIXME: populate this with the standard metadata format
633        return new IIOMetadataFormatImpl (standardMetadataFormatName,
634                                          IIOMetadataFormat.CHILD_POLICY_ALL)
635          {
636            public boolean canNodeAppear (String elementName,
637                                          ImageTypeSpecifier specifier)
638            {
639              return true;
640            }
641          };
642      }
643    
644      public abstract boolean canNodeAppear (String elementName,
645                                             ImageTypeSpecifier specifier);
646    
647      protected void removeAttribute (String elementName,
648                                      String attrName)
649      {
650        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
651        node.removeAttribute (attrName);
652      }
653    
654      protected void removeElement (String elementName)
655      {
656        nodes.remove (elementName);
657      }
658    
659      protected void removeObjectValue (String elementName)
660      {
661        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
662        removeNodeObject (node);
663      }
664    
665      protected void setResourceBaseName (String resourceBaseName)
666      {
667        this.resourceBaseName = resourceBaseName;
668      }
669    
670      public int getAttributeDataType (String elementName, String attrName)
671      {
672        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
673        IIOMetadataNodeAttr attr = (IIOMetadataNodeAttr) node.getAttributeNode (attrName);
674        return attr.getDataType ();
675      }
676    
677      public String getAttributeDefaultValue (String elementName, String attrName)
678      {
679        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
680        IIOMetadataNodeAttr attr = (IIOMetadataNodeAttr) node.getAttributeNode (attrName);
681        return attr.getValue();
682      }
683    
684      public String getAttributeDescription (String elementName, String attrName, Locale locale)
685      {
686        return getDescription (elementName + "/" + attrName, locale);
687      }
688    
689      public String[] getAttributeEnumerations (String elementName, String attrName)
690      {
691        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
692        IIOMetadataNodeAttrEnumerated attr =
693          (IIOMetadataNodeAttrEnumerated) node.getAttributeNode (attrName);
694    
695        Object[] attrEnums = attr.getEnumerations();
696    
697        String[] attrNames = new String[attrEnums.length];
698    
699        for (int i = 0; i < attrEnums.length; i++)
700          {
701            attrNames[i] = (String) attrEnums[i];
702          }
703    
704        return attrNames;
705      }
706    
707      public int getAttributeListMaxLength (String elementName, String attrName)
708      {
709        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
710        IIOMetadataNodeAttrList attr =
711          (IIOMetadataNodeAttrList) node.getAttributeNode (attrName);
712        return attr.getListMaxLength();
713      }
714    
715      public int getAttributeListMinLength (String elementName, String attrName)
716      {
717        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
718        IIOMetadataNodeAttrList attr =
719          (IIOMetadataNodeAttrList) node.getAttributeNode (attrName);
720        return attr.getListMinLength();
721      }
722    
723      public String getAttributeMaxValue (String elementName, String attrName)
724      {
725        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
726        IIOMetadataNodeAttrBounded attr =
727          (IIOMetadataNodeAttrBounded) node.getAttributeNode (attrName);
728        return attr.getMaxValue();
729      }
730    
731      public String getAttributeMinValue (String elementName, String attrName)
732      {
733        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
734        IIOMetadataNodeAttrBounded attr =
735          (IIOMetadataNodeAttrBounded) node.getAttributeNode (attrName);
736        return attr.getMinValue();
737      }
738    
739      public String[] getAttributeNames (String elementName)
740      {
741        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
742    
743        NamedNodeMap attrNodes = node.getAttributes();
744    
745        String[] attrNames = new String[attrNodes.getLength()];
746    
747        for (int i = 0; i < attrNodes.getLength(); i++)
748          {
749            attrNames[i] = attrNodes.item (i).getLocalName();
750          }
751    
752        return attrNames;
753      }
754    
755      public int getAttributeValueType (String elementName, String attrName)
756      {
757        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
758        IIOMetadataNodeAttr attr = (IIOMetadataNodeAttr) node.getAttributeNode (attrName);
759        return attr.getDataType();
760      }
761    
762      public String[] getChildNames (String elementName)
763      {
764        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
765    
766        NodeList childNodes = node.getChildNodes();
767    
768        String[] childNames = new String[childNodes.getLength()];
769    
770        for (int i = 0; i < childNodes.getLength(); i++)
771          {
772            childNames[i] = childNodes.item (i).getLocalName();
773          }
774    
775        return childNames;
776      }
777    
778      public int getChildPolicy (String elementName)
779      {
780        return ((Integer) childPolicies.get (elementName)).intValue();
781      }
782    
783      private String getDescription (String resourceName, Locale locale)
784      {
785        if (resourceBaseName == null)
786          return null;
787    
788        Locale l = locale;
789    
790        if (l == null)
791          l = Locale.getDefault();
792    
793        ResourceBundle bundle = ResourceBundle.getBundle (resourceBaseName, locale);
794    
795        String desc = null;
796    
797        if (bundle == null)
798          {
799            try
800              {
801                desc = bundle.getString (resourceName);
802              }
803            catch (MissingResourceException e)
804              {
805                desc = null;
806              }
807          }
808    
809        return desc;
810      }
811    
812      public String getElementDescription (String elementName, Locale locale)
813      {
814        return getDescription (elementName, locale);
815      }
816    
817      public int getElementMaxChildren (String elementName)
818      {
819        return ((int[]) childRanges.get (elementName))[1];
820      }
821    
822      public int getElementMinChildren (String elementName)
823      {
824        return ((int[]) childRanges.get (elementName))[0];
825      }
826    
827      public int getObjectArrayMaxLength (String elementName)
828      {
829        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
830        return ((Integer) ((NodeObjectArray) getNodeObject (node)).getArrayMaxLength ()).intValue();
831      }
832    
833      public int getObjectArrayMinLength (String elementName)
834      {
835        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
836        return ((Integer) ((NodeObjectArray) getNodeObject (node)).getArrayMinLength ()).intValue();
837      }
838    
839      public Class getObjectClass (String elementName)
840      {
841        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
842        return getNodeObject (node).getClassType ();
843      }
844    
845      public Object getObjectDefaultValue (String elementName)
846      {
847        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
848        return getNodeObject (node).getDefaultValue ();
849      }
850    
851      public Object[] getObjectEnumerations (String elementName)
852      {
853        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
854        return ((NodeObjectEnumerated) getNodeObject (node)).getEnumerations ();
855      }
856    
857      public Comparable getObjectMaxValue (String elementName)
858      {
859        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
860        return ((NodeObjectBounded) getNodeObject (node)).getMaxValue ();
861      }
862    
863      public Comparable getObjectMinValue (String elementName)
864      {
865        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
866        return ((NodeObjectBounded) getNodeObject (node)).getMinValue ();
867      }
868    
869      public int getObjectValueType (String elementName)
870      {
871        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
872        NodeObject n = getNodeObject (node);
873    
874        if (n == null)
875          return IIOMetadataFormat.VALUE_NONE;
876        else
877          return n.getValueType ();
878      }
879    
880      public boolean isAttributeRequired (String elementName, String attrName)
881      {
882        IIOMetadataNode node = (IIOMetadataNode) nodes.get (elementName);
883        return ((IIOMetadataNodeAttr) node.getAttributeNode (attrName)).isRequired();
884      }
885  }  }

Legend:
Removed from v.1.1.2.2  
changed lines
  Added in v.1.1.2.3

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26