1 /*

     2  * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package build.tools.module;

    27 

    28 import javax.xml.namespace.QName;

    29 import javax.xml.stream.XMLOutputFactory;

    30 import javax.xml.stream.XMLStreamException;

    31 import javax.xml.stream.XMLStreamWriter;

    32 import java.io.IOException;

    33 import java.io.OutputStream;

    34 import java.nio.file.Files;

    35 import java.nio.file.Path;

    36 import java.util.Collections;

    37 import java.util.Comparator;

    38 import java.util.Map;

    39 import java.util.Set;

    40 

    41 public final class ModulesXmlWriter {

    42 

    43     private ModulesXmlWriter() {}

    44 

    45     public static void writeModules(Set<Module> modules, Path path)

    46         throws IOException, XMLStreamException

    47     {

    48         writeXML(modules, path);

    49     }

    50 

    51     private static final String MODULES   = "modules";

    52     private static final String MODULE    = "module";

    53     private static final String NAME      = "name";

    54     private static final String DEPEND    = "depend";

    55     private static final String EXPORT    = "export";

    56     private static final String TO        = "to";

    57     private static final QName  REEXPORTS = new QName("re-exports");

    58 

    59     private static void writeXML(Set<Module> modules, Path path)

    60         throws IOException, XMLStreamException

    61     {

    62         XMLOutputFactory xof = XMLOutputFactory.newInstance();

    63         try (OutputStream out = Files.newOutputStream(path)) {

    64             int depth = 0;

    65             XMLStreamWriter xtw = xof.createXMLStreamWriter(out, "UTF-8");

    66             xtw.writeStartDocument("utf-8","1.0");

    67             writeStartElement(xtw, MODULES, depth);

    68             modules.stream()

    69                    .sorted(Comparator.comparing(Module::name))

    70                    .forEach(m -> writeModuleElement(xtw, m, depth+1));

    71             writeEndElement(xtw, depth);

    72             xtw.writeCharacters("\n");

    73             xtw.writeEndDocument();

    74             xtw.flush();

    75             xtw.close();

    76         }

    77     }

    78 

    79     private static void writeElement(XMLStreamWriter xtw,

    80                                      String element,

    81                                      String value,

    82                                      int depth) {

    83         try {

    84             writeStartElement(xtw, element, depth);

    85             xtw.writeCharacters(value);

    86             xtw.writeEndElement();

    87         } catch (XMLStreamException e) {

    88             throw new RuntimeException(e);

    89         }

    90     }

    91 

    92     private static void writeDependElement(XMLStreamWriter xtw,

    93                                            Module.Dependence d,

    94                                            int depth) {

    95         try {

    96             writeStartElement(xtw, DEPEND, depth);

    97             if (d.reexport) {

    98                 xtw.writeAttribute("re-exports", "true");

    99             }

   100             xtw.writeCharacters(d.name);

   101             xtw.writeEndElement();

   102         } catch (XMLStreamException e) {

   103             throw new RuntimeException(e);

   104         }

   105     }

   106 

   107     private static void writeExportElement(XMLStreamWriter xtw,

   108                                            String pkg,

   109                                            int depth) {

   110         writeExportElement(xtw, pkg, Collections.emptySet(), depth);

   111     }

   112 

   113     private static void writeExportElement(XMLStreamWriter xtw,

   114                                            String pkg,

   115                                            Set<String> permits,

   116                                            int depth) {

   117         try {

   118             writeStartElement(xtw, EXPORT, depth);

   119             writeElement(xtw, NAME, pkg, depth+1);

   120             if (!permits.isEmpty()) {

   121                 permits.stream().sorted()

   122                        .forEach(m -> writeElement(xtw, TO, m, depth + 1));

   123             }

   124             writeEndElement(xtw, depth);

   125         } catch (XMLStreamException e) {

   126             throw new RuntimeException(e);

   127         }

   128     }

   129     private static void writeModuleElement(XMLStreamWriter xtw,

   130                                            Module m,

   131                                            int depth) {

   132         try {

   133             writeStartElement(xtw, MODULE, depth);

   134             writeElement(xtw, NAME, m.name(), depth+1);

   135             m.requires().stream().sorted(Comparator.comparing(d -> d.name))

   136                         .forEach(d -> writeDependElement(xtw, d, depth+1));

   137             m.exports().keySet().stream()

   138                        .filter(pn -> m.exports().get(pn).isEmpty())

   139                        .sorted()

   140                        .forEach(pn -> writeExportElement(xtw, pn, depth+1));

   141             m.exports().entrySet().stream()

   142                        .filter(e -> !e.getValue().isEmpty())

   143                        .sorted(Map.Entry.comparingByKey())

   144                        .forEach(e -> writeExportElement(xtw, e.getKey(), e.getValue(), depth+1));

   145             writeEndElement(xtw, depth);

   146         } catch (XMLStreamException e) {

   147             throw new RuntimeException(e);

   148 

   149         }

   150     }

   151 

   152     /** Two spaces; the default indentation. */

   153     public static final String DEFAULT_INDENT = "  ";

   154 

   155     /** stack[depth] indicates what's been written into the current scope. */

   156     private static String[] stack = new String[] { "\n",

   157         "\n" + DEFAULT_INDENT,

   158         "\n" + DEFAULT_INDENT + DEFAULT_INDENT,

   159         "\n" + DEFAULT_INDENT + DEFAULT_INDENT + DEFAULT_INDENT};

   160 

   161     private static void writeStartElement(XMLStreamWriter xtw,

   162                                           String name,

   163                                           int depth)

   164         throws XMLStreamException

   165     {

   166         xtw.writeCharacters(stack[depth]);

   167         xtw.writeStartElement(name);

   168     }

   169 

   170     private static void writeEndElement(XMLStreamWriter xtw, int depth)

   171         throws XMLStreamException

   172     {

   173         xtw.writeCharacters(stack[depth]);

   174         xtw.writeEndElement();

   175     }

   176 }