| /* |
| * Copyright 2000-2011 JetBrains s.r.o. |
| * |
| * Licensed 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 com.intellij.openapi.roots.impl.libraries; |
| |
| import com.intellij.openapi.roots.OrderRootType; |
| import com.intellij.openapi.roots.PersistentOrderRootType; |
| import com.intellij.openapi.util.InvalidDataException; |
| import com.intellij.openapi.util.JDOMExternalizable; |
| import com.intellij.util.containers.MultiMap; |
| import org.jdom.Element; |
| import org.jetbrains.annotations.NonNls; |
| import org.jetbrains.annotations.Nullable; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.List; |
| |
| /** |
| * @author nik |
| */ |
| public class JarDirectories implements JDOMExternalizable { |
| private final MultiMap<OrderRootType, String> myDirectories = new MultiMap<OrderRootType, String>(); |
| private final MultiMap<OrderRootType, String> myRecursivelyIncluded = new MultiMap<OrderRootType, String>(); |
| |
| @NonNls private static final String JAR_DIRECTORY_ELEMENT = "jarDirectory"; |
| @NonNls private static final String URL_ATTR = "url"; |
| @NonNls private static final String RECURSIVE_ATTR = "recursive"; |
| @NonNls private static final String ROOT_TYPE_ATTR = "type"; |
| public static final OrderRootType DEFAULT_JAR_DIRECTORY_TYPE = OrderRootType.CLASSES; |
| |
| public void copyFrom(JarDirectories other) { |
| myDirectories.clear(); |
| myDirectories.putAllValues(other.myDirectories); |
| myRecursivelyIncluded.clear(); |
| myRecursivelyIncluded.putAllValues(other.myRecursivelyIncluded); |
| } |
| |
| public boolean contains(OrderRootType rootType, String url) { |
| return myDirectories.get(rootType).contains(url); |
| } |
| |
| public boolean isRecursive(OrderRootType rootType, String url) { |
| return myRecursivelyIncluded.get(rootType).contains(url); |
| } |
| |
| public void add(OrderRootType rootType, String url, boolean recursively) { |
| myDirectories.putValue(rootType, url); |
| if (recursively) { |
| myRecursivelyIncluded.putValue(rootType, url); |
| } |
| } |
| |
| public void remove(OrderRootType rootType, String url) { |
| myDirectories.remove(rootType, url); |
| myRecursivelyIncluded.remove(rootType, url); |
| } |
| |
| public void clear() { |
| myDirectories.clear(); |
| myRecursivelyIncluded.clear(); |
| } |
| |
| public Collection<OrderRootType> getRootTypes() { |
| return myDirectories.keySet(); |
| } |
| |
| public Collection<String> getDirectories(OrderRootType rootType) { |
| return myDirectories.get(rootType); |
| } |
| |
| public Collection<? extends String> getAllDirectories() { |
| return myDirectories.values(); |
| } |
| |
| public boolean isEmpty() { |
| return myDirectories.isEmpty(); |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| if (this == o) return true; |
| if (!(o instanceof JarDirectories)) return false; |
| |
| JarDirectories that = (JarDirectories)o; |
| return myDirectories.equals(that.myDirectories) && myRecursivelyIncluded.equals(that.myRecursivelyIncluded); |
| } |
| |
| @Override |
| public int hashCode() { |
| return 31 * myDirectories.hashCode() + myRecursivelyIncluded.hashCode(); |
| } |
| |
| @Override |
| public String toString() { |
| return "JAR dirs: " + myDirectories.values(); |
| } |
| |
| |
| @Override |
| public void readExternal(Element element) throws InvalidDataException { |
| clear(); |
| final List jarDirs = element.getChildren(JAR_DIRECTORY_ELEMENT); |
| for (Object item : jarDirs) { |
| final Element jarDir = (Element)item; |
| final String url = jarDir.getAttributeValue(URL_ATTR); |
| final String recursive = jarDir.getAttributeValue(RECURSIVE_ATTR); |
| final OrderRootType rootType = getJarDirectoryRootType(jarDir.getAttributeValue(ROOT_TYPE_ATTR)); |
| if (url != null) { |
| add(rootType, url, Boolean.valueOf(Boolean.parseBoolean(recursive))); |
| } |
| } |
| } |
| |
| private static OrderRootType getJarDirectoryRootType(@Nullable String type) { |
| for (PersistentOrderRootType rootType : OrderRootType.getAllPersistentTypes()) { |
| if (rootType.name().equals(type)) { |
| return rootType; |
| } |
| } |
| return DEFAULT_JAR_DIRECTORY_TYPE; |
| } |
| |
| @Override |
| public void writeExternal(Element element) { |
| final List<OrderRootType> rootTypes = LibraryImpl.sortRootTypes(getRootTypes()); |
| for (OrderRootType rootType : rootTypes) { |
| final List<String> urls = new ArrayList<String>(getDirectories(rootType)); |
| Collections.sort(urls, String.CASE_INSENSITIVE_ORDER); |
| for (String url : urls) { |
| final Element jarDirElement = new Element(JAR_DIRECTORY_ELEMENT); |
| jarDirElement.setAttribute(URL_ATTR, url); |
| jarDirElement.setAttribute(RECURSIVE_ATTR, Boolean.toString(isRecursive(rootType, url))); |
| if (!rootType.equals(DEFAULT_JAR_DIRECTORY_TYPE)) { |
| jarDirElement.setAttribute(ROOT_TYPE_ATTR, rootType.name()); |
| } |
| element.addContent(jarDirElement); |
| } |
| } |
| } |
| |
| } |