You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1274 lines
47 KiB
1274 lines
47 KiB
/*
|
|
* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
|
|
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</code> interface. In addition, a static
|
|
* instance representing the standard, plug-in neutral
|
|
* <code>javax_imageio_1.0</code> format is provided by the
|
|
* <code>getStandardFormatInstance</code> method.
|
|
*
|
|
* <p> In order to supply localized descriptions of elements and
|
|
* attributes, a <code>ResourceBundle</code> with a base name of
|
|
* <code>this.getClass().getName() + "Resources"</code> should be
|
|
* supplied via the usual mechanism used by
|
|
* <code>ResourceBundle.getBundle</code>. 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</code>, plus the string
|
|
* "Resources", plus the country, language, and variant codes
|
|
* separated by underscores). At run time, calls to
|
|
* <code>getElementDescription</code> or
|
|
* <code>getAttributeDescription</code> 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</code>'s
|
|
* <code>getString</code> 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</code> method.
|
|
*
|
|
* <p> A subclass may choose its own localization mechanism, if so
|
|
* desired, by overriding the supplied implementations of
|
|
* <code>getElementDescription</code> and
|
|
* <code>getAttributeDescription</code>.
|
|
*
|
|
* @see ResourceBundle#getBundle(String,Locale)
|
|
*
|
|
*/
|
|
public abstract class IIOMetadataFormatImpl implements IIOMetadataFormat {
|
|
|
|
/**
|
|
* A <code>String</code> constant containing the standard format
|
|
* name, <code>"javax_imageio_1.0"</code>.
|
|
*/
|
|
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 elementMap = new HashMap();
|
|
|
|
class Element {
|
|
String elementName;
|
|
|
|
int childPolicy;
|
|
int minChildren = 0;
|
|
int maxChildren = 0;
|
|
|
|
// Child names (Strings)
|
|
List childList = new ArrayList();
|
|
|
|
// Parent names (Strings)
|
|
List parentList = new ArrayList();
|
|
|
|
// List of attribute names in the order they were added
|
|
List attrList = new ArrayList();
|
|
// Attr name (String) -> Attribute
|
|
Map attrMap = new HashMap();
|
|
|
|
ObjectValue objectValue;
|
|
}
|
|
|
|
class Attribute {
|
|
String attrName;
|
|
|
|
int valueType = VALUE_ARBITRARY;
|
|
int dataType;
|
|
boolean required;
|
|
String defaultValue = null;
|
|
|
|
// enumeration
|
|
List enumeratedValues;
|
|
|
|
// range
|
|
String minValue;
|
|
String maxValue;
|
|
|
|
// list
|
|
int listMinLength;
|
|
int listMaxLength;
|
|
}
|
|
|
|
class ObjectValue {
|
|
int valueType = VALUE_NONE;
|
|
Class classType = null;
|
|
Object defaultValue = null;
|
|
|
|
// Meaningful only if valueType == VALUE_ENUMERATION
|
|
List enumeratedValues = null;
|
|
|
|
// Meaningful only if valueType == VALUE_RANGE
|
|
Comparable minValue = null;
|
|
Comparable maxValue = null;
|
|
|
|
// Meaningful only if valueType == VALUE_LIST
|
|
int arrayMinLength = 0;
|
|
int arrayMaxLength = 0;
|
|
}
|
|
|
|
/**
|
|
* Constructs a blank <code>IIOMetadataFormatImpl</code> instance,
|
|
* with a given root element name and child policy (other than
|
|
* <code>CHILD_POLICY_REPEAT</code>). Additional elements, and
|
|
* their attributes and <code>Object</code> reference information
|
|
* may be added using the various <code>add</code> methods.
|
|
*
|
|
* @param rootName the name of the root element.
|
|
* @param childPolicy one of the <code>CHILD_POLICY_*</code> constants,
|
|
* other than <code>CHILD_POLICY_REPEAT</code>.
|
|
*
|
|
* @exception IllegalArgumentException if <code>rootName</code> is
|
|
* <code>null</code>.
|
|
* @exception IllegalArgumentException if <code>childPolicy</code> 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</code> instance,
|
|
* with a given root element name and a child policy of
|
|
* <code>CHILD_POLICY_REPEAT</code>. Additional elements, and
|
|
* their attributes and <code>Object</code> reference information
|
|
* may be added using the various <code>add</code> 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</code> is
|
|
* <code>null</code>.
|
|
* @exception IllegalArgumentException if <code>minChildren</code>
|
|
* is negative or larger than <code>maxChildren</code>.
|
|
*/
|
|
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</code>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"</code>.
|
|
*
|
|
* @param resourceBaseName a <code>String</code> containing the new
|
|
* base name.
|
|
*
|
|
* @exception IllegalArgumentException if
|
|
* <code>resourceBaseName</code> is <code>null</code>.
|
|
*
|
|
* @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</code>s.
|
|
*
|
|
* @return a <code>String</code> containing the base name.
|
|
*
|
|
* @see #setResourceBaseName
|
|
*/
|
|
protected String getResourceBaseName() {
|
|
return resourceBaseName;
|
|
}
|
|
|
|
/**
|
|
* Utility method for locating an element.
|
|
*
|
|
* @param mustAppear if <code>true</code>, throw an
|
|
* <code>IllegalArgumentException</code> if no such node exists;
|
|
* if <code>false</code>, just return null.
|
|
*/
|
|
private Element getElement(String elementName, boolean mustAppear) {
|
|
if (mustAppear && (elementName == null)) {
|
|
throw new IllegalArgumentException("element name is null!");
|
|
}
|
|
Element 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 = (Attribute)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</code>.
|
|
*
|
|
* @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_*</code>
|
|
* constants, other than <code>CHILD_POLICY_REPEAT</code>,
|
|
* indicating the child policy of the new element.
|
|
*
|
|
* @exception IllegalArgumentException if <code>parentName</code>
|
|
* is <code>null</code>, or is not a legal element name for this
|
|
* format.
|
|
* @exception IllegalArgumentException if <code>childPolicy</code>
|
|
* 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</code>.
|
|
*
|
|
* @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</code>
|
|
* is <code>null</code>, or is not a legal element name for this
|
|
* format.
|
|
* @exception IllegalArgumentException if <code>minChildren</code>
|
|
* is negative or larger than <code>maxChildren</code>.
|
|
*/
|
|
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</code>
|
|
* is <code>null</code>, or is not a legal element name for this
|
|
* format.
|
|
* @exception IllegalArgumentException if <code>parentName</code>
|
|
* is <code>null</code>, 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 iter = element.parentList.iterator();
|
|
while (iter.hasNext()) {
|
|
String parentName = (String)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_*</code> constants.
|
|
* @param required <code>true</code> if the attribute must be present.
|
|
* @param defaultValue the default value for the attribute, or
|
|
* <code>null</code>.
|
|
*
|
|
* @exception IllegalArgumentException if <code>elementName</code>
|
|
* is <code>null</code>, or is not a legal element name for this
|
|
* format.
|
|
* @exception IllegalArgumentException if <code>attrName</code> is
|
|
* <code>null</code>.
|
|
* @exception IllegalArgumentException if <code>dataType</code> 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_*</code> constants.
|
|
* @param required <code>true</code> if the attribute must be present.
|
|
* @param defaultValue the default value for the attribute, or
|
|
* <code>null</code>.
|
|
* @param enumeratedValues a <code>List</code> of
|
|
* <code>String</code>s containing the legal values for the
|
|
* attribute.
|
|
*
|
|
* @exception IllegalArgumentException if <code>elementName</code>
|
|
* is <code>null</code>, or is not a legal element name for this
|
|
* format.
|
|
* @exception IllegalArgumentException if <code>attrName</code> is
|
|
* <code>null</code>.
|
|
* @exception IllegalArgumentException if <code>dataType</code> is
|
|
* not one of the predefined constants.
|
|
* @exception IllegalArgumentException if
|
|
* <code>enumeratedValues</code> is <code>null</code>.
|
|
* @exception IllegalArgumentException if
|
|
* <code>enumeratedValues</code> does not contain at least one
|
|
* entry.
|
|
* @exception IllegalArgumentException if
|
|
* <code>enumeratedValues</code> contains an element that is not a
|
|
* <code>String</code> or is <code>null</code>.
|
|
*/
|
|
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 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_*</code> constants.
|
|
* @param required <code>true</code> if the attribute must be present.
|
|
* @param defaultValue the default value for the attribute, or
|
|
* <code>null</code>.
|
|
* @param minValue the smallest (inclusive or exclusive depending
|
|
* on the value of <code>minInclusive</code>) legal value for the
|
|
* attribute, as a <code>String</code>.
|
|
* @param maxValue the largest (inclusive or exclusive depending
|
|
* on the value of <code>minInclusive</code>) legal value for the
|
|
* attribute, as a <code>String</code>.
|
|
* @param minInclusive <code>true</code> if <code>minValue</code>
|
|
* is inclusive.
|
|
* @param maxInclusive <code>true</code> if <code>maxValue</code>
|
|
* is inclusive.
|
|
*
|
|
* @exception IllegalArgumentException if <code>elementName</code>
|
|
* is <code>null</code>, or is not a legal element name for this
|
|
* format.
|
|
* @exception IllegalArgumentException if <code>attrName</code> is
|
|
* <code>null</code>.
|
|
* @exception IllegalArgumentException if <code>dataType</code> 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_*</code> constants.
|
|
* @param required <code>true</code> 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</code>
|
|
* is <code>null</code>, or is not a legal element name for this
|
|
* format.
|
|
* @exception IllegalArgumentException if <code>attrName</code> is
|
|
* <code>null</code>.
|
|
* @exception IllegalArgumentException if <code>dataType</code> is
|
|
* not one of the predefined constants.
|
|
* @exception IllegalArgumentException if
|
|
* <code>listMinLength</code> is negative or larger than
|
|
* <code>listMaxLength</code>.
|
|
*/
|
|
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</code> and
|
|
* <code>FALSE</code>, with a datatype of
|
|
* <code>DATATYPE_BOOLEAN</code>.
|
|
*
|
|
* @param elementName the name of the element.
|
|
* @param attrName the name of the attribute being added.
|
|
* @param hasDefaultValue <code>true</code> if a default value
|
|
* should be present.
|
|
* @param defaultValue the default value for the attribute as a
|
|
* <code>boolean</code>, ignored if <code>hasDefaultValue</code>
|
|
* is <code>false</code>.
|
|
*
|
|
* @exception IllegalArgumentException if <code>elementName</code>
|
|
* is <code>null</code>, or is not a legal element name for this
|
|
* format.
|
|
* @exception IllegalArgumentException if <code>attrName</code> is
|
|
* <code>null</code>.
|
|
*/
|
|
protected void addBooleanAttribute(String elementName,
|
|
String attrName,
|
|
boolean hasDefaultValue,
|
|
boolean defaultValue) {
|
|
List 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</code>
|
|
* is <code>null</code>, 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</code> reference of a given class type
|
|
* to be stored in nodes implementing the named element. The
|
|
* value of the <code>Object</code> is unconstrained other than by
|
|
* its class type.
|
|
*
|
|
* <p> If an <code>Object</code> reference was previously allowed,
|
|
* the previous settings are overwritten.
|
|
*
|
|
* @param elementName the name of the element.
|
|
* @param classType a <code>Class</code> variable indicating the
|
|
* legal class type for the object value.
|
|
* @param required <code>true</code> if an object value must be present.
|
|
* @param defaultValue the default value for the
|
|
* <code>Object</code> reference, or <code>null</code>.
|
|
* @param <T> the type of the object.
|
|
*
|
|
* @exception IllegalArgumentException if <code>elementName</code>
|
|
* is <code>null</code>, 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 obj = new ObjectValue();
|
|
obj.valueType = VALUE_ARBITRARY;
|
|
obj.classType = classType;
|
|
obj.defaultValue = defaultValue;
|
|
|
|
element.objectValue = obj;
|
|
}
|
|
|
|
/**
|
|
* Allows an <code>Object</code> reference of a given class type
|
|
* to be stored in nodes implementing the named element. The
|
|
* value of the <code>Object</code> must be one of the values
|
|
* given by <code>enumeratedValues</code>.
|
|
*
|
|
* <p> If an <code>Object</code> reference was previously allowed,
|
|
* the previous settings are overwritten.
|
|
*
|
|
* @param elementName the name of the element.
|
|
* @param classType a <code>Class</code> variable indicating the
|
|
* legal class type for the object value.
|
|
* @param required <code>true</code> if an object value must be present.
|
|
* @param defaultValue the default value for the
|
|
* <code>Object</code> reference, or <code>null</code>.
|
|
* @param enumeratedValues a <code>List</code> of
|
|
* <code>Object</code>s containing the legal values for the
|
|
* object reference.
|
|
* @param <T> the type of the object.
|
|
*
|
|
* @exception IllegalArgumentException if <code>elementName</code>
|
|
* is <code>null</code>, or is not a legal element name for this format.
|
|
* @exception IllegalArgumentException if
|
|
* <code>enumeratedValues</code> is <code>null</code>.
|
|
* @exception IllegalArgumentException if
|
|
* <code>enumeratedValues</code> does not contain at least one
|
|
* entry.
|
|
* @exception IllegalArgumentException if
|
|
* <code>enumeratedValues</code> contains an element that is not
|
|
* an instance of the class type denoted by <code>classType</code>
|
|
* or is <code>null</code>.
|
|
*/
|
|
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 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 obj = new ObjectValue();
|
|
obj.valueType = VALUE_ENUMERATION;
|
|
obj.classType = classType;
|
|
obj.defaultValue = defaultValue;
|
|
obj.enumeratedValues = enumeratedValues;
|
|
|
|
element.objectValue = obj;
|
|
}
|
|
|
|
/**
|
|
* Allows an <code>Object</code> reference of a given class type
|
|
* to be stored in nodes implementing the named element. The
|
|
* value of the <code>Object</code> must be within the range given
|
|
* by <code>minValue</code> and <code>maxValue</code>.
|
|
* Furthermore, the class type must implement the
|
|
* <code>Comparable</code> interface.
|
|
*
|
|
* <p> If an <code>Object</code> reference was previously allowed,
|
|
* the previous settings are overwritten.
|
|
*
|
|
* @param elementName the name of the element.
|
|
* @param classType a <code>Class</code> 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</code>) legal value for the
|
|
* object value, as a <code>String</code>.
|
|
* @param maxValue the largest (inclusive or exclusive depending
|
|
* on the value of <code>minInclusive</code>) legal value for the
|
|
* object value, as a <code>String</code>.
|
|
* @param minInclusive <code>true</code> if <code>minValue</code>
|
|
* is inclusive.
|
|
* @param maxInclusive <code>true</code> if <code>maxValue</code>
|
|
* is inclusive.
|
|
* @param <T> the type of the object.
|
|
*
|
|
* @exception IllegalArgumentException if <code>elementName</code>
|
|
* is <code>null</code>, 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 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</code> reference of a given class type
|
|
* to be stored in nodes implementing the named element. The
|
|
* value of the <code>Object</code> must an array of objects of
|
|
* class type given by <code>classType</code>, with at least
|
|
* <code>arrayMinLength</code> and at most
|
|
* <code>arrayMaxLength</code> elements.
|
|
*
|
|
* <p> If an <code>Object</code> reference was previously allowed,
|
|
* the previous settings are overwritten.
|
|
*
|
|
* @param elementName the name of the element.
|
|
* @param classType a <code>Class</code> 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</code> 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 obj = new ObjectValue();
|
|
obj.valueType = VALUE_LIST;
|
|
obj.classType = classType;
|
|
obj.arrayMinLength = arrayMinLength;
|
|
obj.arrayMaxLength = arrayMaxLength;
|
|
|
|
element.objectValue = obj;
|
|
}
|
|
|
|
/**
|
|
* Disallows an <code>Object</code> reference from being stored in
|
|
* nodes implementing the named element.
|
|
*
|
|
* @param elementName the name of the element.
|
|
*
|
|
* @exception IllegalArgumentException if <code>elementName</code> 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();
|
|
}
|
|
|
|
/**
|
|
* If an applet supplies an implementation of IIOMetadataFormat and
|
|
* resource bundles, then the resource bundle will need to be
|
|
* accessed via the applet class loader. So first try the context
|
|
* class loader to locate the resource bundle.
|
|
* If that throws MissingResourceException, then try the
|
|
* system class loader.
|
|
*/
|
|
ClassLoader loader = (ClassLoader)
|
|
java.security.AccessController.doPrivileged(
|
|
new java.security.PrivilegedAction() {
|
|
public Object run() {
|
|
return Thread.currentThread().getContextClassLoader();
|
|
}
|
|
});
|
|
|
|
ResourceBundle bundle = null;
|
|
try {
|
|
bundle = ResourceBundle.getBundle(resourceBaseName,
|
|
locale, loader);
|
|
} catch (MissingResourceException mre) {
|
|
try {
|
|
bundle = ResourceBundle.getBundle(resourceBaseName, locale);
|
|
} catch (MissingResourceException mre1) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
try {
|
|
return bundle.getString(key);
|
|
} catch (MissingResourceException e) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns a <code>String</code> containing a description of the
|
|
* named element, or <code>null</code>. The description will be
|
|
* localized for the supplied <code>Locale</code> if possible.
|
|
*
|
|
* <p> The default implementation will first locate a
|
|
* <code>ResourceBundle</code> using the current resource base
|
|
* name set by <code>setResourceBaseName</code> and the supplied
|
|
* <code>Locale</code>, using the fallback mechanism described in
|
|
* the comments for <code>ResourceBundle.getBundle</code>. If a
|
|
* <code>ResourceBundle</code> is found, the element name will be
|
|
* used as a key to its <code>getString</code> method, and the
|
|
* result returned. If no <code>ResourceBundle</code> is found,
|
|
* or no such key is present, <code>null</code> will be returned.
|
|
*
|
|
* <p> If <code>locale</code> is <code>null</code>, the current
|
|
* default <code>Locale</code> returned by <code>Locale.getLocale</code>
|
|
* will be used.
|
|
*
|
|
* @param elementName the name of the element.
|
|
* @param locale the <code>Locale</code> for which localization
|
|
* will be attempted.
|
|
*
|
|
* @return the element description.
|
|
*
|
|
* @exception IllegalArgumentException if <code>elementName</code>
|
|
* is <code>null</code>, 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 (String[])element.childList.toArray(new String[0]);
|
|
}
|
|
|
|
// Attributes
|
|
|
|
public String[] getAttributeNames(String elementName) {
|
|
Element element = getElement(elementName);
|
|
List names = element.attrList;
|
|
|
|
String[] result = new String[names.size()];
|
|
return (String[])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 values = attr.enumeratedValues;
|
|
Iterator iter = values.iterator();
|
|
String[] result = new String[values.size()];
|
|
return (String[])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</code> containing a description of the
|
|
* named attribute, or <code>null</code>. The description will be
|
|
* localized for the supplied <code>Locale</code> if possible.
|
|
*
|
|
* <p> The default implementation will first locate a
|
|
* <code>ResourceBundle</code> using the current resource base
|
|
* name set by <code>setResourceBaseName</code> and the supplied
|
|
* <code>Locale</code>, using the fallback mechanism described in
|
|
* the comments for <code>ResourceBundle.getBundle</code>. If a
|
|
* <code>ResourceBundle</code> is found, the element name followed
|
|
* by a "/" character followed by the attribute name
|
|
* (<code>elementName + "/" + attrName</code>) will be used as a
|
|
* key to its <code>getString</code> method, and the result
|
|
* returned. If no <code>ResourceBundle</code> is found, or no
|
|
* such key is present, <code>null</code> will be returned.
|
|
*
|
|
* <p> If <code>locale</code> is <code>null</code>, the current
|
|
* default <code>Locale</code> returned by <code>Locale.getLocale</code>
|
|
* will be used.
|
|
*
|
|
* @param elementName the name of the element.
|
|
* @param attrName the name of the attribute.
|
|
* @param locale the <code>Locale</code> for which localization
|
|
* will be attempted, or <code>null</code>.
|
|
*
|
|
* @return the attribute description.
|
|
*
|
|
* @exception IllegalArgumentException if <code>elementName</code>
|
|
* is <code>null</code>, or is not a legal element name for this format.
|
|
* @exception IllegalArgumentException if <code>attrName</code> is
|
|
* <code>null</code> 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 = (Attribute)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 = (ObjectValue)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 = (ObjectValue)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 synchronized static void createStandardFormat() {
|
|
if (standardFormat == null) {
|
|
standardFormat = new StandardMetadataFormat();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns an <code>IIOMetadataFormat</code> object describing the
|
|
* standard, plug-in neutral <code>javax.imageio_1.0</code>
|
|
* metadata document format described in the comment of the
|
|
* <code>javax.imageio.metadata</code> package.
|
|
*
|
|
* @return a predefined <code>IIOMetadataFormat</code> instance.
|
|
*/
|
|
public static IIOMetadataFormat getStandardFormatInstance() {
|
|
createStandardFormat();
|
|
return standardFormat;
|
|
}
|
|
}
|