replicant-frameworks_native/awt/javax/imageio/metadata/IIOMetadataFormatImpl.java

/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package javax.imageio.metadata;

import javax.imageio.ImageTypeSpecifier;
import java.util.*;
import java.security.AccessController;
import java.security.PrivilegedAction;

/**
 * The IIOMetadataFormatImpl class provides an implementation of the 
 * IIOMetadataFormat interface.
 */
public abstract class IIOMetadataFormatImpl implements IIOMetadataFormat {
    
    /** The Constant standardMetadataFormatName. */
    @SuppressWarnings({"ConstantDeclaredInAbstractClass"})
    public static final String standardMetadataFormatName = "javax_imageio_1.0";

    /** The standard format. */
    @SuppressWarnings({"StaticNonFinalField"})
    private static IIOMetadataFormatImpl standardFormat;

    /** The root name. */
    private String rootName;
    
    /** The element hash. */
    private HashMap<String, Element> elementHash = new HashMap<String, Element>();

    /** The resource base name. */
    private String resourceBaseName = getClass().getName() + "Resources";

    /**
     * Instantiates an IIOMetadataFormatImpl with the specified root
     * name and child policy (not CHILD_POLICY_REPEAT).
     * 
     * @param rootName the name of root element.
     * @param childPolicy the child policy defined by one of the 
     * CHILD_POLICY_* constants  (except CHILD_POLICY_REPEAT).
     */
    public IIOMetadataFormatImpl(String rootName, int childPolicy) {
        if (rootName == null) {
            throw new IllegalArgumentException("rootName is null");
        }
        if (
                childPolicy < CHILD_POLICY_EMPTY ||
                childPolicy > CHILD_POLICY_MAX ||
                childPolicy == CHILD_POLICY_REPEAT
        ) {
            throw new IllegalArgumentException("childPolicy is not one of the predefined constants");
        }

        this.rootName = rootName;
        Element root = new Element();
        root.name = rootName;
        root.childPolicy = childPolicy;
        elementHash.put(rootName, root);
    }

    /**
     * Instantiates an IIOMetadataFormatImpl with the specified root
     * name and CHILD_POLICY_REPEAT child policy.
     * 
     * @param rootName the name of root element.
     * @param minChildren the minimum number of children.
     * @param maxChildren the maximum number of children
     */
    public IIOMetadataFormatImpl(String rootName, int minChildren, int maxChildren) {
        if (rootName == null) {
            throw new IllegalArgumentException("rootName is null");
        }
        if (minChildren < 0) {
            throw new IllegalArgumentException("minChildren < 0!");
        }
        if (minChildren > maxChildren) {
            throw new IllegalArgumentException("minChildren > maxChildren!");
        }

        this.rootName = rootName;
        Element root = new Element();
        root.name = rootName;
        root.minChildren = minChildren;
        root.maxChildren = maxChildren;
        root.childPolicy = CHILD_POLICY_REPEAT;
        elementHash.put(rootName, root);
    }

    @SuppressWarnings({"AbstractMethodOverridesAbstractMethod"})
    public abstract boolean canNodeAppear(String elementName, ImageTypeSpecifier imageType);

    /**
     * Adds a new attribute to an existing element.
     * 
     * @param elementName the name of the element to which the new attribute
     * will be added.
     * @param attrName the attribute name.
     * @param dataType the data type of the new attribute.
     * @param required the flag which indicates whether this attribute
     * must be present.
     * @param listMinLength the minimum legal number of list items.
     * @param listMaxLength the the maximum legal number of list items.
     */
    protected void addAttribute(
            String elementName, String attrName, int dataType,
            boolean required, int listMinLength, int listMaxLength
    ) {
        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!");
        }

        Element element = findElement(elementName);
        Attlist attr = new Attlist();
        attr.name = attrName;
        attr.dataType = dataType;
        attr.required = required;
        attr.listMinLength = listMinLength;
        attr.listMaxLength = listMaxLength;
        attr.valueType = VALUE_LIST;

        element.attributes.put(attrName, attr);
    }

    /**
     * Adds a new attribute to an existing element.
     * 
     * @param elementName the name of the element to which the new attribute
     * will be added.
     * @param attrName the attribute name.
     * @param dataType the data type of the new attribute.
     * @param required the flag which indicates whether this attribute
     * must be present.
     * @param defaultValue the default value of the attribute.
     */
    protected void addAttribute(
            String elementName, String attrName, int dataType,
            boolean required, String defaultValue
    ) {
        if (attrName == null) {
            throw new IllegalArgumentException("attrName == null!");
        }
        if (dataType < DATATYPE_STRING || dataType > DATATYPE_DOUBLE) {
            throw new IllegalArgumentException("Invalid value for dataType!");
        }

        Element element = findElement(elementName);
        Attlist attr = new Attlist();
        attr.name = attrName;
        attr.dataType = dataType;
        attr.required = required;
        attr.defaultValue = defaultValue;
        attr.valueType = VALUE_ARBITRARY;

        element.attributes.put(attrName, attr);
    }

    /**
     * Adds a new attribute to an existing element.
     * 
     * @param elementName the name of the element to which the new attribute
     * will be added.
     * @param attrName the attribute name.
     * @param dataType the data type of the new attribute.
     * @param required the flag which indicates whether this attribute
     * must be present.
     * @param defaultValue the default value of the attribute.
     * @param enumeratedValues the legal values for the attribute as 
     * a list of strings.
     */
    protected void addAttribute(
            String elementName, String attrName, int dataType,
            boolean required, String defaultValue, List<String> enumeratedValues
    ) {
        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 || enumeratedValues.isEmpty()) {
            throw new IllegalArgumentException("enumeratedValues is empty or null");
        }

        try {
            for (String enumeratedValue : enumeratedValues) {
                if (enumeratedValue == null) {
                    throw new IllegalArgumentException("enumeratedValues contains a null!");
                }
            }
        } catch (ClassCastException e) {
            throw new IllegalArgumentException("enumeratedValues contains a non-String value!");
        }

        Element element = findElement(elementName);
        Attlist attr = new Attlist();
        attr.name = attrName;
        attr.dataType = dataType;
        attr.required = required;
        attr.defaultValue = defaultValue;
        attr.enumeratedValues = enumeratedValues;
        attr.valueType = VALUE_ENUMERATION;

        element.attributes.put(attrName, attr);
    }

    /**
     * Adds a new attribute to an existing element.
     * 
     * @param elementName the name of the element to which the new attribute
     * will be added.
     * @param attrName the attribute name.
     * @param dataType the data type of the new attribute.
     * @param required the flag which indicates whether this attribute
     * must be present.
     * @param defaultValue the default value of attribute.
     * @param minValue the minimum legal value of an attribute.
     * @param maxValue the maximum legal value of an attribute.
     * @param minInclusive the flag which indicates  
     * whether the minValue is inclusive.
     * @param maxInclusive the flag which indicates  
     * whether the maxValue is inclusive.
     */
    protected void addAttribute(
            String elementName, String attrName, int dataType,
            boolean required, String defaultValue,
            String minValue, String maxValue,
            boolean minInclusive, boolean maxInclusive
    ) {
        if (attrName == null) {
            throw new IllegalArgumentException("attrName == null!");
        }
        if (dataType < DATATYPE_STRING || dataType > DATATYPE_DOUBLE) {
            throw new IllegalArgumentException("Invalid value for dataType!");
        }

        Element element = findElement(elementName);
        Attlist attr = new Attlist();
        attr.name = attrName;
        attr.dataType = dataType;
        attr.required = required;
        attr.defaultValue = defaultValue;
        attr.minValue = minValue;
        attr.maxValue = maxValue;
        attr.minInclusive = minInclusive;
        attr.maxInclusive = maxInclusive;

        attr.valueType = VALUE_RANGE;
        attr.valueType |= minInclusive ? VALUE_RANGE_MIN_INCLUSIVE_MASK : 0;
        attr.valueType |= maxInclusive ? VALUE_RANGE_MAX_INCLUSIVE_MASK : 0;

        element.attributes.put(attrName, attr);
    }

    /**
     * Adds a new attribute with boolean data type to an existing 
     * element.
     * 
     * @param elementName the name of the element to which the new attribute
     * will be added.
     * @param attrName the attribute name.
     * @param hasDefaultValue the flag which indicates whether this attribute
     * must have a default value.
     * @param defaultValue the default value.
     */
    protected void addBooleanAttribute(
            String elementName, String attrName,
            boolean hasDefaultValue, boolean defaultValue
    ) {
        String defaultVal = hasDefaultValue ? (defaultValue ? "TRUE" : "FALSE") : null;
        ArrayList<String> values = new ArrayList<String>(2);
        values.add("TRUE");
        values.add("FALSE");

        addAttribute(elementName, attrName, DATATYPE_BOOLEAN, true, defaultVal, values);
    }

    /**
     * Adds an existing element to the list of child elements 
     * of the specified parent element.
     * 
     * @param elementName the name of the element to be added.
     * @param parentName the parent element name.
     */
    protected void addChildElement(String elementName, String parentName) {
        Element parent = findElement(parentName);
        Element element = findElement(elementName);
        parent.children.add(element.name);
    }

    /**
     * Adds a new element type to this IIOMetadataFormat with 
     * a child policy (if policy is not CHILD_POLICY_REPEAT).
     * 
     * @param elementName the name of the element to be added.
     * @param parentName the parent element name.
     * @param childPolicy one of the CHILD_POLICY_* constants defined
     * by IIOMetadataFormat.
     */
    protected void addElement(String elementName, String parentName, int childPolicy) {
        if (
                childPolicy < CHILD_POLICY_EMPTY ||
                childPolicy > CHILD_POLICY_MAX ||
                childPolicy == CHILD_POLICY_REPEAT
        ) {
            throw new IllegalArgumentException("childPolicy is not one of the predefined constants");
        }
        
        Element parent = findElement(parentName);
        Element element = new Element();
        element.name = elementName;
        element.childPolicy = childPolicy;
        elementHash.put(elementName, element);
        parent.children.add(elementName);
    }

    /**
     * Adds a new element type to this IIOMetadataFormat with 
     * CHILD_POLICY_REPEAT and the specified minimum and maximum
     * number of child elements.
     * 
     * @param elementName the element name to be added.
     * @param parentName the parent element name.
     * @param minChildren the minimum number of child elements.
     * @param maxChildren the maximum number of child elements.
     */
    protected void addElement(
            String elementName, String parentName,
            int minChildren, int maxChildren
    ) {
        if (minChildren < 0) {
            throw new IllegalArgumentException("minChildren < 0!");
        }
        if (minChildren > maxChildren) {
            throw new IllegalArgumentException("minChildren > maxChildren!");
        }

        Element parent = findElement(parentName);
        Element element = new Element();
        element.name = elementName;
        element.childPolicy = CHILD_POLICY_REPEAT;
        element.minChildren = minChildren;
        element.maxChildren = maxChildren;
        elementHash.put(elementName, element);
        parent.children.add(elementName);
    }

    /**
     * Adds an Object reference with the specified class type to be 
     * stored as element's value. 
     * 
     * @param elementName the element name.
     * @param classType the class indicates the legal types for 
     * the object's value.
     * @param arrayMinLength the minimum legal length for the array.
     * @param arrayMaxLength the maximum legal length for the array.
     */
    protected void addObjectValue(
            String elementName, Class<?> classType,
            int arrayMinLength, int arrayMaxLength
    ) {
        Element element = findElement(elementName);

        ObjectValue objVal = new ObjectValue();
        objVal.classType = classType;
        objVal.arrayMaxLength = arrayMaxLength;
        objVal.arrayMinLength = arrayMinLength;
        objVal.valueType = VALUE_LIST;

        element.objectValue = objVal;
    }

    /**
     * Adds an Object reference with the specified class type to be 
     * stored as an element's value. 
     * 
     * @param elementName the element name.
     * @param classType the class indicates the legal types for 
     * the object's value.
     * @param required a flag indicated that this object value 
     * must be present.
     * @param defaultValue the default value, or null.
     */
    protected <T> void addObjectValue(
            String elementName, Class<T> classType,
            boolean required, T defaultValue
    ) {
        // note: reqired is an unused parameter
        Element element = findElement(elementName);

        ObjectValue<T> objVal = new ObjectValue<T>();
        objVal.classType = classType;
        objVal.defaultValue = defaultValue;
        objVal.valueType = VALUE_ARBITRARY;

        element.objectValue = objVal;
    }

    /**
     * Adds an Object reference with the specified class type to be 
     * stored as the element's value. 
     * 
     * @param elementName the element name.
     * @param classType the class indicates the legal types for 
     * the object value.
     * @param required a flag indicated that this object value 
     * must be present.
     * @param defaultValue the default value, or null.
     * @param enumeratedValues the list of legal values for the object.
     */
    protected <T> void addObjectValue(
            String elementName, Class<T> classType,
            boolean required, T defaultValue,
            List<? extends T> enumeratedValues
    ) {
        // note: reqired is an unused parameter
        if (enumeratedValues == null || enumeratedValues.isEmpty()) {
            throw new IllegalArgumentException("enumeratedValues is empty or null");
        }

        try {
            for (T enumeratedValue : enumeratedValues) {
                if (enumeratedValue == null) {
                    throw new IllegalArgumentException("enumeratedValues contains a null!");
                }
            }
        } catch (ClassCastException e) {
            throw new IllegalArgumentException("enumeratedValues contains a value not of class classType!");
        }

        Element element = findElement(elementName);

        ObjectValue<T> objVal = new ObjectValue<T>();
        objVal.classType = classType;
        objVal.defaultValue = defaultValue;
        objVal.enumeratedValues = enumeratedValues;
        objVal.valueType = VALUE_ENUMERATION;

        element.objectValue = objVal;
    }

    /**
     * Adds an Object reference with the specified class type to be 
     * stored as the element's value. 
     * 
     * @param elementName the element name.
     * @param classType the class indicates the legal types for 
     * the object value.
     * @param defaultValue the default value, or null.
     * @param minValue the minimum legal value for the object value. 
     * @param maxValue the maximum legal value for the object value. 
     * @param minInclusive the flag which indicates 
     * whether the minValue is inclusive.
     * @param maxInclusive the flag which indicates 
     * whether the maxValue is inclusive.
     */
    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 = findElement(elementName);

        ObjectValue<T> objVal = new ObjectValue<T>();
        objVal.classType = classType;
        objVal.defaultValue = defaultValue;
        objVal.minValue = minValue;
        objVal.maxValue = maxValue;
        objVal.minInclusive = minInclusive;
        objVal.maxInclusive = maxInclusive;

        objVal.valueType = VALUE_RANGE;
        objVal.valueType |= minInclusive ? VALUE_RANGE_MIN_INCLUSIVE_MASK : 0;
        objVal.valueType |= maxInclusive ? VALUE_RANGE_MAX_INCLUSIVE_MASK : 0;

        element.objectValue = objVal;
    }

    public int getAttributeDataType(String elementName, String attrName) {
        Attlist attr = findAttribute(elementName, attrName);
        return attr.dataType;
    }

    public String getAttributeDefaultValue(String elementName, String attrName) {
        Attlist attr = findAttribute(elementName, attrName);
        return attr.defaultValue;
    }

    public String getAttributeDescription(String elementName, String attrName, Locale locale) {
        findAttribute(elementName, attrName);
        return getResourceString(elementName + "/" + attrName, locale);
    }

    public String[] getAttributeEnumerations(String elementName, String attrName) {
        Attlist attr = findAttribute(elementName, attrName);
        if (attr.valueType != VALUE_ENUMERATION) {
            throw new IllegalArgumentException("Attribute is not an enumeration!");
        }

        return attr.enumeratedValues.toArray(new String[attr.enumeratedValues.size()]);
    }

    public int getAttributeListMaxLength(String elementName, String attrName) {
        Attlist attr = findAttribute(elementName, attrName);
        if (attr.valueType != VALUE_LIST) {
            throw new IllegalArgumentException("Attribute is not a list!");
        }
        return attr.listMaxLength;
    }

    public int getAttributeListMinLength(String elementName, String attrName) {
        Attlist attr = findAttribute(elementName, attrName);
        if (attr.valueType != VALUE_LIST) {
            throw new IllegalArgumentException("Attribute is not a list!");
        }
        return attr.listMinLength;
    }

    public String getAttributeMaxValue(String elementName, String attrName) {
        Attlist attr = findAttribute(elementName, attrName);
        if ((attr.valueType & VALUE_RANGE) == 0) {
            throw new IllegalArgumentException("Attribute is not a range!");
        }
        return attr.maxValue;        
    }

    public String getAttributeMinValue(String elementName, String attrName) {
        Attlist attr = findAttribute(elementName, attrName);
        if ((attr.valueType & VALUE_RANGE) == 0) {
            throw new IllegalArgumentException("Attribute is not a range!");
        }
        return attr.minValue;
    }

    public String[] getAttributeNames(String elementName) {
        Element element = findElement(elementName);
        return element.attributes.keySet().toArray(new String[element.attributes.size()]);
    }

    public int getAttributeValueType(String elementName, String attrName) {
        Attlist attr = findAttribute(elementName, attrName);
        return attr.valueType;                
    }

    public String[] getChildNames(String elementName) {
        Element element = findElement(elementName);
        if (element.childPolicy == CHILD_POLICY_EMPTY) { // Element cannot have children
            return null;
        }
        return element.children.toArray(new String[element.children.size()]);
    }

    public int getChildPolicy(String elementName) {
        Element element = findElement(elementName);
        return element.childPolicy;
    }

    public String getElementDescription(String elementName, Locale locale) {
        findElement(elementName); // Check if there is such element
        return getResourceString(elementName, locale);
    }

    public int getElementMaxChildren(String elementName) {
        Element element = findElement(elementName);
        if (element.childPolicy != CHILD_POLICY_REPEAT) {
            throw new IllegalArgumentException("Child policy is not CHILD_POLICY_REPEAT!");
        }
        return element.maxChildren;
    }

    public int getElementMinChildren(String elementName) {
        Element element = findElement(elementName);
        if (element.childPolicy != CHILD_POLICY_REPEAT) {
            throw new IllegalArgumentException("Child policy is not CHILD_POLICY_REPEAT!");
        }
        return element.minChildren;
    }

    public int getObjectArrayMaxLength(String elementName) {
        Element element = findElement(elementName);
        ObjectValue v = element.objectValue;
        if (v == null || v.valueType != VALUE_LIST) {
            throw new IllegalArgumentException("Not a list!");
        }
        return v.arrayMaxLength;
    }

    public int getObjectArrayMinLength(String elementName) {
        Element element = findElement(elementName);
        ObjectValue v = element.objectValue;
        if (v == null || v.valueType != VALUE_LIST) {
            throw new IllegalArgumentException("Not a list!");
        }
        return v.arrayMinLength;
    }

    public Class<?> getObjectClass(String elementName) {
        ObjectValue v = findObjectValue(elementName);
        return v.classType;
    }

    public Object getObjectDefaultValue(String elementName) {
        ObjectValue v = findObjectValue(elementName);
        return v.defaultValue;
    }

    public Object[] getObjectEnumerations(String elementName) {
        Element element = findElement(elementName);
        ObjectValue v = element.objectValue;
        if (v == null || v.valueType != VALUE_ENUMERATION) {
            throw new IllegalArgumentException("Not an enumeration!");
        }
        return v.enumeratedValues.toArray();
    }

    public Comparable<?> getObjectMaxValue(String elementName) {
        Element element = findElement(elementName);
        ObjectValue v = element.objectValue;
        if (v == null || (v.valueType & VALUE_RANGE) == 0) {
            throw new IllegalArgumentException("Not a range!");
        }
        return v.maxValue;
    }

    public Comparable<?> getObjectMinValue(String elementName) {
        Element element = findElement(elementName);
        ObjectValue v = element.objectValue;
        if (v == null || (v.valueType & VALUE_RANGE) == 0) {
            throw new IllegalArgumentException("Not a range!");
        }
        return v.minValue;
    }

    public int getObjectValueType(String elementName) {
        Element element = findElement(elementName);
        if (element.objectValue == null) {
            return VALUE_NONE;
        }
        return element.objectValue.valueType;
    }

    /**
     * Gets the resource base name for locating ResourceBundles.
     * 
     * @return the current resource base name.
     */
    protected String getResourceBaseName() {
        return resourceBaseName;
    }

    public String getRootName() {
        return rootName;
    }

    /**
     * Gets the standard format instance.
     * 
     * @return the IIOMetadataFormat instance.
     */
    public static IIOMetadataFormat getStandardFormatInstance() {
        if (standardFormat == null) {
            standardFormat = new IIOStandardMetadataFormat();
        }

        return standardFormat;
    }

    public boolean isAttributeRequired(String elementName, String attrName) {
        return findAttribute(elementName, attrName).required;
    }

    /**
     * Removes the specified attribute from the specified element. 
     *  
     * @param elementName the specified element name.
     * @param attrName the specified attribute name.
     */
    protected void removeAttribute(String elementName, String attrName) {
        Element element = findElement(elementName);
        element.attributes.remove(attrName);
    }

    /**
     * Removes the specified element from this format.
     * 
     * @param elementName the specified element name.
     */
    protected void removeElement(String elementName) {
        Element element;
        if ((element = elementHash.get(elementName)) != null) {
            elementHash.remove(elementName);
            for (Element e : elementHash.values()) {
                e.children.remove(element.name);
            }
        }
    }

    /**
     * Removes the object value from the specified element.
     * 
     * @param elementName the element name.
     */
    protected void removeObjectValue(String elementName) {
        Element element = findElement(elementName);
        element.objectValue = null;
    }
    
    /**
     * Sets a new base name for ResourceBundles containing 
     * descriptions of elements and attributes for this format.
     * 
     * @param resourceBaseName the new resource base name.
     */
    protected void setResourceBaseName(String resourceBaseName) {
        if (resourceBaseName == null) {
            throw new IllegalArgumentException("resourceBaseName == null!");
        }
        this.resourceBaseName = resourceBaseName;
    }

    /**
     * The Class Element.
     */
    @SuppressWarnings({"ClassWithoutConstructor"})
    private class Element {
        
        /** The name. */
        String name;

        /** The children. */
        ArrayList<String> children = new ArrayList<String>();
        
        /** The attributes. */
        HashMap<String, Attlist> attributes = new HashMap<String, Attlist>();

        /** The min children. */
        int minChildren;
        
        /** The max children. */
        int maxChildren;
        
        /** The child policy. */
        int childPolicy;

        /** The object value. */
        ObjectValue objectValue;
    }

    /**
     * The Class Attlist.
     */
    @SuppressWarnings({"ClassWithoutConstructor"})
    private class Attlist {
        
        /** The name. */
        String name;

        /** The data type. */
        int dataType;
        
        /** The required. */
        boolean required;
        
        /** The list min length. */
        int listMinLength;
        
        /** The list max length. */
        int listMaxLength;
        
        /** The default value. */
        String defaultValue;
        
        /** The enumerated values. */
        List<String> enumeratedValues;
        
        /** The min value. */
        String minValue;
        
        /** The max value. */
        String maxValue;
        
        /** The min inclusive. */
        boolean minInclusive;
        
        /** The max inclusive. */
        boolean maxInclusive;

        /** The value type. */
        int valueType;
    }

    /**
     * The Class ObjectValue.
     */
    @SuppressWarnings({"ClassWithoutConstructor"})
    private class ObjectValue<T> {
        
        /** The class type. */
        Class<T> classType;
        
        /** The array min length. */
        int arrayMinLength;
        
        /** The array max length. */
        int arrayMaxLength;
        
        /** The default value. */
        T defaultValue;
        
        /** The enumerated values. */
        List<? extends T> enumeratedValues;
        
        /** The min value. */
        Comparable<? super T> minValue;
        
        /** The max value. */
        Comparable<? super T> maxValue;
        
        /** The min inclusive. */
        boolean minInclusive;
        
        /** The max inclusive. */
        boolean maxInclusive;

        /** The value type. */
        int valueType;
    }

    /**
     * Find element.
     * 
     * @param name the name
     * 
     * @return the element
     */
    private Element findElement(String name) {
        Element element;
        if ((element = elementHash.get(name)) == null) {
            throw new IllegalArgumentException("element name is null or no such element: " + name);
        }

        return element;
    }

    /**
     * Find attribute.
     * 
     * @param elementName the element name
     * @param attributeName the attribute name
     * 
     * @return the attlist
     */
    private Attlist findAttribute(String elementName, String attributeName) {
        Element element = findElement(elementName);
        Attlist attribute;
        if ((attribute = element.attributes.get(attributeName)) == null) {
            throw new IllegalArgumentException("attribute name is null or no such attribute: " + attributeName);
        }

        return attribute;
    }

    /**
     * Find object value.
     * 
     * @param elementName the element name
     * 
     * @return the object value
     */
    private ObjectValue findObjectValue(String elementName) {
        Element element = findElement(elementName);
        ObjectValue v = element.objectValue;
        if (v == null) {
            throw new IllegalArgumentException("No object within element");
        }
        return v;
    }

    /**
     * Gets the resource string.
     * 
     * @param key the key
     * @param locale the locale
     * 
     * @return the resource string
     */
    private String getResourceString(String key, Locale locale) {
        if (locale == null) {
            locale = Locale.getDefault();
        }

        // Get the context class loader and try to locate the bundle with it first
        ClassLoader contextClassloader = AccessController.doPrivileged(
                new PrivilegedAction<ClassLoader>() {
                    public ClassLoader run() {
                        return Thread.currentThread().getContextClassLoader();
                    }
        });

        // Now try to get the resource bundle
        ResourceBundle rb;
        try {
            rb = ResourceBundle.getBundle(resourceBaseName, locale, contextClassloader);
        } catch (MissingResourceException e) {
            try {
                rb = ResourceBundle.getBundle(resourceBaseName, locale);
            } catch (MissingResourceException e1) {
                return null;
            }
        }

        try {
            return rb.getString(key);
        } catch (MissingResourceException e) {
            return null;
        } catch (ClassCastException e) {
            return null; // Not a string resource
        }
    }
}