MDS/openide
1
0
Fork 0
mirror of https://gitflic.ru/project/openide/openide.git synced 2026-09-18 09:34:34 +07:00
Code Issues Packages Projects Releases Wiki Activity

implemented read access to library which delegates to the new project model

Browse Source
This commit is contained in:
nik
2012-06-19 15:39:45 +04:00
parent c79915b70a
commit b0012df3fb
24 changed files with 649 additions and 137 deletions
Download Patch File Download Diff File Expand all files Collapse all files
jps/model-api/src/org/jetbrains/jps/model/JpsGlobal.java
+3 -1
View File
@@ -2,6 +2,7 @@ package org.jetbrains.jps.model;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.model.library.JpsLibrary;
import org.jetbrains.jps.model.library.JpsLibraryCollection;
import org.jetbrains.jps.model.library.JpsLibraryType;
/**
@@ -11,5 +12,6 @@ public interface JpsGlobal extends JpsCompositeElement, JpsReferenceableElement<
@NotNull
JpsLibrary addLibrary(@NotNull JpsLibraryType libraryType, final @NotNull String name);
@NotNull
JpsLibraryCollection getLibraryCollection();
}
jps/model-api/src/org/jetbrains/jps/model/JpsProject.java
+8 -8
View File
@@ -2,6 +2,7 @@ package org.jetbrains.jps.model;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.model.library.JpsLibrary;
import org.jetbrains.jps.model.library.JpsLibraryCollection;
import org.jetbrains.jps.model.library.JpsLibraryType;
import org.jetbrains.jps.model.module.JpsModule;
import org.jetbrains.jps.model.module.JpsModuleType;
@@ -16,16 +17,15 @@ public interface JpsProject extends JpsCompositeElement, JpsReferenceableElement
@NotNull
JpsModule addModule(@NotNull JpsModuleType<?> moduleType, @NotNull String name);
void addModule(@NotNull JpsModule module);
@NotNull
List<JpsModule> getModules();
@NotNull
JpsLibrary addLibrary(@NotNull JpsLibraryType<?> libraryType, @NotNull String name);
@NotNull
List<? extends JpsLibrary> getLibraries();
@NotNull
List<? extends JpsModule> getModules();
void addModule(JpsModule module);
void addLibrary(JpsLibrary library);
JpsLibraryCollection getLibraryCollection();
}
jps/model-api/src/org/jetbrains/jps/model/library/JpsLibrary.java
+5 -3
View File
@@ -12,11 +12,13 @@ import java.util.List;
public interface JpsLibrary extends JpsNamedElement, JpsReferenceableElement<JpsLibrary> {
@NotNull
List<String> getUrls(@NotNull JpsLibraryRootType rootType);
List<JpsLibraryRoot> getRoots(@NotNull JpsOrderRootType rootType);
void addUrl(@NotNull String url, @NotNull JpsLibraryRootType rootType);
void addRoot(@NotNull String url, @NotNull JpsOrderRootType rootType);
void removeUrl(@NotNull String url, @NotNull JpsLibraryRootType rootType);
void addRoot(@NotNull String url, @NotNull JpsOrderRootType rootType, @NotNull JpsLibraryRoot.InclusionOptions options);
void removeUrl(@NotNull String url, @NotNull JpsOrderRootType rootType);
void delete();
jps/model-api/src/org/jetbrains/jps/model/library/JpsLibraryCollection.java
+18
View File
@@ -0,0 +1,18 @@
package org.jetbrains.jps.model.library;
import org.jetbrains.annotations.NotNull;
import java.util.List;
/**
* @author nik
*/
public interface JpsLibraryCollection {
@NotNull
JpsLibrary addLibrary(@NotNull JpsLibraryType<?> libraryType, @NotNull String name);
@NotNull
List<JpsLibrary> getLibraries();
void addLibrary(@NotNull JpsLibrary library);
}
jps/model-api/src/org/jetbrains/jps/model/library/JpsLibraryRoot.java
+6 -1
View File
@@ -8,11 +8,16 @@ import org.jetbrains.jps.model.JpsElement;
*/
public interface JpsLibraryRoot extends JpsElement {
@NotNull
JpsLibraryRootType getRootType();
JpsOrderRootType getRootType();
@NotNull
String getUrl();
@NotNull
InclusionOptions getInclusionOptions();
@NotNull
JpsLibrary getLibrary();
enum InclusionOptions {ROOT_ITSELF, ARCHIVES_UNDER_ROOT, ARCHIVES_UNDER_ROOT_RECURSIVELY}
}
jps/model-api/src/org/jetbrains/jps/model/library/JpsLibraryRootType.java
-30
View File
@@ -1,30 +0,0 @@
package org.jetbrains.jps.model.library;
/**
* @author nik
*/
public class JpsLibraryRootType {
public static final JpsLibraryRootType COMPILED = new JpsLibraryRootType(JpsOrderRootType.COMPILED, false, false);
public static final JpsLibraryRootType SOURCES = new JpsLibraryRootType(JpsOrderRootType.SOURCES, false, false);
private final boolean myJarDirectory;
private final boolean myRecursive;
private final JpsOrderRootType myType;
public JpsLibraryRootType(JpsOrderRootType type, boolean jarDirectory, boolean recursive) {
myJarDirectory = jarDirectory;
myRecursive = recursive;
myType = type;
}
public boolean isJarDirectory() {
return myJarDirectory;
}
public JpsOrderRootType getType() {
return myType;
}
public boolean isRecursive() {
return myRecursive;
}
}
jps/model-api/src/org/jetbrains/jps/model/module/JpsModule.java
+6 -3
View File
@@ -3,6 +3,7 @@ package org.jetbrains.jps.model.module;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.model.*;
import org.jetbrains.jps.model.library.JpsLibrary;
import org.jetbrains.jps.model.library.JpsLibraryCollection;
import org.jetbrains.jps.model.library.JpsLibraryType;
import java.util.List;
@@ -42,11 +43,13 @@ public interface JpsModule extends JpsNamedElement, JpsReferenceableElement<JpsM
@NotNull
JpsLibrary addModuleLibrary(@NotNull JpsLibraryType<?> type, @NotNull String name);
@NotNull
JpsLibrary addModuleLibrary(@NotNull JpsLibrary library);
void addModuleLibrary(@NotNull JpsLibrary library);
void delete();
@NotNull
JpsLibraryCollection getLibraryCollection();
@NotNull
JpsSdkReferencesTable getSdkReferencesTable();
void delete();
}
jps/model-impl/src/org/jetbrains/jps/model/impl/JpsGlobalImpl.java
+17 -5
View File
@@ -1,30 +1,42 @@
package org.jetbrains.jps.model.impl;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.model.*;
import org.jetbrains.jps.model.JpsElementReference;
import org.jetbrains.jps.model.JpsEventDispatcher;
import org.jetbrains.jps.model.JpsGlobal;
import org.jetbrains.jps.model.JpsModel;
import org.jetbrains.jps.model.library.JpsLibrary;
import org.jetbrains.jps.model.library.JpsLibraryCollection;
import org.jetbrains.jps.model.library.JpsLibraryType;
import org.jetbrains.jps.model.library.impl.JpsLibraryImpl;
import org.jetbrains.jps.model.library.impl.JpsLibraryCollectionImpl;
import org.jetbrains.jps.model.library.impl.JpsLibraryKind;
/**
* @author nik
*/
public class JpsGlobalImpl extends JpsRootElementBase<JpsGlobalImpl> implements JpsGlobal {
private final JpsLibraryCollectionImpl myLibraryCollection;
public JpsGlobalImpl(JpsModel model, JpsEventDispatcher eventDispatcher) {
super(model, eventDispatcher);
myContainer.setChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND);
myLibraryCollection = new JpsLibraryCollectionImpl(myContainer.setChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND));
}
public JpsGlobalImpl(JpsGlobalImpl original, JpsModel model, JpsEventDispatcher eventDispatcher) {
super(original, model, eventDispatcher);
myLibraryCollection = new JpsLibraryCollectionImpl(myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND));
}
@NotNull
@Override
public JpsLibrary addLibrary(@NotNull JpsLibraryType libraryType, @NotNull final String name) {
final JpsElementCollectionImpl<JpsLibrary> collection = myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND);
return collection.addChild(new JpsLibraryImpl(name, libraryType));
return myLibraryCollection.addLibrary(libraryType, name);
}
@NotNull
@Override
public JpsLibraryCollection getLibraryCollection() {
return myLibraryCollection;
}
@NotNull
jps/model-impl/src/org/jetbrains/jps/model/impl/JpsProjectImpl.java
+15 -15
View File
@@ -1,10 +1,14 @@
package org.jetbrains.jps.model.impl;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.model.*;
import org.jetbrains.jps.model.JpsElementReference;
import org.jetbrains.jps.model.JpsEventDispatcher;
import org.jetbrains.jps.model.JpsModel;
import org.jetbrains.jps.model.JpsProject;
import org.jetbrains.jps.model.library.JpsLibrary;
import org.jetbrains.jps.model.library.JpsLibraryCollection;
import org.jetbrains.jps.model.library.JpsLibraryType;
import org.jetbrains.jps.model.library.impl.JpsLibraryImpl;
import org.jetbrains.jps.model.library.impl.JpsLibraryCollectionImpl;
import org.jetbrains.jps.model.library.impl.JpsLibraryKind;
import org.jetbrains.jps.model.module.JpsModule;
import org.jetbrains.jps.model.module.JpsModuleType;
@@ -19,16 +23,18 @@ import java.util.List;
public class JpsProjectImpl extends JpsRootElementBase<JpsProjectImpl> implements JpsProject {
private static final JpsElementCollectionKind<JpsElementReference<?>> EXTERNAL_REFERENCES_COLLECTION_KIND =
new JpsElementCollectionKind<JpsElementReference<?>>(new JpsElementKindBase<JpsElementReference<?>>("external reference"));
private final JpsLibraryCollection myLibraryCollection;
public JpsProjectImpl(JpsModel model, JpsEventDispatcher eventDispatcher) {
super(model, eventDispatcher);
myContainer.setChild(JpsModuleKind.MODULE_COLLECTION_KIND);
myContainer.setChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND);
myContainer.setChild(EXTERNAL_REFERENCES_COLLECTION_KIND);
myLibraryCollection = new JpsLibraryCollectionImpl(myContainer.setChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND));
}
public JpsProjectImpl(JpsProjectImpl original, JpsModel model, JpsEventDispatcher eventDispatcher) {
super(original, model, eventDispatcher);
myLibraryCollection = new JpsLibraryCollectionImpl(myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND));
}
public void addExternalReference(@NotNull JpsElementReference<?> reference) {
@@ -45,30 +51,24 @@ public class JpsProjectImpl extends JpsRootElementBase<JpsProjectImpl> implement
@NotNull
@Override
public JpsLibrary addLibrary(@NotNull JpsLibraryType<?> libraryType, @NotNull final String name) {
final JpsElementCollectionImpl<JpsLibrary> collection = myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND);
return collection.addChild(new JpsLibraryImpl(name, libraryType));
return myLibraryCollection.addLibrary(libraryType, name);
}
@NotNull
@Override
public List<? extends JpsLibrary> getLibraries() {
return myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND).getElements();
}
@NotNull
@Override
public List<? extends JpsModule> getModules() {
public List<JpsModule> getModules() {
return myContainer.getChild(JpsModuleKind.MODULE_COLLECTION_KIND).getElements();
}
@Override
public void addModule(JpsModule module) {
public void addModule(@NotNull JpsModule module) {
myContainer.getChild(JpsModuleKind.MODULE_COLLECTION_KIND).addChild(module);
}
@NotNull
@Override
public void addLibrary(JpsLibrary library) {
myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND).addChild(library);
public JpsLibraryCollection getLibraryCollection() {
return myLibraryCollection;
}
@NotNull
jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryCollectionImpl.java
+37
View File
@@ -0,0 +1,37 @@
package org.jetbrains.jps.model.library.impl;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.model.JpsElementCollection;
import org.jetbrains.jps.model.library.JpsLibrary;
import org.jetbrains.jps.model.library.JpsLibraryCollection;
import org.jetbrains.jps.model.library.JpsLibraryType;
import java.util.List;
/**
* @author nik
*/
public class JpsLibraryCollectionImpl implements JpsLibraryCollection {
private final JpsElementCollection<JpsLibrary> myCollection;
public JpsLibraryCollectionImpl(JpsElementCollection<JpsLibrary> collection) {
myCollection = collection;
}
@NotNull
@Override
public JpsLibrary addLibrary(@NotNull JpsLibraryType<?> libraryType, @NotNull String name) {
return myCollection.addChild(new JpsLibraryImpl(name, libraryType));
}
@NotNull
@Override
public List<JpsLibrary> getLibraries() {
return myCollection.getElements();
}
@Override
public void addLibrary(@NotNull JpsLibrary library) {
myCollection.addChild(library);
}
}
jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryImpl.java
+17 -21
View File
@@ -3,20 +3,16 @@ package org.jetbrains.jps.model.library.impl;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.model.*;
import org.jetbrains.jps.model.impl.*;
import org.jetbrains.jps.model.library.JpsLibrary;
import org.jetbrains.jps.model.library.JpsLibraryReference;
import org.jetbrains.jps.model.library.JpsLibraryRootType;
import org.jetbrains.jps.model.library.JpsLibraryType;
import org.jetbrains.jps.model.library.*;
import java.util.ArrayList;
import java.util.List;
/**
* @author nik
*/
public class JpsLibraryImpl extends JpsNamedCompositeElementBase<JpsLibraryImpl, JpsProjectImpl> implements JpsLibrary {
private static final JpsElementCollectionKind<JpsLibraryRootImpl> LIBRARY_ROOTS_COLLECTION =
new JpsElementCollectionKind<JpsLibraryRootImpl>(JpsLibraryRootKind.INSTANCE);
private static final JpsElementCollectionKind<JpsLibraryRoot> LIBRARY_ROOTS_COLLECTION =
new JpsElementCollectionKind<JpsLibraryRoot>(JpsLibraryRootKind.INSTANCE);
private static final JpsTypedDataKind<JpsLibraryType<?>> TYPED_DATA_KIND = new JpsTypedDataKind<JpsLibraryType<?>>();
public JpsLibraryImpl(@NotNull String name, @NotNull JpsLibraryType<?> type) {
@@ -31,29 +27,29 @@ public class JpsLibraryImpl extends JpsNamedCompositeElementBase<JpsLibraryImpl,
@NotNull
@Override
public List<String> getUrls(@NotNull JpsLibraryRootType rootType) {
final List<String> urls = new ArrayList<String>();
for (JpsLibraryRootImpl root : getRootsCollection().getElements()) {
if (root.getRootType().equals(rootType)) {
urls.add(root.getUrl());
}
}
return urls;
public List<JpsLibraryRoot> getRoots(@NotNull JpsOrderRootType rootType) {
return getRootsCollection().getElements();
}
@Override
public void addUrl(@NotNull final String url, @NotNull final JpsLibraryRootType rootType) {
getRootsCollection().addChild(new JpsLibraryRootImpl(url, rootType));
public void addRoot(@NotNull String url, @NotNull JpsOrderRootType rootType) {
addRoot(url, rootType, JpsLibraryRoot.InclusionOptions.ROOT_ITSELF);
}
private JpsElementCollectionImpl<JpsLibraryRootImpl> getRootsCollection() {
@Override
public void addRoot(@NotNull final String url, @NotNull final JpsOrderRootType rootType,
@NotNull JpsLibraryRoot.InclusionOptions options) {
getRootsCollection().addChild(new JpsLibraryRootImpl(url, rootType, options));
}
private JpsElementCollectionImpl<JpsLibraryRoot> getRootsCollection() {
return myContainer.getChild(LIBRARY_ROOTS_COLLECTION);
}
@Override
public void removeUrl(@NotNull final String url, @NotNull final JpsLibraryRootType rootType) {
final JpsElementCollectionImpl<JpsLibraryRootImpl> rootsCollection = getRootsCollection();
for (JpsLibraryRootImpl root : rootsCollection.getElements()) {
public void removeUrl(@NotNull final String url, @NotNull final JpsOrderRootType rootType) {
final JpsElementCollection<JpsLibraryRoot> rootsCollection = getRootsCollection();
for (JpsLibraryRoot root : rootsCollection.getElements()) {
if (root.getUrl().equals(url) && root.getRootType().equals(rootType)) {
rootsCollection.removeChild(root);
break;
jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryRootImpl.java
+13 -5
View File
@@ -4,29 +4,31 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.model.impl.JpsElementBase;
import org.jetbrains.jps.model.library.JpsLibrary;
import org.jetbrains.jps.model.library.JpsLibraryRoot;
import org.jetbrains.jps.model.library.JpsLibraryRootType;
import org.jetbrains.jps.model.library.JpsOrderRootType;
/**
* @author nik
*/
public class JpsLibraryRootImpl extends JpsElementBase<JpsLibraryRootImpl> implements JpsLibraryRoot {
private final String myUrl;
private final JpsLibraryRootType myRootType;
private final JpsOrderRootType myRootType;
private final InclusionOptions myOptions;
public JpsLibraryRootImpl(@NotNull String url,
@NotNull JpsLibraryRootType rootType) {
public JpsLibraryRootImpl(@NotNull String url, @NotNull JpsOrderRootType rootType, @NotNull InclusionOptions options) {
myUrl = url;
myRootType = rootType;
myOptions = options;
}
public JpsLibraryRootImpl(JpsLibraryRootImpl original) {
myUrl = original.myUrl;
myRootType = original.myRootType;
myOptions = original.myOptions;
}
@NotNull
@Override
public JpsLibraryRootType getRootType() {
public JpsOrderRootType getRootType() {
return myRootType;
}
@@ -35,6 +37,12 @@ public class JpsLibraryRootImpl extends JpsElementBase<JpsLibraryRootImpl> imple
return myUrl;
}
@NotNull
@Override
public InclusionOptions getInclusionOptions() {
return myOptions;
}
@NotNull
@Override
public JpsLibraryRootImpl createCopy() {
jps/model-impl/src/org/jetbrains/jps/model/library/impl/JpsLibraryRootKind.java
+5 -4
View File
@@ -1,14 +1,15 @@
package org.jetbrains.jps.model.library.impl;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.model.impl.JpsElementKindBase;
import org.jetbrains.jps.model.JpsEventDispatcher;
import org.jetbrains.jps.model.impl.JpsElementKindBase;
import org.jetbrains.jps.model.library.JpsLibraryRoot;
import org.jetbrains.jps.model.library.JpsLibraryRootListener;
/**
* @author nik
*/
public class JpsLibraryRootKind extends JpsElementKindBase<JpsLibraryRootImpl> {
public class JpsLibraryRootKind extends JpsElementKindBase<JpsLibraryRoot> {
public static final JpsLibraryRootKind INSTANCE = new JpsLibraryRootKind();
public JpsLibraryRootKind() {
@@ -16,12 +17,12 @@ public class JpsLibraryRootKind extends JpsElementKindBase<JpsLibraryRootImpl> {
}
@Override
public void fireElementAdded(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsLibraryRootImpl element) {
public void fireElementAdded(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsLibraryRoot element) {
dispatcher.getPublisher(JpsLibraryRootListener.class).rootAdded(element);
}
@Override
public void fireElementRemoved(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsLibraryRootImpl element) {
public void fireElementRemoved(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsLibraryRoot element) {
dispatcher.getPublisher(JpsLibraryRootListener.class).rootRemoved(element);
}
}
jps/model-impl/src/org/jetbrains/jps/model/module/impl/JpsModuleImpl.java
+17 -8
View File
@@ -1,11 +1,14 @@
package org.jetbrains.jps.model.module.impl;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.model.*;
import org.jetbrains.jps.model.JpsElementKind;
import org.jetbrains.jps.model.JpsElementProperties;
import org.jetbrains.jps.model.JpsUrlList;
import org.jetbrains.jps.model.impl.*;
import org.jetbrains.jps.model.library.JpsLibrary;
import org.jetbrains.jps.model.library.JpsLibraryCollection;
import org.jetbrains.jps.model.library.JpsLibraryType;
import org.jetbrains.jps.model.library.impl.JpsLibraryImpl;
import org.jetbrains.jps.model.library.impl.JpsLibraryCollectionImpl;
import org.jetbrains.jps.model.library.impl.JpsLibraryKind;
import org.jetbrains.jps.model.module.*;
@@ -18,8 +21,8 @@ public class JpsModuleImpl extends JpsNamedCompositeElementBase<JpsModuleImpl, J
private static final JpsTypedDataKind<JpsModuleType<?>> TYPED_DATA_KIND = new JpsTypedDataKind<JpsModuleType<?>>();
private static final JpsUrlListKind CONTENT_ROOTS_KIND = new JpsUrlListKind("content roots");
private static final JpsUrlListKind EXCLUDED_ROOTS_KIND = new JpsUrlListKind("excluded roots");
public static final JpsElementKind<JpsDependenciesListImpl> DEPENDENCIES_LIST_KIND =
new JpsElementKindBase<JpsDependenciesListImpl>("dependencies");
public static final JpsElementKind<JpsDependenciesListImpl> DEPENDENCIES_LIST_KIND = new JpsElementKindBase<JpsDependenciesListImpl>("dependencies");
private final JpsLibraryCollection myLibraryCollection;
public JpsModuleImpl(JpsModuleType type,
@NotNull String name) {
@@ -28,13 +31,14 @@ public class JpsModuleImpl extends JpsNamedCompositeElementBase<JpsModuleImpl, J
myContainer.setChild(CONTENT_ROOTS_KIND);
myContainer.setChild(EXCLUDED_ROOTS_KIND);
myContainer.setChild(DEPENDENCIES_LIST_KIND, new JpsDependenciesListImpl());
myContainer.setChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND);
myLibraryCollection = new JpsLibraryCollectionImpl(myContainer.setChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND));
myContainer.setChild(JpsModuleSourceRootKind.ROOT_COLLECTION_KIND);
myContainer.setChild(JpsSdkReferencesTableImpl.KIND, new JpsSdkReferencesTableImpl());
}
private JpsModuleImpl(JpsModuleImpl original) {
super(original);
myLibraryCollection = new JpsLibraryCollectionImpl(myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND));
}
@NotNull
@@ -116,12 +120,17 @@ public class JpsModuleImpl extends JpsNamedCompositeElementBase<JpsModuleImpl, J
@NotNull
@Override
public JpsLibrary addModuleLibrary(@NotNull JpsLibraryType<?> type, @NotNull String name) {
return addModuleLibrary(new JpsLibraryImpl(name, type));
return myLibraryCollection.addLibrary(type, name);
}
@Override
public void addModuleLibrary(final @NotNull JpsLibrary library) {
myLibraryCollection.addLibrary(library);
}
@NotNull
@Override
public JpsLibrary addModuleLibrary(final @NotNull JpsLibrary library) {
return myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND).addChild(library);
public JpsLibraryCollection getLibraryCollection() {
return myLibraryCollection;
}
}
jps/model-impl/testSrc/org/jetbrains/jps/model/JpsLibraryTest.java
+7 -9
View File
@@ -1,9 +1,7 @@
package org.jetbrains.jps.model;
import org.jetbrains.jps.model.java.JpsJavaLibraryType;
import org.jetbrains.jps.model.library.JpsLibrary;
import org.jetbrains.jps.model.library.JpsLibraryReference;
import org.jetbrains.jps.model.library.JpsLibraryRootType;
import org.jetbrains.jps.model.library.*;
/**
* @author nik
@@ -11,20 +9,20 @@ import org.jetbrains.jps.model.library.JpsLibraryRootType;
public class JpsLibraryTest extends JpsModelTestCase {
public void testAddRoot() {
final JpsLibrary library = myModel.getProject().addLibrary(JpsJavaLibraryType.INSTANCE, "a");
library.addUrl("file://my-url", JpsLibraryRootType.COMPILED);
assertEquals("file://my-url", assertOneElement(library.getUrls(JpsLibraryRootType.COMPILED)));
library.addRoot("file://my-url", JpsOrderRootType.COMPILED);
assertEquals("file://my-url", assertOneElement(library.getRoots(JpsOrderRootType.COMPILED)).getUrl());
}
public void testModifiableCopy() {
myModel.getProject().addLibrary(JpsJavaLibraryType.INSTANCE, "a");
final JpsModel modifiableModel = myModel.createModifiableModel(new TestJpsEventDispatcher());
final JpsLibrary modifiable = assertOneElement(modifiableModel.getProject().getLibraries());
modifiable.addUrl("file://my-url", JpsLibraryRootType.COMPILED);
final JpsLibrary modifiable = assertOneElement(modifiableModel.getProject().getLibraryCollection().getLibraries());
modifiable.addRoot("file://my-url", JpsOrderRootType.COMPILED);
modifiableModel.commit();
final JpsLibrary library = assertOneElement(myModel.getProject().getLibraries());
assertEquals("file://my-url", assertOneElement(library.getUrls(JpsLibraryRootType.COMPILED)));
final JpsLibrary library = assertOneElement(myModel.getProject().getLibraryCollection().getLibraries());
assertEquals("file://my-url", assertOneElement(library.getRoots(JpsOrderRootType.COMPILED)).getUrl());
}
public void testCreateReferenceByLibrary() {
jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsLibraryTableLoader.java
+10 -7
View File
@@ -5,10 +5,7 @@ import com.intellij.util.containers.MultiMap;
import org.jdom.Element;
import org.jetbrains.jps.model.JpsElementFactory;
import org.jetbrains.jps.model.java.JpsJavaLibraryType;
import org.jetbrains.jps.model.library.JpsLibrary;
import org.jetbrains.jps.model.library.JpsLibraryRootType;
import org.jetbrains.jps.model.library.JpsLibraryType;
import org.jetbrains.jps.model.library.JpsOrderRootType;
import org.jetbrains.jps.model.library.*;
import org.jetbrains.jps.service.JpsServiceManager;
import java.util.HashMap;
@@ -55,9 +52,15 @@ public class JpsLibraryTableLoader {
final JpsOrderRootType rootType = getRootType(rootTypeId);
for (Element rootElement : JDOMUtil.getChildren(rootsElement, "root")) {
String url = rootElement.getAttributeValue("url");
final boolean jarDirectory = jarDirectories.get(rootType).contains(url);
final boolean recursive = recursiveJarDirectories.get(rootType).contains(url);
library.addUrl(url, new JpsLibraryRootType(rootType, jarDirectory, recursive));
JpsLibraryRoot.InclusionOptions options;
if (jarDirectories.get(rootType).contains(url)) {
final boolean recursive = recursiveJarDirectories.get(rootType).contains(url);
options = recursive ? JpsLibraryRoot.InclusionOptions.ARCHIVES_UNDER_ROOT_RECURSIVELY : JpsLibraryRoot.InclusionOptions.ARCHIVES_UNDER_ROOT;
}
else {
options = JpsLibraryRoot.InclusionOptions.ROOT_ITSELF;
}
library.addRoot(url, rootType, options);
}
}
}
jps/model-serialization/src/org/jetbrains/jps/model/serialization/JpsProjectLoader.java
+1 -1
View File
@@ -103,7 +103,7 @@ public class JpsProjectLoader {
final ArrayList<JpsLibrary> libraries = new ArrayList<JpsLibrary>();
JpsLibraryTableLoader.loadLibraries(libraryTableElement, libraries);
for (JpsLibrary library : libraries) {
myProject.addLibrary(library);
myProject.getLibraryCollection().addLibrary(library);
}
}
jps/model-serialization/testSrc/org/jetbrains/jps/model/serialization/JpsModuleSerializationTest.java
+1 -1
View File
@@ -15,7 +15,7 @@ public class JpsModuleSerializationTest extends JpsModelTestCase {
loadProject("iprProject/iprProject.ipr");
final JpsModule module = assertOneElement(myModel.getProject().getModules());
assertEquals("iprProject", module.getName());
final JpsLibrary library = assertOneElement(myModel.getProject().getLibraries());
final JpsLibrary library = assertOneElement(myModel.getProject().getLibraryCollection().getLibraries());
assertEquals("junit", library.getName());
}
platform/projectModel-impl/src/com/intellij/project/model/impl/library/JpsLibraryDelegate.java
+209
View File
@@ -0,0 +1,209 @@
/*
* Copyright 2000-2012 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.project.model.impl.library;
import com.intellij.openapi.roots.OrderRootType;
import com.intellij.openapi.roots.RootProvider;
import com.intellij.openapi.roots.impl.RootModelImpl;
import com.intellij.openapi.roots.impl.RootProviderBaseImpl;
import com.intellij.openapi.roots.impl.libraries.JarDirectories;
import com.intellij.openapi.roots.impl.libraries.LibraryEx;
import com.intellij.openapi.roots.impl.libraries.LibraryImpl;
import com.intellij.openapi.roots.libraries.Library;
import com.intellij.openapi.roots.libraries.LibraryProperties;
import com.intellij.openapi.roots.libraries.LibraryTable;
import com.intellij.openapi.roots.libraries.PersistentLibraryKind;
import com.intellij.openapi.util.InvalidDataException;
import com.intellij.openapi.util.WriteExternalException;
import com.intellij.openapi.vfs.VfsUtilCore;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.openapi.vfs.pointers.VirtualFilePointer;
import com.intellij.openapi.vfs.pointers.VirtualFilePointerContainer;
import com.intellij.util.ArrayUtil;
import com.intellij.util.SmartList;
import org.jdom.Element;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jps.model.library.JpsLibrary;
import org.jetbrains.jps.model.library.JpsLibraryRoot;
import org.jetbrains.jps.model.library.JpsOrderRootType;
import java.util.*;
/**
* @author nik
*/
public class JpsLibraryDelegate implements LibraryEx {
private JpsLibrary myJpsLibrary;
private JpsLibraryTableImpl myLibraryTable;
private Map<OrderRootType, VirtualFilePointerContainer> myRoots;
private RootProviderBaseImpl myRootProvider = new MyRootProvider();
public JpsLibraryDelegate(JpsLibrary library, JpsLibraryTableImpl table) {
myJpsLibrary = library;
myLibraryTable = table;
myRoots = new HashMap<OrderRootType, VirtualFilePointerContainer>();
}
@Override
public String getName() {
return myJpsLibrary.getName();
}
@Override
public PersistentLibraryKind<?> getKind() {
return null;
}
@Override
public LibraryProperties getProperties() {
return null;
}
@NotNull
@Override
public String[] getUrls(@NotNull OrderRootType rootType) {
final VirtualFilePointerContainer container = myRoots.get(rootType);
if (container == null) return ArrayUtil.EMPTY_STRING_ARRAY;
return container.getUrls();
}
@NotNull
@Override
public VirtualFile[] getFiles(@NotNull OrderRootType rootType) {
final VirtualFilePointerContainer container = myRoots.get(rootType);
if (container == null) return VirtualFile.EMPTY_ARRAY;
final List<VirtualFile> expanded = new ArrayList<VirtualFile>();
for (JpsLibraryRoot root : myJpsLibrary.getRoots(getJpsRootType(rootType))) {
final VirtualFilePointer pointer = container.findByUrl(root.getUrl());
if (pointer == null) continue;
VirtualFile file = pointer.getFile();
if (file == null) continue;
if (file.isDirectory() && root.getInclusionOptions() != JpsLibraryRoot.InclusionOptions.ROOT_ITSELF) {
LibraryImpl.collectJarFiles(file, expanded, root.getInclusionOptions() == JpsLibraryRoot.InclusionOptions.ARCHIVES_UNDER_ROOT_RECURSIVELY);
continue;
}
expanded.add(file);
}
return VfsUtilCore.toVirtualFileArray(expanded);
}
@Override
public List<String> getInvalidRootUrls(OrderRootType type) {
final VirtualFilePointerContainer container = myRoots.get(type);
if (container == null) return Collections.emptyList();
final List<VirtualFilePointer> pointers = container.getList();
List<String> invalidPaths = null;
for (VirtualFilePointer pointer : pointers) {
if (!pointer.isValid()) {
if (invalidPaths == null) {
invalidPaths = new SmartList<String>();
}
invalidPaths.add(pointer.getUrl());
}
}
return invalidPaths == null ? Collections.<String>emptyList() : invalidPaths;
}
@Override
public boolean isDisposed() {
return false;
}
@Override
public LibraryTable getTable() {
return myLibraryTable;
}
@NotNull
@Override
public RootProvider getRootProvider() {
return myRootProvider;
}
@Override
public void dispose() {
}
@Override
public Library cloneLibrary(RootModelImpl rootModel) {
throw new UnsupportedOperationException("'cloneLibrary' not implemented in " + getClass().getName());
}
@NotNull
@Override
public ModifiableModel getModifiableModel() {
throw new UnsupportedOperationException("'getModifiableModel' not implemented in " + getClass().getName());
}
@Override
public void readExternal(Element element) throws InvalidDataException {
throw new UnsupportedOperationException();
}
@Override
public void writeExternal(Element element) throws WriteExternalException {
throw new UnsupportedOperationException();
}
@Override
public boolean isJarDirectory(@NotNull String url) {
return isJarDirectory(url, JarDirectories.DEFAULT_JAR_DIRECTORY_TYPE);
}
@Override
public boolean isJarDirectory(@NotNull String url, @NotNull OrderRootType rootType) {
for (JpsLibraryRoot root : myJpsLibrary.getRoots(getJpsRootType(rootType))) {
if (url.equals(root.getUrl()) && root.getInclusionOptions() != JpsLibraryRoot.InclusionOptions.ROOT_ITSELF) {
return true;
}
}
return false;
}
@Override
public boolean isValid(@NotNull String url, @NotNull OrderRootType rootType) {
final VirtualFilePointerContainer container = myRoots.get(rootType);
if (container == null) return false;
final VirtualFilePointer fp = container.findByUrl(url);
return fp != null && fp.isValid();
}
private static JpsOrderRootType getJpsRootType(OrderRootType type) {
if (type == OrderRootType.CLASSES) return JpsOrderRootType.COMPILED;
if (type == OrderRootType.SOURCES) return JpsOrderRootType.SOURCES;
if (type == OrderRootType.DOCUMENTATION) return JpsOrderRootType.DOCUMENTATION;
return JpsOrderRootType.COMPILED;
}
private class MyRootProvider extends RootProviderBaseImpl {
@NotNull
@Override
public String[] getUrls(@NotNull OrderRootType rootType) {
Set<String> originalUrls = new LinkedHashSet<String>(Arrays.asList(JpsLibraryDelegate.this.getUrls(rootType)));
for (VirtualFile file : getFiles(rootType)) { // Add those expanded with jar directories.
originalUrls.add(file.getUrl());
}
return ArrayUtil.toStringArray(originalUrls);
}
@NotNull
@Override
public VirtualFile[] getFiles(@NotNull OrderRootType rootType) {
return JpsLibraryDelegate.this.getFiles(rootType);
}
}
}
platform/projectModel-impl/src/com/intellij/project/model/impl/library/JpsLibraryTableImpl.java
+189
View File
@@ -0,0 +1,189 @@
/*
* Copyright 2000-2012 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.project.model.impl.library;
import com.intellij.openapi.Disposable;
import com.intellij.openapi.roots.impl.libraries.LibraryTableBase;
import com.intellij.openapi.roots.libraries.Library;
import com.intellij.openapi.roots.libraries.LibraryTable;
import com.intellij.openapi.roots.libraries.LibraryTablePresentation;
import com.intellij.openapi.roots.libraries.PersistentLibraryKind;
import com.intellij.openapi.util.Disposer;
import com.intellij.util.EventDispatcher;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jps.model.library.JpsLibrary;
import org.jetbrains.jps.model.library.JpsLibraryCollection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
/**
* @author nik
*/
public class JpsLibraryTableImpl implements LibraryTable, Disposable {
private JpsLibrariesModel myModel;
private final EventDispatcher<Listener> myDispatcher = EventDispatcher.create(Listener.class);
private String myTableLevel;
private LibraryTablePresentation myPresentation;
public JpsLibraryTableImpl(JpsLibraryCollection libraryCollection, String level) {
myTableLevel = level;
myModel = new JpsLibrariesModel(libraryCollection);
}
@NotNull
@Override
public Library[] getLibraries() {
return myModel.getLibraries();
}
@NotNull
@Override
public Iterator<Library> getLibraryIterator() {
return myModel.getLibraryIterator();
}
@Override
public Library getLibraryByName(@NotNull String name) {
return myModel.getLibraryByName(name);
}
@Override
public void addListener(Listener listener) {
myDispatcher.addListener(listener);
}
@Override
public void addListener(Listener listener, Disposable parentDisposable) {
myDispatcher.addListener(listener, parentDisposable);
}
@Override
public void removeListener(Listener listener) {
myDispatcher.removeListener(listener);
}
@Override
public Library createLibrary() {
return createLibrary(null);
}
@Override
public Library createLibrary(@NonNls String name) {
final ModifiableModel model = getModifiableModel();
final Library library = model.createLibrary(name);
model.commit();
return library;
}
@Override
public void removeLibrary(@NotNull Library library) {
final ModifiableModel model = getModifiableModel();
model.removeLibrary(library);
model.commit();
}
@Override
public void dispose() {
for (Library library : getLibraries()) {
Disposer.dispose(library);
}
}
@Override
public ModifiableModel getModifiableModel() {
return new JpsLibrariesModel(myModel.myJpsLibraries);
}
@Override
public boolean isEditable() {
return true;
}
@Override
public String getTableLevel() {
return myTableLevel;
}
@Override
public LibraryTablePresentation getPresentation() {
return myPresentation;
}
private class JpsLibrariesModel implements LibraryTableBase.ModifiableModelEx {
private JpsLibraryCollection myJpsLibraries;
private List<JpsLibraryDelegate> myLibraries;
private JpsLibrariesModel(JpsLibraryCollection libraryCollection) {
myLibraries = new ArrayList<JpsLibraryDelegate>();
myJpsLibraries = libraryCollection;
for (JpsLibrary library : libraryCollection.getLibraries()) {
myLibraries.add(new JpsLibraryDelegate(library, JpsLibraryTableImpl.this));
}
}
@Override
public Library createLibrary(String name) {
return createLibrary(name, null);
}
@Override
public Library createLibrary(String name, @Nullable PersistentLibraryKind type) {
throw new UnsupportedOperationException("'createLibrary' not implemented in " + getClass().getName());
}
@NotNull
@Override
public Iterator<Library> getLibraryIterator() {
return Collections.<Library>unmodifiableList(myLibraries).iterator();
}
@Override
public void removeLibrary(@NotNull Library library) {
throw new UnsupportedOperationException();
}
@NotNull
@Override
public Library[] getLibraries() {
return myLibraries.toArray(new Library[myLibraries.size()]);
}
@Override
public Library getLibraryByName(@NotNull String name) {
for (JpsLibraryDelegate library : myLibraries) {
if (name.equals(library.getName())) {
return library;
}
}
return null;
}
@Override
public void commit() {
throw new UnsupportedOperationException();
}
@Override
public boolean isChanged() {
return false;
}
}
}
platform/projectModel-impl/src/com/intellij/project/model/impl/module/content/JpsContentEntry.java
+44 -9
View File
@@ -31,6 +31,8 @@ import com.intellij.openapi.vfs.pointers.VirtualFilePointerManager;
import com.intellij.project.model.impl.module.JpsRootModel;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jps.model.java.JavaSourceRootProperties;
import org.jetbrains.jps.model.java.JavaSourceRootType;
import org.jetbrains.jps.model.module.JpsModule;
import org.jetbrains.jps.model.module.JpsModuleSourceRoot;
@@ -130,47 +132,80 @@ public class JpsContentEntry implements ContentEntry, Disposable {
@Override
public SourceFolder addSourceFolder(@NotNull VirtualFile file, boolean isTestSource) {
throw new UnsupportedOperationException("'addSourceFolder' not implemented in " + getClass().getName());
return addSourceFolder(file, isTestSource, "");
}
@Override
public SourceFolder addSourceFolder(@NotNull VirtualFile file, boolean isTestSource, @NotNull String packagePrefix) {
throw new UnsupportedOperationException("'addSourceFolder' not implemented in " + getClass().getName());
return addSourceFolder(file.getUrl(), isTestSource, packagePrefix);
}
private SourceFolder addSourceFolder(final String url, boolean isTestSource, String packagePrefix) {
final JavaSourceRootType rootType = isTestSource ? JavaSourceRootType.TEST_SOURCE : JavaSourceRootType.SOURCE;
final JpsModuleSourceRoot sourceRoot = myModule.addSourceRoot(rootType, url, new JavaSourceRootProperties(packagePrefix));
final JpsSourceFolder sourceFolder = new JpsSourceFolder(sourceRoot, this);
mySourceFolders.add(sourceFolder);
return sourceFolder;
}
@Override
public SourceFolder addSourceFolder(@NotNull String url, boolean isTestSource) {
throw new UnsupportedOperationException("'addSourceFolder' not implemented in " + getClass().getName());
return addSourceFolder(url, isTestSource, "");
}
@Override
public void removeSourceFolder(@NotNull SourceFolder sourceFolder) {
throw new UnsupportedOperationException();
final JpsSourceFolder folder = (JpsSourceFolder)sourceFolder;
mySourceFolders.remove(folder);
myModule.removeSourceRoot(folder.getSourceRoot().getRootType(), folder.getSourceRoot().getUrl());
Disposer.dispose(folder);
}
@Override
public void clearSourceFolders() {
throw new UnsupportedOperationException();
List<JpsModuleSourceRoot> toRemove = new ArrayList<JpsModuleSourceRoot>();
for (JpsSourceFolder folder : mySourceFolders) {
toRemove.add(folder.getSourceRoot());
Disposer.dispose(folder);
}
mySourceFolders.clear();
for (JpsModuleSourceRoot root : toRemove) {
myModule.removeSourceRoot(root.getRootType(), root.getUrl());
}
}
@Override
public ExcludeFolder addExcludeFolder(@NotNull VirtualFile file) {
throw new UnsupportedOperationException("'addExcludeFolder' not implemented in " + getClass().getName());
return addExcludeFolder(file.getUrl());
}
@Override
public ExcludeFolder addExcludeFolder(@NotNull String url) {
throw new UnsupportedOperationException("'addExcludeFolder' not implemented in " + getClass().getName());
final JpsExcludeFolder folder = new JpsExcludeFolder(url, this);
myModule.getExcludeRootsList().addUrl(url);
myExcludeFolders.add(folder);
return folder;
}
@Override
public void removeExcludeFolder(@NotNull ExcludeFolder excludeFolder) {
throw new UnsupportedOperationException();
JpsExcludeFolder folder = (JpsExcludeFolder)excludeFolder;
myExcludeFolders.remove(folder);
myModule.getExcludeRootsList().removeUrl(folder.getUrl());
Disposer.dispose(folder);
}
@Override
public void clearExcludeFolders() {
throw new UnsupportedOperationException();
List<String> toRemove = new ArrayList<String>();
for (JpsExcludeFolder folder : myExcludeFolders) {
toRemove.add(folder.getUrl());
Disposer.dispose(folder);
}
myExcludeFolders.clear();
for (String url : toRemove) {
myModule.getExcludeRootsList().removeUrl(url);
}
}
@Override
platform/projectModel-impl/src/com/intellij/project/model/impl/module/content/JpsSourceFolder.java
+4
View File
@@ -32,6 +32,10 @@ public class JpsSourceFolder extends JpsContentFolderBase implements SourceFolde
mySourceRoot = sourceRoot;
}
public JpsModuleSourceRoot getSourceRoot() {
return mySourceRoot;
}
@Override
public boolean isTestSource() {
return mySourceRoot.getRootType() == JavaSourceRootType.TEST_SOURCE;
platform/projectModel-impl/src/com/intellij/project/model/impl/module/dependencies/JpsExportableOrderEntry.java
+2 -2
View File
@@ -56,7 +56,7 @@ public abstract class JpsExportableOrderEntry<E extends JpsDependencyElement> ex
@Override
public void setScope(@NotNull DependencyScope scope) {
JpsJavaExtensionService.getInstance().getOrCreateDependencyExtension(myDependencyElement)
.setScope(JpsJavaDependencyScope.valueOf(scope.name()));
final JpsJavaDependencyExtension extension = JpsJavaExtensionService.getInstance().getOrCreateDependencyExtension(myDependencyElement);
extension.setScope(JpsJavaDependencyScope.valueOf(scope.name()));
}
}
platform/projectModel-impl/src/com/intellij/project/model/impl/module/dependencies/JpsModuleOrderEntry.java
+15 -4
View File
@@ -18,10 +18,13 @@ package com.intellij.project.model.impl.module.dependencies;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.roots.ModuleOrderEntry;
import com.intellij.openapi.roots.OrderRootType;
import com.intellij.openapi.roots.OrderRootsEnumerator;
import com.intellij.openapi.roots.RootPolicy;
import com.intellij.openapi.roots.impl.ModuleRootManagerImpl;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.project.model.JpsModelManager;
import com.intellij.project.model.impl.module.JpsRootModel;
import com.intellij.util.ArrayUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jps.model.module.JpsModule;
@@ -53,15 +56,23 @@ public class JpsModuleOrderEntry extends JpsExportableOrderEntry<JpsModuleDepend
}
@NotNull
@Override
public VirtualFile[] getFiles(OrderRootType type) {
throw new UnsupportedOperationException("'getFiles' not implemented in " + getClass().getName());
final OrderRootsEnumerator enumerator = getEnumerator(type);
return enumerator != null ? enumerator.getRoots() : VirtualFile.EMPTY_ARRAY;
}
@Nullable
private OrderRootsEnumerator getEnumerator(OrderRootType type) {
final Module module = getModule();
if (module == null) return null;
return ModuleRootManagerImpl.getCachingEnumeratorForType(type, module, true);
}
@NotNull
@Override
public String[] getUrls(OrderRootType rootType) {
throw new UnsupportedOperationException("'getUrls' not implemented in " + getClass().getName());
final OrderRootsEnumerator enumerator = getEnumerator(rootType);
return enumerator != null ? enumerator.getUrls() : ArrayUtil.EMPTY_STRING_ARRAY;
}
@Override