import groovy.util.Node; //导入依赖的package包/类
private void printNode(Node node, Writer writer) {
    final PrintWriter printWriter = new PrintWriter(writer);
    if (GUtil.isTrue(publicId)) {
        printWriter.format("<!DOCTYPE %s PUBLIC \"%s\" \"%s\">%n", node.name(), publicId, systemId);
    }
    IndentPrinter indentPrinter = new IndentPrinter(printWriter, indentation) {
        @Override
        public void println() {
            printWriter.println();
        }
    };
    XmlNodePrinter nodePrinter = new XmlNodePrinter(indentPrinter);
    nodePrinter.setPreserveWhitespace(true);
    nodePrinter.print(node);
    printWriter.flush();
}
 

import groovy.util.Node; //导入依赖的package包/类
protected Node addClasspathEntry(Node node, Map<String, ?> attributes) {
    Map<String, Object> allAttributes = Maps.newLinkedHashMap();
    for (String key : attributes.keySet()) {
        Object value = attributes.get(key);
        if (value != null && !String.valueOf(value).isEmpty()) {
            allAttributes.put(key, value);
        }
    }
    allAttributes.put("kind", getKind());
    allAttributes.put("path", path);


    if (exported && !(this instanceof SourceFolder)) {
        allAttributes.put("exported", true);
    }

    Node entryNode = node.appendNode("classpathentry", allAttributes);
    writeAccessRules(entryNode);
    writeEntryAttributes(entryNode);
    return entryNode;
}
 

import groovy.util.Node; //导入依赖的package包/类
private void storeBytecodeLevels() {
    Node bytecodeLevelConfiguration = findOrCreateBytecodeLevelConfiguration();
    bytecodeLevelConfiguration.attributes().put("target", bytecodeVersion.toString());
    for (IdeaModule module : modules) {
        List<Node> bytecodeLevelModules = getChildren(bytecodeLevelConfiguration, "module");
        Node moduleNode = findFirstWithAttributeValue(bytecodeLevelModules, "name", module.getName());
        JavaVersion moduleBytecodeVersionOverwrite = module.getTargetBytecodeVersion();
        if (moduleBytecodeVersionOverwrite == null) {
            if (moduleNode != null) {
                bytecodeLevelConfiguration.remove(moduleNode);
            }
        } else {
            if (moduleNode == null) {
                moduleNode = bytecodeLevelConfiguration.appendNode("module");
                moduleNode.attributes().put("name", module.getName());
            }
            moduleNode.attributes().put("target", moduleBytecodeVersionOverwrite.toString());
        }
    }
}
 

import groovy.util.Node; //导入依赖的package包/类
private void readSourceAndExcludeFolderFromXml() {
    for (Node sourceFolder : findSourceFolder()) {
        String url = (String) sourceFolder.attribute("url");
        if ("false".equals(sourceFolder.attribute("isTestSource"))) {
            sourceFolders.add(pathFactory.path(url));
        } else {
            testSourceFolders.add(pathFactory.path(url));
        }
        if ("true".equals(sourceFolder.attribute("generated"))) {
            generatedSourceFolders.add(pathFactory.path(url));
        }
    }
    for (Node excludeFolder : findExcludeFolder()) {
        excludeFolders.add(pathFactory.path((String) excludeFolder.attribute("url")));
    }

}
 

import groovy.util.Node; //导入依赖的package包/类
@Override
public Node toXmlNode(Node parentModule, Object name) {
    Node node = new Node(parentModule, name, path);
    if (StringUtils.isNotEmpty(altDeployDescriptor)) {
        new Node(parentModule, nodeNameFor("alt-dd", name), altDeployDescriptor);
    }
    return node;
}
 

import groovy.util.Node; //导入依赖的package包/类
@Override
public Node toXmlNode(Node parentModule, Object name) {
    Node web = new Node(parentModule, name);
    new Node(web, nodeNameFor("web-uri", name), getPath());
    new Node(web, nodeNameFor("context-root", name), contextRoot);
    if (StringUtils.isNotEmpty(getAltDeployDescriptor())) {
        return new Node(parentModule, nodeNameFor("alt-dd", name), getAltDeployDescriptor());
    }
    return null;
}
 

import groovy.util.Node; //导入依赖的package包/类
private static String childNodeText(Node root, String name) {
    for (Node child : Cast.<List<Node>>uncheckedCast(root.children())) {
        if (localNameOf(child).equals(name)) {
            return child.text();
        }
    }
    return null;
}
 

import groovy.util.Node; //导入依赖的package包/类
@Override
public void appendNode(Node node) {
    Map<String, Object> attributes = Maps.newHashMap();
    attributes.put("deploy-path", deployPath);
    attributes.put("source-path", sourcePath);
    node.appendNode("wb-resource", attributes);
}
 

import groovy.util.Node; //导入依赖的package包/类
public void appendNode(Node node) {
    Map<String, Object> attributes = Maps.newHashMap();
    attributes.put("facet", name);
    if (type == FacetType.installed) {
        attributes.put("version", version);
    }
    node.appendNode(type.name(), attributes);
}
 

import groovy.util.Node; //导入依赖的package包/类
@Override
protected void store(Node xml) {
    removeConfigurableDataFromXml();
    Node wbModuleNode = getWbModuleNode(xml);
    wbModuleNode.attributes().put("deploy-name", deployName);
    if (!isNullOrEmpty(contextPath)) {
        new WbProperty("context-root", contextPath).appendNode(wbModuleNode);
    }
    for (WbModuleEntry wbModuleEntry : wbModuleEntries) {
        wbModuleEntry.appendNode(wbModuleNode);
    }

}
 

import groovy.util.Node; //导入依赖的package包/类
private void removeConfigurableDataFromXml() {
    Node wbModuleNode = getWbModuleNode(getXml());
    for (String elementName : Arrays.asList("property", "wb-resource", "dependent-module")) {
        for (Node elementNode : XmlPersistableConfigurationObject.getChildren(wbModuleNode, elementName)) {
            wbModuleNode.remove(elementNode);
        }
    }
}
 

import groovy.util.Node; //导入依赖的package包/类
@Override
public void appendNode(Node node) {
    Map<String, Object> attributes = Maps.newHashMap();
    attributes.put("kind", getKind());
    attributes.put("path", path);
    node.appendNode("classpathentry", attributes);
}
 

import groovy.util.Node; //导入依赖的package包/类
@Override
protected void load(Node xml) {
    Node nameNode = findFirstChildNamed(xml, "name");
    name = nameNode != null ? nameNode.text() : "";
    Node commentNode = findFirstChildNamed(xml, "comment");
    comment = commentNode != null ? commentNode.text() : "";
    readReferencedProjects();
    readNatures();
    readBuildCommands();
    readLinkedResources();
}
 

import groovy.util.Node; //导入依赖的package包/类
private void readBuildCommands() {
    for (Node commandNode : getChildren(findFirstChildNamed(getXml(), "buildSpec"), "buildCommand")) {
        String name = findFirstChildNamed(commandNode, "name").text();
        Map<String, String> arguments = Maps.newHashMap();
        for (Node dictionaryNode : getChildren(findFirstChildNamed(commandNode, "arguments"), "dictionary")) {
            String key = findFirstChildNamed(dictionaryNode, "key").text();
            String value = findFirstChildNamed(dictionaryNode, "value").text();
            arguments.put(key, value);
        }
        buildCommands.add(new BuildCommand(name, arguments));
    }
}
 

import groovy.util.Node; //导入依赖的package包/类
@Override
protected void store(Node xml) {
    for (String childNodeName : Arrays.asList("name", "comment", "projects", "natures", "buildSpec", "linkedResources")) {
        Node childNode = findFirstChildNamed(xml, childNodeName);
        if (childNode != null) {
            xml.remove(childNode);
        }
    }
    xml.appendNode("name", nullToEmpty(name));
    xml.appendNode("comment", nullToEmpty(comment));
    addReferencedProjectsToXml();
    addNaturesToXml();
    addBuildSpecToXml();
    addLinkedResourcesToXml();
}
 

import groovy.util.Node; //导入依赖的package包/类
private void addBuildSpecToXml() {
    Node buildSpec = getXml().appendNode("buildSpec");
    for (BuildCommand command : buildCommands) {
        Node commandNode = buildSpec.appendNode("buildCommand");
        commandNode.appendNode("name", command.getName());
        Node argumentsNode = commandNode.appendNode("arguments");
        for (Map.Entry<String, String> argument : command.getArguments().entrySet()) {
            Node dictionaryNode = argumentsNode.appendNode("dictionary");
            dictionaryNode.appendNode("key", argument.getKey());
            dictionaryNode.appendNode("value", argument.getValue());
        }
    }
}
 

import groovy.util.Node; //导入依赖的package包/类
private void addLinkedResourcesToXml() {
    Node parent = getXml().appendNode("linkedResources");
    for (Link link : linkedResources) {
        Node linkNode = parent.appendNode("link");
        linkNode.appendNode("name", link.getName());
        linkNode.appendNode("type", link.getType());
        if (!isNullOrEmpty(link.getLocation())) {
            linkNode.appendNode("location", link.getLocation());
        }
        if (!isNullOrEmpty(link.getLocationUri())) {
            linkNode.appendNode("locationURI", link.getLocationUri());
        }
    }
}
 

import groovy.util.Node; //导入依赖的package包/类
public AbstractClasspathEntry(Node node) {
    path = normalizePath((String) node.attribute("path"));
    this.exported = isNodeExported(node);
    accessRules = readAccessRules(node);
    entryAttributes = readEntryAttributes(node);
    Preconditions.checkNotNull(path);
    Preconditions.checkNotNull(accessRules);
}
 

import groovy.util.Node; //导入依赖的package包/类
private boolean isNodeExported(Node node) {
    Object value = node.attribute("exported");
    if (value == null) {
        return false;
    } else if (value instanceof Boolean) {
        return ((Boolean) value).booleanValue();
    } else {
        return Boolean.valueOf((String) value);
    }
}
 

import groovy.util.Node; //导入依赖的package包/类
private Map<String, Object> readEntryAttributes(Node node) {
    Map<String, Object> attributes = Maps.newLinkedHashMap();
    NodeList attributesNodes = (NodeList) node.get("attributes");
    for (Object attributesEntry : attributesNodes) {
        NodeList attributeNodes = (NodeList) ((Node) attributesEntry).get("attribute");
        for (Object attributeEntry : attributeNodes) {
            Node attributeNode = (Node) attributeEntry;
            attributes.put((String) attributeNode.attribute("name"), attributeNode.attribute("value"));
        }
    }
    return attributes;
}