Java tutorial
/* * Copyright (c) 2000, 2014, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package javax.imageio.metadata; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Locale; import java.util.Map; import java.util.MissingResourceException; import java.util.ResourceBundle; import javax.imageio.ImageTypeSpecifier; import com.sun.imageio.plugins.common.StandardMetadataFormat; /** * A concrete class providing a reusable implementation of the * {@code IIOMetadataFormat} interface. In addition, a static * instance representing the standard, plug-in neutral * {@code javax_imageio_1.0} format is provided by the * {@code getStandardFormatInstance} method. * * <p> In order to supply localized descriptions of elements and * attributes, a {@code ResourceBundle} with a base name of * {@code this.getClass().getName() + "Resources"} should be * supplied via the usual mechanism used by * {@code ResourceBundle.getBundle}. Briefly, the subclasser * supplies one or more additional classes according to a naming * convention (by default, the fully-qualified name of the subclass * extending {@code IIMetadataFormatImpl}, plus the string * "Resources", plus the country, language, and variant codes * separated by underscores). At run time, calls to * {@code getElementDescription} or * {@code getAttributeDescription} will attempt to load such * classes dynamically according to the supplied locale, and will use * either the element name, or the element name followed by a '/' * character followed by the attribute name as a key. This key will * be supplied to the {@code ResourceBundle}'s * {@code getString} method, and the resulting localized * description of the node or attribute is returned. * * <p> The subclass may supply a different base name for the resource * bundles using the {@code setResourceBaseName} method. * * <p> A subclass may choose its own localization mechanism, if so * desired, by overriding the supplied implementations of * {@code getElementDescription} and * {@code getAttributeDescription}. * * @see ResourceBundle#getBundle(String,Locale) * */ public abstract class IIOMetadataFormatImpl implements IIOMetadataFormat { /** * A {@code String} constant containing the standard format * name, {@code "javax_imageio_1.0"}. */ public static final String standardMetadataFormatName = "javax_imageio_1.0"; private static IIOMetadataFormat standardFormat = null; private String resourceBaseName = this.getClass().getName() + "Resources"; private String rootName; // Element name (String) -> Element private HashMap<String, Element> elementMap = new HashMap<>(); class Element { String elementName; int childPolicy; int minChildren = 0; int maxChildren = 0; // Child names (Strings) List<String> childList = new ArrayList<>(); // Parent names (Strings) List<String> parentList = new ArrayList<>(); // List of attribute names in the order they were added List<String> attrList = new ArrayList<>(); // Attr name (String) -> Attribute Map<String, Attribute> attrMap = new HashMap<>(); ObjectValue<?> objectValue; } class Attribute { String attrName; int valueType = VALUE_ARBITRARY; int dataType; boolean required; String defaultValue = null; // enumeration List<String> enumeratedValues; // range String minValue; String maxValue; // list int listMinLength; int listMaxLength; } class ObjectValue<T> { int valueType = VALUE_NONE; // ? extends T So that ObjectValue<Object> can take Class<?> Class<? extends T> classType = null; T defaultValue = null; // Meaningful only if valueType == VALUE_ENUMERATION List<? extends T> enumeratedValues = null; // Meaningful only if valueType == VALUE_RANGE Comparable<? super T> minValue = null; Comparable<? super T> maxValue = null; // Meaningful only if valueType == VALUE_LIST int arrayMinLength = 0; int arrayMaxLength = 0; } /** * Constructs a blank {@code IIOMetadataFormatImpl} instance, * with a given root element name and child policy (other than * {@code CHILD_POLICY_REPEAT}). Additional elements, and * their attributes and {@code Object} reference information * may be added using the various {@code add} methods. * * @param rootName the name of the root element. * @param childPolicy one of the {@code CHILD_POLICY_*} constants, * other than {@code CHILD_POLICY_REPEAT}. * * @exception IllegalArgumentException if {@code rootName} is * {@code null}. * @exception IllegalArgumentException if {@code childPolicy} is * not one of the predefined constants. */ public IIOMetadataFormatImpl(String rootName, int childPolicy) { if (rootName == null) { throw new IllegalArgumentException("rootName == null!"); } if (childPolicy < CHILD_POLICY_EMPTY || childPolicy > CHILD_POLICY_MAX || childPolicy == CHILD_POLICY_REPEAT) { throw new IllegalArgumentException("Invalid value for childPolicy!"); } this.rootName = rootName; Element root = new Element(); root.elementName = rootName; root.childPolicy = childPolicy; elementMap.put(rootName, root); } /** * Constructs a blank {@code IIOMetadataFormatImpl} instance, * with a given root element name and a child policy of * {@code CHILD_POLICY_REPEAT}. Additional elements, and * their attributes and {@code Object} reference information * may be added using the various {@code add} methods. * * @param rootName the name of the root element. * @param minChildren the minimum number of children of the node. * @param maxChildren the maximum number of children of the node. * * @exception IllegalArgumentException if {@code rootName} is * {@code null}. * @exception IllegalArgumentException if {@code minChildren} * is negative or larger than {@code maxChildren}. */ public IIOMetadataFormatImpl(String rootName, int minChildren, int maxChildren) { if (rootName == null) { throw new IllegalArgumentException("rootName == null!"); } if (minChildren < 0) { throw new IllegalArgumentException("minChildren < 0!"); } if (minChildren > maxChildren) { throw new IllegalArgumentException("minChildren > maxChildren!"); } Element root = new Element(); root.elementName = rootName; root.childPolicy = CHILD_POLICY_REPEAT; root.minChildren = minChildren; root.maxChildren = maxChildren; this.rootName = rootName; elementMap.put(rootName, root); } /** * Sets a new base name for locating {@code ResourceBundle}s * containing descriptions of elements and attributes for this * format. * * <p> Prior to the first time this method is called, the base * name will be equal to * {@code this.getClass().getName() + "Resources"}. * * @param resourceBaseName a {@code String} containing the new * base name. * * @exception IllegalArgumentException if * {@code resourceBaseName} is {@code null}. * * @see #getResourceBaseName */ protected void setResourceBaseName(String resourceBaseName) { if (resourceBaseName == null) { throw new IllegalArgumentException("resourceBaseName == null!"); } this.resourceBaseName = resourceBaseName; } /** * Returns the currently set base name for locating * {@code ResourceBundle}s. * * @return a {@code String} containing the base name. * * @see #setResourceBaseName */ protected String getResourceBaseName() { return resourceBaseName; } /** * Utility method for locating an element. * * @param mustAppear if {@code true}, throw an * {@code IllegalArgumentException} if no such node exists; * if {@code false}, just return null. */ private Element getElement(String elementName, boolean mustAppear) { if (mustAppear && (elementName == null)) { throw new IllegalArgumentException("element name is null!"); } Element element = elementMap.get(elementName); if (mustAppear && (element == null)) { throw new IllegalArgumentException("No such element: " + elementName); } return element; } private Element getElement(String elementName) { return getElement(elementName, true); } // Utility method for locating an attribute private Attribute getAttribute(String elementName, String attrName) { Element element = getElement(elementName); Attribute attr = element.attrMap.get(attrName); if (attr == null) { throw new IllegalArgumentException("No such attribute \"" + attrName + "\"!"); } return attr; } // Setup /** * Adds a new element type to this metadata document format with a * child policy other than {@code CHILD_POLICY_REPEAT}. * * @param elementName the name of the new element. * @param parentName the name of the element that will be the * parent of the new element. * @param childPolicy one of the {@code CHILD_POLICY_*} * constants, other than {@code CHILD_POLICY_REPEAT}, * indicating the child policy of the new element. * * @exception IllegalArgumentException if {@code parentName} * is {@code null}, or is not a legal element name for this * format. * @exception IllegalArgumentException if {@code childPolicy} * is not one of the predefined constants. */ protected void addElement(String elementName, String parentName, int childPolicy) { Element parent = getElement(parentName); if (childPolicy < CHILD_POLICY_EMPTY || childPolicy > CHILD_POLICY_MAX || childPolicy == CHILD_POLICY_REPEAT) { throw new IllegalArgumentException("Invalid value for childPolicy!"); } Element element = new Element(); element.elementName = elementName; element.childPolicy = childPolicy; parent.childList.add(elementName); element.parentList.add(parentName); elementMap.put(elementName, element); } /** * Adds a new element type to this metadata document format with a * child policy of {@code CHILD_POLICY_REPEAT}. * * @param elementName the name of the new element. * @param parentName the name of the element that will be the * parent of the new element. * @param minChildren the minimum number of children of the node. * @param maxChildren the maximum number of children of the node. * * @exception IllegalArgumentException if {@code parentName} * is {@code null}, or is not a legal element name for this * format. * @exception IllegalArgumentException if {@code minChildren} * is negative or larger than {@code maxChildren}. */ protected void addElement(String elementName, String parentName, int minChildren, int maxChildren) { Element parent = getElement(parentName); if (minChildren < 0) { throw new IllegalArgumentException("minChildren < 0!"); } if (minChildren > maxChildren) { throw new IllegalArgumentException("minChildren > maxChildren!"); } Element element = new Element(); element.elementName = elementName; element.childPolicy = CHILD_POLICY_REPEAT; element.minChildren = minChildren; element.maxChildren = maxChildren; parent.childList.add(elementName); element.parentList.add(parentName); elementMap.put(elementName, element); } /** * Adds an existing element to the list of legal children for a * given parent node type. * * @param parentName the name of the element that will be the * new parent of the element. * @param elementName the name of the element to be added as a * child. * * @exception IllegalArgumentException if {@code elementName} * is {@code null}, or is not a legal element name for this * format. * @exception IllegalArgumentException if {@code parentName} * is {@code null}, or is not a legal element name for this * format. */ protected void addChildElement(String elementName, String parentName) { Element parent = getElement(parentName); Element element = getElement(elementName); parent.childList.add(elementName); element.parentList.add(parentName); } /** * Removes an element from the format. If no element with the * given name was present, nothing happens and no exception is * thrown. * * @param elementName the name of the element to be removed. */ protected void removeElement(String elementName) { Element element = getElement(elementName, false); if (element != null) { Iterator<String> iter = element.parentList.iterator(); while (iter.hasNext()) { String parentName = iter.next(); Element parent = getElement(parentName, false); if (parent != null) { parent.childList.remove(elementName); } } elementMap.remove(elementName); } } /** * Adds a new attribute to a previously defined element that may * be set to an arbitrary value. * * @param elementName the name of the element. * @param attrName the name of the attribute being added. * @param dataType the data type (string format) of the attribute, * one of the {@code DATATYPE_*} constants. * @param required {@code true} if the attribute must be present. * @param defaultValue the default value for the attribute, or * {@code null}. * * @exception IllegalArgumentException if {@code elementName} * is {@code null}, or is not a legal element name for this * format. * @exception IllegalArgumentException if {@code attrName} is * {@code null}. * @exception IllegalArgumentException if {@code dataType} is * not one of the predefined constants. */ protected void addAttribute(String elementName, String attrName, int dataType, boolean required, String defaultValue) { Element element = getElement(elementName); if (attrName == null) { throw new IllegalArgumentException("attrName == null!"); } if (dataType < DATATYPE_STRING || dataType > DATATYPE_DOUBLE) { throw new IllegalArgumentException("Invalid value for dataType!"); } Attribute attr = new Attribute(); attr.attrName = attrName; attr.valueType = VALUE_ARBITRARY; attr.dataType = dataType; attr.required = required; attr.defaultValue = defaultValue; element.attrList.add(attrName); element.attrMap.put(attrName, attr); } /** * Adds a new attribute to a previously defined element that will * be defined by a set of enumerated values. * * @param elementName the name of the element. * @param attrName the name of the attribute being added. * @param dataType the data type (string format) of the attribute, * one of the {@code DATATYPE_*} constants. * @param required {@code true} if the attribute must be present. * @param defaultValue the default value for the attribute, or * {@code null}. * @param enumeratedValues a {@code List} of * {@code String}s containing the legal values for the * attribute. * * @exception IllegalArgumentException if {@code elementName} * is {@code null}, or is not a legal element name for this * format. * @exception IllegalArgumentException if {@code attrName} is * {@code null}. * @exception IllegalArgumentException if {@code dataType} is * not one of the predefined constants. * @exception IllegalArgumentException if * {@code enumeratedValues} is {@code null}. * @exception IllegalArgumentException if * {@code enumeratedValues} does not contain at least one * entry. * @exception IllegalArgumentException if * {@code enumeratedValues} contains an element that is not a * {@code String} or is {@code null}. */ protected void addAttribute(String elementName, String attrName, int dataType, boolean required, String defaultValue, List<String> enumeratedValues) { Element element = getElement(elementName); if (attrName == null) { throw new IllegalArgumentException("attrName == null!"); } if (dataType < DATATYPE_STRING || dataType > DATATYPE_DOUBLE) { throw new IllegalArgumentException("Invalid value for dataType!"); } if (enumeratedValues == null) { throw new IllegalArgumentException("enumeratedValues == null!"); } if (enumeratedValues.size() == 0) { throw new IllegalArgumentException("enumeratedValues is empty!"); } Iterator<String> iter = enumeratedValues.iterator(); while (iter.hasNext()) { Object o = iter.next(); if (o == null) { throw new IllegalArgumentException("enumeratedValues contains a null!"); } if (!(o instanceof String)) { throw new IllegalArgumentException("enumeratedValues contains a non-String value!"); } } Attribute attr = new Attribute(); attr.attrName = attrName; attr.valueType = VALUE_ENUMERATION; attr.dataType = dataType; attr.required = required; attr.defaultValue = defaultValue; attr.enumeratedValues = enumeratedValues; element.attrList.add(attrName); element.attrMap.put(attrName, attr); } /** * Adds a new attribute to a previously defined element that will * be defined by a range of values. * * @param elementName the name of the element. * @param attrName the name of the attribute being added. * @param dataType the data type (string format) of the attribute, * one of the {@code DATATYPE_*} constants. * @param required {@code true} if the attribute must be present. * @param defaultValue the default value for the attribute, or * {@code null}. * @param minValue the smallest (inclusive or exclusive depending * on the value of {@code minInclusive}) legal value for the * attribute, as a {@code String}. * @param maxValue the largest (inclusive or exclusive depending * on the value of {@code minInclusive}) legal value for the * attribute, as a {@code String}. * @param minInclusive {@code true} if {@code minValue} * is inclusive. * @param maxInclusive {@code true} if {@code maxValue} * is inclusive. * * @exception IllegalArgumentException if {@code elementName} * is {@code null}, or is not a legal element name for this * format. * @exception IllegalArgumentException if {@code attrName} is * {@code null}. * @exception IllegalArgumentException if {@code dataType} is * not one of the predefined constants. */ protected void addAttribute(String elementName, String attrName, int dataType, boolean required, String defaultValue, String minValue, String maxValue, boolean minInclusive, boolean maxInclusive) { Element element = getElement(elementName); if (attrName == null) { throw new IllegalArgumentException("attrName == null!"); } if (dataType < DATATYPE_STRING || dataType > DATATYPE_DOUBLE) { throw new IllegalArgumentException("Invalid value for dataType!"); } Attribute attr = new Attribute(); attr.attrName = attrName; attr.valueType = VALUE_RANGE; if (minInclusive) { attr.valueType |= VALUE_RANGE_MIN_INCLUSIVE_MASK; } if (maxInclusive) { attr.valueType |= VALUE_RANGE_MAX_INCLUSIVE_MASK; } attr.dataType = dataType; attr.required = required; attr.defaultValue = defaultValue; attr.minValue = minValue; attr.maxValue = maxValue; element.attrList.add(attrName); element.attrMap.put(attrName, attr); } /** * Adds a new attribute to a previously defined element that will * be defined by a list of values. * * @param elementName the name of the element. * @param attrName the name of the attribute being added. * @param dataType the data type (string format) of the attribute, * one of the {@code DATATYPE_*} constants. * @param required {@code true} if the attribute must be present. * @param listMinLength the smallest legal number of list items. * @param listMaxLength the largest legal number of list items. * * @exception IllegalArgumentException if {@code elementName} * is {@code null}, or is not a legal element name for this * format. * @exception IllegalArgumentException if {@code attrName} is * {@code null}. * @exception IllegalArgumentException if {@code dataType} is * not one of the predefined constants. * @exception IllegalArgumentException if * {@code listMinLength} is negative or larger than * {@code listMaxLength}. */ protected void addAttribute(String elementName, String attrName, int dataType, boolean required, int listMinLength, int listMaxLength) { Element element = getElement(elementName); if (attrName == null) { throw new IllegalArgumentException("attrName == null!"); } if (dataType < DATATYPE_STRING || dataType > DATATYPE_DOUBLE) { throw new IllegalArgumentException("Invalid value for dataType!"); } if (listMinLength < 0 || listMinLength > listMaxLength) { throw new IllegalArgumentException("Invalid list bounds!"); } Attribute attr = new Attribute(); attr.attrName = attrName; attr.valueType = VALUE_LIST; attr.dataType = dataType; attr.required = required; attr.listMinLength = listMinLength; attr.listMaxLength = listMaxLength; element.attrList.add(attrName); element.attrMap.put(attrName, attr); } /** * Adds a new attribute to a previously defined element that will * be defined by the enumerated values {@code TRUE} and * {@code FALSE}, with a datatype of * {@code DATATYPE_BOOLEAN}. * * @param elementName the name of the element. * @param attrName the name of the attribute being added. * @param hasDefaultValue {@code true} if a default value * should be present. * @param defaultValue the default value for the attribute as a * {@code boolean}, ignored if {@code hasDefaultValue} * is {@code false}. * * @exception IllegalArgumentException if {@code elementName} * is {@code null}, or is not a legal element name for this * format. * @exception IllegalArgumentException if {@code attrName} is * {@code null}. */ protected void addBooleanAttribute(String elementName, String attrName, boolean hasDefaultValue, boolean defaultValue) { List<String> values = new ArrayList<>(); values.add("TRUE"); values.add("FALSE"); String dval = null; if (hasDefaultValue) { dval = defaultValue ? "TRUE" : "FALSE"; } addAttribute(elementName, attrName, DATATYPE_BOOLEAN, true, dval, values); } /** * Removes an attribute from a previously defined element. If no * attribute with the given name was present in the given element, * nothing happens and no exception is thrown. * * @param elementName the name of the element. * @param attrName the name of the attribute being removed. * * @exception IllegalArgumentException if {@code elementName} * is {@code null}, or is not a legal element name for this format. */ protected void removeAttribute(String elementName, String attrName) { Element element = getElement(elementName); element.attrList.remove(attrName); element.attrMap.remove(attrName); } /** * Allows an {@code Object} reference of a given class type * to be stored in nodes implementing the named element. The * value of the {@code Object} is unconstrained other than by * its class type. * * <p> If an {@code Object} reference was previously allowed, * the previous settings are overwritten. * * @param elementName the name of the element. * @param classType a {@code Class} variable indicating the * legal class type for the object value. * @param required {@code true} if an object value must be present. * @param defaultValue the default value for the * {@code Object} reference, or {@code null}. * @param <T> the type of the object. * * @exception IllegalArgumentException if {@code elementName} * is {@code null}, or is not a legal element name for this format. */ protected <T> void addObjectValue(String elementName, Class<T> classType, boolean required, T defaultValue) { Element element = getElement(elementName); ObjectValue<T> obj = new ObjectValue<>(); obj.valueType = VALUE_ARBITRARY; obj.classType = classType; obj.defaultValue = defaultValue; element.objectValue = obj; } /** * Allows an {@code Object} reference of a given class type * to be stored in nodes implementing the named element. The * value of the {@code Object} must be one of the values * given by {@code enumeratedValues}. * * <p> If an {@code Object} reference was previously allowed, * the previous settings are overwritten. * * @param elementName the name of the element. * @param classType a {@code Class} variable indicating the * legal class type for the object value. * @param required {@code true} if an object value must be present. * @param defaultValue the default value for the * {@code Object} reference, or {@code null}. * @param enumeratedValues a {@code List} of * {@code Object}s containing the legal values for the * object reference. * @param <T> the type of the object. * * @exception IllegalArgumentException if {@code elementName} * is {@code null}, or is not a legal element name for this format. * @exception IllegalArgumentException if * {@code enumeratedValues} is {@code null}. * @exception IllegalArgumentException if * {@code enumeratedValues} does not contain at least one * entry. * @exception IllegalArgumentException if * {@code enumeratedValues} contains an element that is not * an instance of the class type denoted by {@code classType} * or is {@code null}. */ protected <T> void addObjectValue(String elementName, Class<T> classType, boolean required, T defaultValue, List<? extends T> enumeratedValues) { Element element = getElement(elementName); if (enumeratedValues == null) { throw new IllegalArgumentException("enumeratedValues == null!"); } if (enumeratedValues.size() == 0) { throw new IllegalArgumentException("enumeratedValues is empty!"); } Iterator<? extends T> iter = enumeratedValues.iterator(); while (iter.hasNext()) { Object o = iter.next(); if (o == null) { throw new IllegalArgumentException("enumeratedValues contains a null!"); } if (!classType.isInstance(o)) { throw new IllegalArgumentException("enumeratedValues contains a value not of class classType!"); } } ObjectValue<T> obj = new ObjectValue<>(); obj.valueType = VALUE_ENUMERATION; obj.classType = classType; obj.defaultValue = defaultValue; obj.enumeratedValues = enumeratedValues; element.objectValue = obj; } /** * Allows an {@code Object} reference of a given class type * to be stored in nodes implementing the named element. The * value of the {@code Object} must be within the range given * by {@code minValue} and {@code maxValue}. * Furthermore, the class type must implement the * {@code Comparable} interface. * * <p> If an {@code Object} reference was previously allowed, * the previous settings are overwritten. * * @param elementName the name of the element. * @param classType a {@code Class} variable indicating the * legal class type for the object value. * @param defaultValue the default value for the * @param minValue the smallest (inclusive or exclusive depending * on the value of {@code minInclusive}) legal value for the * object value, as a {@code String}. * @param maxValue the largest (inclusive or exclusive depending * on the value of {@code minInclusive}) legal value for the * object value, as a {@code String}. * @param minInclusive {@code true} if {@code minValue} * is inclusive. * @param maxInclusive {@code true} if {@code maxValue} * is inclusive. * @param <T> the type of the object. * * @exception IllegalArgumentException if {@code elementName} * is {@code null}, or is not a legal element name for this * format. */ protected <T extends Object & Comparable<? super T>> void addObjectValue(String elementName, Class<T> classType, T defaultValue, Comparable<? super T> minValue, Comparable<? super T> maxValue, boolean minInclusive, boolean maxInclusive) { Element element = getElement(elementName); ObjectValue<T> obj = new ObjectValue<>(); obj.valueType = VALUE_RANGE; if (minInclusive) { obj.valueType |= VALUE_RANGE_MIN_INCLUSIVE_MASK; } if (maxInclusive) { obj.valueType |= VALUE_RANGE_MAX_INCLUSIVE_MASK; } obj.classType = classType; obj.defaultValue = defaultValue; obj.minValue = minValue; obj.maxValue = maxValue; element.objectValue = obj; } /** * Allows an {@code Object} reference of a given class type * to be stored in nodes implementing the named element. The * value of the {@code Object} must an array of objects of * class type given by {@code classType}, with at least * {@code arrayMinLength} and at most * {@code arrayMaxLength} elements. * * <p> If an {@code Object} reference was previously allowed, * the previous settings are overwritten. * * @param elementName the name of the element. * @param classType a {@code Class} variable indicating the * legal class type for the object value. * @param arrayMinLength the smallest legal length for the array. * @param arrayMaxLength the largest legal length for the array. * * @exception IllegalArgumentException if {@code elementName} is * not a legal element name for this format. */ protected void addObjectValue(String elementName, Class<?> classType, int arrayMinLength, int arrayMaxLength) { Element element = getElement(elementName); ObjectValue<Object> obj = new ObjectValue<>(); obj.valueType = VALUE_LIST; obj.classType = classType; obj.arrayMinLength = arrayMinLength; obj.arrayMaxLength = arrayMaxLength; element.objectValue = obj; } /** * Disallows an {@code Object} reference from being stored in * nodes implementing the named element. * * @param elementName the name of the element. * * @exception IllegalArgumentException if {@code elementName} is * not a legal element name for this format. */ protected void removeObjectValue(String elementName) { Element element = getElement(elementName); element.objectValue = null; } // Utility method // Methods from IIOMetadataFormat // Root public String getRootName() { return rootName; } // Multiplicity public abstract boolean canNodeAppear(String elementName, ImageTypeSpecifier imageType); public int getElementMinChildren(String elementName) { Element element = getElement(elementName); if (element.childPolicy != CHILD_POLICY_REPEAT) { throw new IllegalArgumentException("Child policy not CHILD_POLICY_REPEAT!"); } return element.minChildren; } public int getElementMaxChildren(String elementName) { Element element = getElement(elementName); if (element.childPolicy != CHILD_POLICY_REPEAT) { throw new IllegalArgumentException("Child policy not CHILD_POLICY_REPEAT!"); } return element.maxChildren; } private String getResource(String key, Locale locale) { if (locale == null) { locale = Locale.getDefault(); } /** * Per the class documentation, resource bundles, including localized ones * are intended to be delivered by the subclasser - ie supplier of the * metadataformat. For the standard format and all standard plugins that * is the JDK. For 3rd party plugins that they will supply their own. * This includes plugins bundled with applets/applications. * In all cases this means it is sufficient to search for those resource * in the module that is providing the MetadataFormatImpl subclass. */ try { ResourceBundle bundle = ResourceBundle.getBundle(resourceBaseName, locale, this.getClass().getModule()); return bundle.getString(key); } catch (MissingResourceException e) { return null; } } /** * Returns a {@code String} containing a description of the * named element, or {@code null}. The description will be * localized for the supplied {@code Locale} if possible. * * <p> The default implementation will first locate a * {@code ResourceBundle} using the current resource base * name set by {@code setResourceBaseName} and the supplied * {@code Locale}, using the fallback mechanism described in * the comments for {@code ResourceBundle.getBundle}. If a * {@code ResourceBundle} is found, the element name will be * used as a key to its {@code getString} method, and the * result returned. If no {@code ResourceBundle} is found, * or no such key is present, {@code null} will be returned. * * <p> If {@code locale} is {@code null}, the current * default {@code Locale} returned by {@code Locale.getLocale} * will be used. * * @param elementName the name of the element. * @param locale the {@code Locale} for which localization * will be attempted. * * @return the element description. * * @exception IllegalArgumentException if {@code elementName} * is {@code null}, or is not a legal element name for this format. * * @see #setResourceBaseName */ public String getElementDescription(String elementName, Locale locale) { Element element = getElement(elementName); return getResource(elementName, locale); } // Children public int getChildPolicy(String elementName) { Element element = getElement(elementName); return element.childPolicy; } public String[] getChildNames(String elementName) { Element element = getElement(elementName); if (element.childPolicy == CHILD_POLICY_EMPTY) { return null; } return element.childList.toArray(new String[0]); } // Attributes public String[] getAttributeNames(String elementName) { Element element = getElement(elementName); List<String> names = element.attrList; String[] result = new String[names.size()]; return names.toArray(result); } public int getAttributeValueType(String elementName, String attrName) { Attribute attr = getAttribute(elementName, attrName); return attr.valueType; } public int getAttributeDataType(String elementName, String attrName) { Attribute attr = getAttribute(elementName, attrName); return attr.dataType; } public boolean isAttributeRequired(String elementName, String attrName) { Attribute attr = getAttribute(elementName, attrName); return attr.required; } public String getAttributeDefaultValue(String elementName, String attrName) { Attribute attr = getAttribute(elementName, attrName); return attr.defaultValue; } public String[] getAttributeEnumerations(String elementName, String attrName) { Attribute attr = getAttribute(elementName, attrName); if (attr.valueType != VALUE_ENUMERATION) { throw new IllegalArgumentException("Attribute not an enumeration!"); } List<String> values = attr.enumeratedValues; String[] result = new String[values.size()]; return values.toArray(result); } public String getAttributeMinValue(String elementName, String attrName) { Attribute attr = getAttribute(elementName, attrName); if (attr.valueType != VALUE_RANGE && attr.valueType != VALUE_RANGE_MIN_INCLUSIVE && attr.valueType != VALUE_RANGE_MAX_INCLUSIVE && attr.valueType != VALUE_RANGE_MIN_MAX_INCLUSIVE) { throw new IllegalArgumentException("Attribute not a range!"); } return attr.minValue; } public String getAttributeMaxValue(String elementName, String attrName) { Attribute attr = getAttribute(elementName, attrName); if (attr.valueType != VALUE_RANGE && attr.valueType != VALUE_RANGE_MIN_INCLUSIVE && attr.valueType != VALUE_RANGE_MAX_INCLUSIVE && attr.valueType != VALUE_RANGE_MIN_MAX_INCLUSIVE) { throw new IllegalArgumentException("Attribute not a range!"); } return attr.maxValue; } public int getAttributeListMinLength(String elementName, String attrName) { Attribute attr = getAttribute(elementName, attrName); if (attr.valueType != VALUE_LIST) { throw new IllegalArgumentException("Attribute not a list!"); } return attr.listMinLength; } public int getAttributeListMaxLength(String elementName, String attrName) { Attribute attr = getAttribute(elementName, attrName); if (attr.valueType != VALUE_LIST) { throw new IllegalArgumentException("Attribute not a list!"); } return attr.listMaxLength; } /** * Returns a {@code String} containing a description of the * named attribute, or {@code null}. The description will be * localized for the supplied {@code Locale} if possible. * * <p> The default implementation will first locate a * {@code ResourceBundle} using the current resource base * name set by {@code setResourceBaseName} and the supplied * {@code Locale}, using the fallback mechanism described in * the comments for {@code ResourceBundle.getBundle}. If a * {@code ResourceBundle} is found, the element name followed * by a "/" character followed by the attribute name * ({@code elementName + "/" + attrName}) will be used as a * key to its {@code getString} method, and the result * returned. If no {@code ResourceBundle} is found, or no * such key is present, {@code null} will be returned. * * <p> If {@code locale} is {@code null}, the current * default {@code Locale} returned by {@code Locale.getLocale} * will be used. * * @param elementName the name of the element. * @param attrName the name of the attribute. * @param locale the {@code Locale} for which localization * will be attempted, or {@code null}. * * @return the attribute description. * * @exception IllegalArgumentException if {@code elementName} * is {@code null}, or is not a legal element name for this format. * @exception IllegalArgumentException if {@code attrName} is * {@code null} or is not a legal attribute name for this * element. * * @see #setResourceBaseName */ public String getAttributeDescription(String elementName, String attrName, Locale locale) { Element element = getElement(elementName); if (attrName == null) { throw new IllegalArgumentException("attrName == null!"); } Attribute attr = element.attrMap.get(attrName); if (attr == null) { throw new IllegalArgumentException("No such attribute!"); } String key = elementName + "/" + attrName; return getResource(key, locale); } private ObjectValue<?> getObjectValue(String elementName) { Element element = getElement(elementName); ObjectValue<?> objv = element.objectValue; if (objv == null) { throw new IllegalArgumentException("No object within element " + elementName + "!"); } return objv; } public int getObjectValueType(String elementName) { Element element = getElement(elementName); ObjectValue<?> objv = element.objectValue; if (objv == null) { return VALUE_NONE; } return objv.valueType; } public Class<?> getObjectClass(String elementName) { ObjectValue<?> objv = getObjectValue(elementName); return objv.classType; } public Object getObjectDefaultValue(String elementName) { ObjectValue<?> objv = getObjectValue(elementName); return objv.defaultValue; } public Object[] getObjectEnumerations(String elementName) { ObjectValue<?> objv = getObjectValue(elementName); if (objv.valueType != VALUE_ENUMERATION) { throw new IllegalArgumentException("Not an enumeration!"); } List<?> vlist = objv.enumeratedValues; Object[] values = new Object[vlist.size()]; return vlist.toArray(values); } public Comparable<?> getObjectMinValue(String elementName) { ObjectValue<?> objv = getObjectValue(elementName); if ((objv.valueType & VALUE_RANGE) != VALUE_RANGE) { throw new IllegalArgumentException("Not a range!"); } return objv.minValue; } public Comparable<?> getObjectMaxValue(String elementName) { ObjectValue<?> objv = getObjectValue(elementName); if ((objv.valueType & VALUE_RANGE) != VALUE_RANGE) { throw new IllegalArgumentException("Not a range!"); } return objv.maxValue; } public int getObjectArrayMinLength(String elementName) { ObjectValue<?> objv = getObjectValue(elementName); if (objv.valueType != VALUE_LIST) { throw new IllegalArgumentException("Not a list!"); } return objv.arrayMinLength; } public int getObjectArrayMaxLength(String elementName) { ObjectValue<?> objv = getObjectValue(elementName); if (objv.valueType != VALUE_LIST) { throw new IllegalArgumentException("Not a list!"); } return objv.arrayMaxLength; } // Standard format descriptor private static synchronized void createStandardFormat() { if (standardFormat == null) { standardFormat = new StandardMetadataFormat(); } } /** * Returns an {@code IIOMetadataFormat} object describing the * standard, plug-in neutral {@code javax.imageio_1.0} * metadata document format described in the comment of the * {@code javax.imageio.metadata} package. * * @return a predefined {@code IIOMetadataFormat} instance. */ public static IIOMetadataFormat getStandardFormatInstance() { createStandardFormat(); return standardFormat; } }