MetadataFormatPrinter.java

/*
 * Copyright (c) 2012, 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.
 *
 * 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.
 */

//

import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.StringTokenizer;
import javax.imageio.metadata.IIOMetadata;
import javax.imageio.metadata.IIOMetadataFormat;
import javax.imageio.metadata.IIOMetadataFormatImpl;
import javax.imageio.spi.IIORegistry;
import javax.imageio.spi.ImageReaderSpi;
import com.sun.imageio.plugins.png.PNGMetadata;

public class MetadataFormatPrinter {

    private int indentLevel = 0;

    private int column = 0;

    private PrintStream out;

    private static final int maxColumn = 75;

    private static String[] dataTypeNames = {
        "String", "Boolean", "Integer", "Float", "Double"
    };

    // "Infinite" values
    private static String maxInteger = Integer.toString(Integer.MAX_VALUE);

    public MetadataFormatPrinter(PrintStream out) {
        this.out = out;
    }

    private void println() {
        out.println();
        column = 0;
    }

    private void println(String s) {
        out.println(s);
        column = 0;
    }

    private void printWrapped(String in, int leftIndent) {
        StringTokenizer t = new StringTokenizer(in);
        while (t.hasMoreTokens()) {
            String s = t.nextToken();
            int length = s.length();
            if (column + length > maxColumn) {
                println();
                indent();
                for (int i = 0; i < leftIndent; i++) {
                    print(" ");
                }
            }
            out.print(s);
            out.print(" ");
            column += length + 1;
        }
    }

    private void print(String s) {
        int length = s.length();
        if (column + length > maxColumn) {
            println();
            indent();
            print("  ");
        }
        out.print(s);
        column += length;
    }

    private void print(IIOMetadataFormat format) {
        String rootName = format.getRootName();
        println("<!DOCTYPE \"" +
                           rootName +
                           "\" [");
        ++indentLevel;
        print(format, rootName);
        --indentLevel;
        print("]>");
        println();
        println();
    }

    private void indent() {
        for (int i = 0; i < indentLevel; i++) {
            out.print("  ");
            column += 2;
        }
    }

    private void printElementInfo(IIOMetadataFormat format,
                                  String elementName) {
        println();
        indent();
        print("<!ELEMENT \"" +
              elementName +
              "\"");

        String[] childNames = format.getChildNames(elementName);
        boolean hasChildren = true;
        String separator = " "; // symbol to place between children
        String terminator = ""; // symbol to follow last child
        String repeater = ""; // "*" if repeating

        switch (format.getChildPolicy(elementName)) {
        case IIOMetadataFormat.CHILD_POLICY_EMPTY:
            hasChildren = false;
            break;
        case IIOMetadataFormat.CHILD_POLICY_ALL:
            separator = ", ";
            break;
        case IIOMetadataFormat.CHILD_POLICY_SOME:
            separator = "?, ";
            terminator = "?";
            break;
        case IIOMetadataFormat.CHILD_POLICY_CHOICE:
            separator = " | ";
            break;
        case IIOMetadataFormat.CHILD_POLICY_SEQUENCE:
            separator = " | ";
            repeater = "*";
            break;
        case IIOMetadataFormat.CHILD_POLICY_REPEAT:
            repeater = "*";
            break;
        default:
            break;
        }

        if (hasChildren) {
            print(" (");
            for (int i = 0; i < childNames.length - 1; i++) {
                print(childNames[i] + separator);
            }
            print(childNames[childNames.length - 1] + terminator);
            print(")" + repeater + ">");
        } else {
            print(" EMPTY>");
        }
        println();

        String description = format.getElementDescription(elementName, null);
        if (description != null) {
            ++indentLevel;
            indent();
            printWrapped("<!-- " + description + " -->", 5);
            println();
            --indentLevel;
        }
        if (format.getChildPolicy(elementName) ==
            IIOMetadataFormat.CHILD_POLICY_REPEAT) {
            int minChildren = format.getElementMinChildren(elementName);
            if (minChildren != 0) {
                indent();
                println("  <!-- Min children: " +
                        minChildren +
                        " -->");
            }
            int maxChildren = format.getElementMaxChildren(elementName);
            if (maxChildren != Integer.MAX_VALUE) {
                indent();
                println("  <!-- Max children: " +
                        maxChildren +
                        " -->");
            }
        }
    }

    private void printAttributeInfo(IIOMetadataFormat format,
                                    String elementName,
                                    String attrName) {
        indent();
        print("<!ATTLIST \"" +
              elementName +
              "\" \"" +
              attrName +
              "\"");

        int attrValueType =
            format.getAttributeValueType(elementName, attrName);
        switch (attrValueType) {
        case IIOMetadataFormat.VALUE_NONE:
            throw new RuntimeException
                ("Encountered VALUE_NONE for an attribute!");
            // break;
        case IIOMetadataFormat.VALUE_ARBITRARY:
            print(" #CDATA");
            break;
        case IIOMetadataFormat.VALUE_RANGE:
        case IIOMetadataFormat.VALUE_RANGE_MIN_INCLUSIVE:
        case IIOMetadataFormat.VALUE_RANGE_MAX_INCLUSIVE:
        case IIOMetadataFormat.VALUE_RANGE_MIN_MAX_INCLUSIVE:
            print(" #CDATA");
            break;
        case IIOMetadataFormat.VALUE_ENUMERATION:
            print(" (");
            String[] attrValues =
                format.getAttributeEnumerations(elementName, attrName);
            for (int j = 0; j < attrValues.length - 1; j++) {
                print("\"" + attrValues[j] + "\" | ");
            }
            print("\"" + attrValues[attrValues.length - 1] + "\")");
            break;
        case IIOMetadataFormat.VALUE_LIST:
            print(" #CDATA");
            break;
        default:
            throw new RuntimeException
                ("Encountered unknown value type for an attribute!");
            // break;
        }

        String defaultValue =
            format.getAttributeDefaultValue(elementName, attrName);
        if (defaultValue != null) {
            print(" ");
            print("\"" + defaultValue + "\"");
        } else {
            if (format.isAttributeRequired(elementName, attrName)) {
                print(" #REQUIRED");
            } else {
                print(" #IMPLIED");
            }
        }
        println(">");

        String description = format.getAttributeDescription(elementName,
                                                            attrName,
                                                            null);
        if (description != null) {
            ++indentLevel;
            indent();
            printWrapped("<!-- " + description + " -->", 5);
            println();
            --indentLevel;
        }

        int dataType = format.getAttributeDataType(elementName, attrName);

        switch (attrValueType) {
        case IIOMetadataFormat.VALUE_ARBITRARY:
            indent();
            println("  <!-- Data type: " + dataTypeNames[dataType] + " -->");
            break;

        case IIOMetadataFormat.VALUE_RANGE:
        case IIOMetadataFormat.VALUE_RANGE_MIN_INCLUSIVE:
        case IIOMetadataFormat.VALUE_RANGE_MAX_INCLUSIVE:
        case IIOMetadataFormat.VALUE_RANGE_MIN_MAX_INCLUSIVE:
            indent();
            println("  <!-- Data type: " + dataTypeNames[dataType] + " -->");

            boolean minInclusive =
                (attrValueType &
                 IIOMetadataFormat.VALUE_RANGE_MIN_INCLUSIVE_MASK) != 0;
            boolean maxInclusive =
                (attrValueType &
                 IIOMetadataFormat.VALUE_RANGE_MAX_INCLUSIVE_MASK) != 0;
            indent();
            println("  <!-- Min value: " +
                    format.getAttributeMinValue(elementName, attrName) +
                    " " +
                    (minInclusive ? "(inclusive)" : "(exclusive)") +
                    " -->");
            String maxValue =
                format.getAttributeMaxValue(elementName, attrName);
            // Hack: don't print "infinite" max values
            if (dataType != IIOMetadataFormat.DATATYPE_INTEGER ||
                !maxValue.equals(maxInteger)) {
                indent();
                println("  <!-- Max value: " +
                        maxValue +
                        " " +
                        (maxInclusive ? "(inclusive)" : "(exclusive)") +
                        " -->");
            }
            break;

        case IIOMetadataFormat.VALUE_LIST:
            indent();
            println("  <!-- Data type: List of " + dataTypeNames[dataType] + " -->");

            int minLength =
                format.getAttributeListMinLength(elementName, attrName);
            if (minLength != 0) {
                indent();
                println("  <!-- Min length: " +
                        minLength +
                        " -->");
            }
            int maxLength =
                format.getAttributeListMaxLength(elementName, attrName);
            if (maxLength != Integer.MAX_VALUE) {
                indent();
                println("  <!-- Max length: " +
                        maxLength +
                        " -->");
            }
            break;
        }
    }

    private void printObjectInfo(IIOMetadataFormat format,
                                 String elementName) {
        int objectType = format.getObjectValueType(elementName);
        if (objectType == IIOMetadataFormat.VALUE_NONE) {
            return;
        }

        Class objectClass = format.getObjectClass(elementName);
        if (objectClass != null) {
            indent();
            if (objectType == IIOMetadataFormat.VALUE_LIST) {
                println("  <!-- User object: array of " +
                        objectClass.getName() +
                        " -->");
            } else {
                println("  <!-- User object: " +
                        objectClass.getName() +
                        " -->");
            }

            Object defaultValue = format.getObjectDefaultValue(elementName);
            if (defaultValue != null) {
                indent();
                println("  <!-- Default value: " +
                        defaultValue.toString() +
                        " -->");
            }

            switch (objectType) {
            case IIOMetadataFormat.VALUE_RANGE:
                indent();
                println("  <!-- Min value: " +
                        format.getObjectMinValue(elementName).toString() +
                        " -->");
                indent();
                println("  <!-- Max value: " +
                        format.getObjectMaxValue(elementName).toString() +
                        " -->");
                break;

            case IIOMetadataFormat.VALUE_ENUMERATION:
                Object[] enums = format.getObjectEnumerations(elementName);
                for (int i = 0; i < enums.length; i++) {
                    indent();
                    println("  <!-- Enumerated value: " +
                            enums[i].toString() +
                            " -->");
                }
                break;

            case IIOMetadataFormat.VALUE_LIST:
                int minLength = format.getObjectArrayMinLength(elementName);
                if (minLength != 0) {
                    indent();
                    println("  <!-- Min length: " +
                            minLength +
                            " -->");
                }
                int maxLength = format.getObjectArrayMaxLength(elementName);
                if (maxLength != Integer.MAX_VALUE) {
                    indent();
                    println("  <!-- Max length: " +
                            maxLength +
                            " -->");
                }
                break;
            }
        }
    }

    // Set of elements that have been printed already
    Set printedElements = new HashSet();

    // Set of elements that have been scheduled to be printed
    Set scheduledElements = new HashSet();

    private void print(IIOMetadataFormat format,
                       String elementName) {
        // Don't print elements more than once
        if (printedElements.contains(elementName)) {
            return;
        }
        printedElements.add(elementName);

        // Add the unscheduled children of this node to a list,
        // and mark them as scheduled
        List children = new ArrayList();
        String[] childNames = format.getChildNames(elementName);
        if (childNames != null) {
            for (int i = 0; i < childNames.length; i++) {
                String childName = childNames[i];
                if (!scheduledElements.contains(childName)) {
                    children.add(childName);
                    scheduledElements.add(childName);
                }
            }
        }

        printElementInfo(format, elementName);
        printObjectInfo(format, elementName);

        ++indentLevel;
        String[] attrNames = format.getAttributeNames(elementName);
        for (int i = 0; i < attrNames.length; i++) {
            printAttributeInfo(format, elementName, attrNames[i]);
        }

        // Recurse on child nodes
        Iterator iter = children.iterator();
        while (iter.hasNext()) {
            print(format, (String)iter.next());
        }
        --indentLevel;
    }

    public static void main(String[] args) {
        IIOMetadataFormat format = null;
        if (args.length == 0 || args[0].equals("javax_imageio_1.0")) {
            format = IIOMetadataFormatImpl.getStandardFormatInstance();
        } else {
            IIORegistry registry = IIORegistry.getDefaultInstance();
            Iterator iter = registry.getServiceProviders(ImageReaderSpi.class,
                                                         false);
            while (iter.hasNext()) {
                ImageReaderSpi spi = (ImageReaderSpi)iter.next();
                if (args[0].equals
                    (spi.getNativeStreamMetadataFormatName())) {
                    System.out.print(spi.getDescription(null));
                    System.out.println(": native stream format");
                    format = spi.getStreamMetadataFormat(args[0]);
                    break;
                }

                String[] extraStreamFormatNames =
                    spi.getExtraStreamMetadataFormatNames();
                if (extraStreamFormatNames != null &&
                    Arrays.asList(extraStreamFormatNames).
                    contains(args[0])) {
                    System.out.print(spi.getDescription(null));
                    System.out.println(": extra stream format");
                    format = spi.getStreamMetadataFormat(args[0]);
                    break;
                }

                if (args[0].equals
                    (spi.getNativeImageMetadataFormatName())) {
                    System.out.print(spi.getDescription(null));
                    System.out.println(": native image format");
                    format = spi.getImageMetadataFormat(args[0]);
                    break;
                }

                String[] extraImageFormatNames =
                    spi.getExtraImageMetadataFormatNames();
                if (extraImageFormatNames != null &&
                    Arrays.asList(extraImageFormatNames).contains(args[0])) {
                    System.out.print(spi.getDescription(null));
                    System.out.println(": extra image format");
                    format = spi.getImageMetadataFormat(args[0]);
                    break;
                }
            }
        }

        if (format == null) {
            System.err.println("Unknown format: " + args[0]);
            System.exit(0);
        }

        MetadataFormatPrinter printer = new MetadataFormatPrinter(System.out);
        printer.print(format);
    }
}