javadoc and external annotations roots moved from ModuleRootModel to a separate extension

java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/AnnotationsEditor.java

@@ -19,7 +19,7 @@ import com.intellij.openapi.fileChooser.FileChooser;
 import com.intellij.openapi.fileChooser.FileChooserDescriptor;
 import com.intellij.openapi.fileChooser.FileChooserDescriptorFactory;
 import com.intellij.openapi.project.ProjectBundle;
-import com.intellij.openapi.roots.AnnotationOrderRootType;
+import com.intellij.openapi.roots.JavaModuleExternalPaths;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.ui.*;
 import com.intellij.ui.components.JBLabel;
@@ -64,7 +64,7 @@ public class AnnotationsEditor extends ModuleElementsEditor {
       final TableItem item = ((MyTableModel)myTable.getModel()).getTableItemAt(row);
       urls[row] = item.getUrl();
     }
-    getModel().setRootUrls(AnnotationOrderRootType.getInstance(), urls);
+    getModel().getModuleExtension(JavaModuleExternalPaths.class).setExternalAnnotationUrls(urls);
   }
 
   public JComponent createComponentImpl() {
@@ -120,7 +120,7 @@ public class AnnotationsEditor extends ModuleElementsEditor {
 
   protected DefaultTableModel createModel() {
     final MyTableModel tableModel = new MyTableModel();
-    final String[] urls = getModel().getRootUrls(AnnotationOrderRootType.getInstance());
+    final String[] urls = getModel().getModuleExtension(JavaModuleExternalPaths.class).getExternalAnnotationsUrls();
     for (String javadocUrl : urls) {
       tableModel.addTableItem(new TableItem(javadocUrl));
     }

java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/JavadocEditor.java

@@ -21,7 +21,7 @@ import com.intellij.openapi.fileChooser.FileChooserDescriptor;
 import com.intellij.openapi.fileChooser.FileChooserDescriptorFactory;
 import com.intellij.openapi.project.ProjectBundle;
 import com.intellij.openapi.projectRoots.ui.Util;
-import com.intellij.openapi.roots.JavadocOrderRootType;
+import com.intellij.openapi.roots.JavaModuleExternalPaths;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.ui.*;
 import com.intellij.ui.components.JBLabel;
@@ -67,7 +67,7 @@ public class JavadocEditor extends ModuleElementsEditor {
       final TableItem item = ((MyTableModel)myTable.getModel()).getTableItemAt(row);
       urls[row] = item.getUrl();
     }
-    getModel().setRootUrls(JavadocOrderRootType.getInstance(), urls);
+    getModel().getModuleExtension(JavaModuleExternalPaths.class).setJavadocUrls(urls);
   }
 
   public JComponent createComponentImpl() {
@@ -139,7 +139,7 @@ public class JavadocEditor extends ModuleElementsEditor {
 
   protected DefaultTableModel createModel() {
     final MyTableModel tableModel = new MyTableModel();
-    final String[] javadocUrls = getModel().getRootUrls(JavadocOrderRootType.getInstance());
+    final String[] javadocUrls = getModel().getModuleExtension(JavaModuleExternalPaths.class).getJavadocUrls();
     for (String javadocUrl : javadocUrls) {
       tableModel.addTableItem(new TableItem(javadocUrl));
     }

java/java-impl/src/com/intellij/codeInsight/ExternalAnnotationsManagerImpl.java

@@ -494,8 +494,8 @@ public class ExternalAnnotationsManagerImpl extends ExternalAnnotationsManager {
     }
     else if (entry instanceof ModuleSourceOrderEntry) {
       final ModifiableRootModel model = ModuleRootManager.getInstance(entry.getOwnerModule()).getModifiableModel();
-      model.setRootUrls(AnnotationOrderRootType.getInstance(), ArrayUtil.mergeArrays(
-        model.getRootUrls(AnnotationOrderRootType.getInstance()), vFile.getUrl()));
+      final JavaModuleExternalPaths extension = model.getModuleExtension(JavaModuleExternalPaths.class);
+      extension.setExternalAnnotationUrls(ArrayUtil.mergeArrays(extension.getExternalAnnotationsUrls(), vFile.getUrl()));
       model.commit();
     }
     else if (entry instanceof JdkOrderEntry) {

java/java-impl/src/com/intellij/lang/java/JavaDocumentationProvider.java

@@ -666,7 +666,7 @@ public class JavaDocumentationProvider implements CodeDocumentationProvider, Ext
       }
     }
     if (module != null) {
-      String[] javadocPaths = ModuleRootManager.getInstance(module).getRootUrls(JavadocOrderRootType.getInstance());
+      String[] javadocPaths = JavaModuleExternalPaths.getInstance(module).getJavadocUrls();
       final List<String> httpRoots = PlatformDocumentationUtil.getHttpRoots(javadocPaths, relPath);
       // if found nothing and the file is from library classes, fall back to order entries
       if (httpRoots != null || !fileIndex.isInLibraryClasses(virtualFile)) { 

java/java-impl/src/com/intellij/openapi/roots/impl/JavaModuleExternalPathsImpl.java

@@ -0,0 +1,163 @@
+/*
+ * 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.openapi.roots.impl;
+
+import com.intellij.openapi.roots.*;
+import com.intellij.openapi.util.Comparing;
+import com.intellij.openapi.util.InvalidDataException;
+import com.intellij.openapi.util.WriteExternalException;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.vfs.pointers.VirtualFilePointerContainer;
+import com.intellij.openapi.vfs.pointers.VirtualFilePointerManager;
+import com.intellij.util.ArrayUtil;
+import org.jdom.Element;
+import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author nik
+ */
+public class JavaModuleExternalPathsImpl extends JavaModuleExternalPaths {
+  @NonNls private static final String ROOT_ELEMENT = "root";
+  private final Map<OrderRootType, VirtualFilePointerContainer> myOrderRootPointerContainers = new HashMap<OrderRootType, VirtualFilePointerContainer>();
+  private JavaModuleExternalPathsImpl mySource;
+
+  public JavaModuleExternalPathsImpl() {
+  }
+
+  public JavaModuleExternalPathsImpl(JavaModuleExternalPathsImpl source) {
+    mySource = source;
+    copyContainersFrom(source);
+  }
+
+  @Override
+  public ModuleExtension getModifiableModel(boolean writable) {
+    return new JavaModuleExternalPathsImpl(this);
+  }
+
+  @Override
+  public void commit() {
+    mySource.copyContainersFrom(this);
+  }
+
+  @NotNull
+  @Override
+  public String[] getJavadocUrls() {
+    final VirtualFilePointerContainer container = myOrderRootPointerContainers.get(JavadocOrderRootType.getInstance());
+    return container != null ? container.getUrls() : ArrayUtil.EMPTY_STRING_ARRAY;
+  }
+
+  @NotNull
+  @Override
+  public VirtualFile[] getExternalAnnotationsRoots() {
+    final VirtualFilePointerContainer container = myOrderRootPointerContainers.get(AnnotationOrderRootType.getInstance());
+    return container != null ? container.getFiles() : VirtualFile.EMPTY_ARRAY;
+  }
+
+  @NotNull
+  @Override
+  public String[] getExternalAnnotationsUrls() {
+    final VirtualFilePointerContainer container = myOrderRootPointerContainers.get(AnnotationOrderRootType.getInstance());
+    return container != null ? container.getUrls() : ArrayUtil.EMPTY_STRING_ARRAY;
+  }
+
+  @Override
+  public void setJavadocUrls(@NotNull String[] urls) {
+    setRootUrls(JavadocOrderRootType.getInstance(), urls);
+  }
+
+  @Override
+  public void setExternalAnnotationUrls(@NotNull String[] urls) {
+    setRootUrls(AnnotationOrderRootType.getInstance(), urls);
+  }
+
+  private void setRootUrls(final OrderRootType orderRootType, @NotNull final String[] urls) {
+    VirtualFilePointerContainer container = myOrderRootPointerContainers.get(orderRootType);
+    if (container == null) {
+      container = VirtualFilePointerManager.getInstance().createContainer(this, null);
+      myOrderRootPointerContainers.put(orderRootType, container);
+    }
+    container.clear();
+    for (final String url : urls) {
+      container.add(url);
+    }
+  }
+
+  @Override
+  public void readExternal(Element element) throws InvalidDataException {
+    for (PersistentOrderRootType orderRootType : OrderRootType.getAllPersistentTypes()) {
+      String paths = orderRootType.getModulePathsName();
+      if (paths != null) {
+        final Element pathsElement = element.getChild(paths);
+        if (pathsElement != null) {
+          VirtualFilePointerContainer container = VirtualFilePointerManager.getInstance().createContainer(this, null);
+          myOrderRootPointerContainers.put(orderRootType, container);
+          container.readExternal(pathsElement, ROOT_ELEMENT);
+        }
+      }
+    }
+  }
+
+  @Override
+  public void writeExternal(Element element) throws WriteExternalException {
+    for (OrderRootType orderRootType : myOrderRootPointerContainers.keySet()) {
+      VirtualFilePointerContainer container = myOrderRootPointerContainers.get(orderRootType);
+      if (container != null && container.size() > 0) {
+        final Element javaDocPaths = new Element(((PersistentOrderRootType)orderRootType).getModulePathsName());
+        container.writeExternal(javaDocPaths, ROOT_ELEMENT);
+        element.addContent(javaDocPaths);
+      }
+    }
+  }
+
+  private void copyContainersFrom(@NotNull JavaModuleExternalPathsImpl paths) {
+    myOrderRootPointerContainers.clear();
+    for (PersistentOrderRootType orderRootType : OrderRootType.getAllPersistentTypes()) {
+      final VirtualFilePointerContainer otherContainer = paths.myOrderRootPointerContainers.get(orderRootType);
+      if (otherContainer != null) {
+        myOrderRootPointerContainers.put(orderRootType, otherContainer.clone(this, null));
+      }
+    }
+  }
+
+  @Override
+  public boolean isChanged() {
+    if (myOrderRootPointerContainers.size() != mySource.myOrderRootPointerContainers.size()) return true;
+    for (final OrderRootType type : myOrderRootPointerContainers.keySet()) {
+      final VirtualFilePointerContainer container = myOrderRootPointerContainers.get(type);
+      final VirtualFilePointerContainer otherContainer = mySource.myOrderRootPointerContainers.get(type);
+      if (container == null || otherContainer == null) {
+        if (container != otherContainer) return true;
+      }
+      else {
+        final String[] urls = container.getUrls();
+        final String[] otherUrls = otherContainer.getUrls();
+        if (urls.length != otherUrls.length) return true;
+        for (int i = 0; i < urls.length; i++) {
+          if (!Comparing.strEqual(urls[i], otherUrls[i])) return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  @Override
+  public void dispose() {
+  }
+}

java/java-tests/testSrc/com/intellij/codeInsight/SuppressExternalTest.java

@@ -9,11 +9,11 @@ import com.intellij.codeInspection.sillyAssignment.SillyAssignmentInspection;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.application.ex.PathManagerEx;
 import com.intellij.openapi.module.Module;
-import com.intellij.openapi.roots.AnnotationOrderRootType;
+import com.intellij.openapi.roots.JavaModuleExternalPaths;
 import com.intellij.openapi.roots.LanguageLevelProjectExtension;
 import com.intellij.openapi.roots.ModifiableRootModel;
 import com.intellij.openapi.roots.ModuleRootManager;
-import com.intellij.openapi.vfs.VfsUtil;
+import com.intellij.openapi.vfs.VfsUtilCore;
 import com.intellij.pom.java.LanguageLevel;
 import com.intellij.psi.JavaPsiFacade;
 import com.intellij.testFramework.IdeaTestCase;
@@ -61,7 +61,8 @@ public class SuppressExternalTest extends UsefulTestCase {
       public void run() {
         final Module module = myFixture.getModule();
         final ModifiableRootModel model = ModuleRootManager.getInstance(module).getModifiableModel();
-        model.setRootUrls(AnnotationOrderRootType.getInstance(), new String[]{VfsUtil.pathToUrl(myFixture.getTempDirPath() + "/content/anno")});
+        final String url = VfsUtilCore.pathToUrl(myFixture.getTempDirPath() + "/content/anno");
+        model.getModuleExtension(JavaModuleExternalPaths.class).setExternalAnnotationUrls(new String[]{url});
         model.commit();
       }
     });

java/openapi/src/com/intellij/openapi/roots/AnnotationOrderRootType.java

@@ -15,7 +15,7 @@
  */
 package com.intellij.openapi.roots;
 
-import com.intellij.openapi.vfs.VfsUtil;
+import com.intellij.openapi.vfs.VfsUtilCore;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.util.ArrayUtil;
 import org.jetbrains.annotations.NotNull;
@@ -63,12 +63,12 @@ public class AnnotationOrderRootType extends PersistentOrderRootType {
       @Override
       public List<VirtualFile> visitModuleSourceOrderEntry(final ModuleSourceOrderEntry orderEntry,
                                                            final List<VirtualFile> value) {
-        Collections.addAll(value, orderEntry.getRootModel().getRootPaths(getInstance()));
+        Collections.addAll(value, orderEntry.getRootModel().getModuleExtension(JavaModuleExternalPaths.class).getExternalAnnotationsRoots());
         return value;
       }
     };
     entry.accept(policy, result);
-    return VfsUtil.toVirtualFileArray(result);
+    return VfsUtilCore.toVirtualFileArray(result);
   }
 
   @NotNull
@@ -90,7 +90,7 @@ public class AnnotationOrderRootType extends PersistentOrderRootType {
       @Override
       public List<String> visitModuleSourceOrderEntry(final ModuleSourceOrderEntry orderEntry,
                                                            final List<String> value) {
-        Collections.addAll(value, orderEntry.getRootModel().getRootUrls(getInstance()));
+        Collections.addAll(value, orderEntry.getRootModel().getModuleExtension(JavaModuleExternalPaths.class).getExternalAnnotationsUrls());
         return value;
       }
     };

java/openapi/src/com/intellij/openapi/roots/JavaModuleExternalPaths.java

@@ -0,0 +1,46 @@
+/*
+ * 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.openapi.roots;
+
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.vfs.VirtualFile;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author nik
+ */
+public abstract class JavaModuleExternalPaths extends ModuleExtension<JavaModuleExternalPaths> {
+
+  public static JavaModuleExternalPaths getInstance(Module module) {
+    return ModuleRootManager.getInstance(module).getModuleExtension(JavaModuleExternalPaths.class);
+  }
+
+  @NotNull
+  public abstract VirtualFile[] getExternalAnnotationsRoots();
+
+  @NotNull
+  public abstract String[] getExternalAnnotationsUrls();
+
+  public abstract void setExternalAnnotationUrls(@NotNull String[] urls);
+
+
+  @NotNull
+  public abstract String[] getJavadocUrls();
+
+  public abstract void setJavadocUrls(@NotNull String[] urls);
+
+
+}

java/openapi/src/com/intellij/openapi/roots/JavadocOrderRootType.java

@@ -51,7 +51,7 @@ public class JavadocOrderRootType extends PersistentOrderRootType {
       @Override
       public List<String> visitModuleSourceOrderEntry(final ModuleSourceOrderEntry orderEntry,
                                                            final List<String> value) {
-        Collections.addAll(value, orderEntry.getRootModel().getRootUrls(getInstance()));
+        Collections.addAll(value, orderEntry.getRootModel().getModuleExtension(JavaModuleExternalPaths.class).getJavadocUrls());
         return value;
       }
     };