/*
* 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;
}
}