1 files changed, 30 insertions, 56 deletions

diff --git a/plugins/svn4idea/src/org/jetbrains/idea/svn/dialogs/RepositoryTreeNode.java b/plugins/svn4idea/src/org/jetbrains/idea/svn/dialogs/RepositoryTreeNode.java
index f21ca1735ff4..90f617ecad72 100644
--- a/plugins/svn4idea/src/org/jetbrains/idea/svn/dialogs/RepositoryTreeNode.java
+++ b/plugins/svn4idea/src/org/jetbrains/idea/svn/dialogs/RepositoryTreeNode.java
@@ -15,9 +15,12 @@
  */
 package org.jetbrains.idea.svn.dialogs;
 
+import com.intellij.CommonBundle;
 import com.intellij.openapi.Disposable;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.util.NotNullFunction;
+import com.intellij.util.containers.ContainerUtil;
+import com.intellij.util.containers.FilteringIterator;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.idea.svn.SvnVcs;
@@ -27,7 +30,6 @@ import org.jetbrains.idea.svn.dialogs.browserCache.NodeLoadState;
 import org.tmatesoft.svn.core.SVNURL;
 import org.tmatesoft.svn.core.internal.util.SVNPathUtil;
 
-import javax.swing.tree.DefaultMutableTreeNode;
 import javax.swing.tree.TreeNode;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -37,16 +39,16 @@ import java.util.List;
 public class RepositoryTreeNode implements TreeNode, Disposable {
 
   private TreeNode myParentNode;
-  private List<TreeNode> myChildren;
+  @NotNull private final List<TreeNode> myChildren;
   private final RepositoryTreeModel myModel;
   private final SVNURL myURL;
   private final Object myUserObject;
 
-  private final NodeLoadState myLoadState;
+  @NotNull private final NodeLoadState myLoadState;
   private NodeLoadState myChildrenLoadState;
 
   public RepositoryTreeNode(RepositoryTreeModel model, TreeNode parentNode,
-                            @NotNull SVNURL url, Object userObject, final NodeLoadState state) {
+                            @NotNull SVNURL url, Object userObject, @NotNull NodeLoadState state) {
     myParentNode = parentNode;
 
     myURL = url;
@@ -54,6 +56,7 @@ public class RepositoryTreeNode implements TreeNode, Disposable {
     myUserObject = userObject;
 
     myLoadState = state;
+    myChildren = ContainerUtil.newArrayList();
     myChildrenLoadState = NodeLoadState.EMPTY;
   }
 
@@ -113,10 +116,10 @@ public class RepositoryTreeNode implements TreeNode, Disposable {
     return SVNPathUtil.tail(myURL.getPath());
   }
 
-  public void reload(final Expander expander, final boolean removeCurrentChildren) {
+  public void reload(@NotNull Expander expander, boolean removeCurrentChildren) {
     ApplicationManager.getApplication().assertIsDispatchThread();
 
-    if (removeCurrentChildren || (myChildren == null)) {
+    if (removeCurrentChildren || NodeLoadState.EMPTY.equals(myChildrenLoadState)) {
       initChildren();
     }
     
@@ -124,15 +127,15 @@ public class RepositoryTreeNode implements TreeNode, Disposable {
   }
 
   private void initChildren() {
-    myChildren = new ArrayList<TreeNode>();
-    myChildren.add(new DefaultMutableTreeNode("Loading"));
+    myChildren.clear();
+    myChildren.add(new SimpleTextNode(CommonBundle.getLoadingTreeNodeText()));
     myChildrenLoadState = NodeLoadState.LOADING;
   }
 
   private List getChildren() {
     ApplicationManager.getApplication().assertIsDispatchThread();
-    
-    if (myChildren == null) {
+
+    if (NodeLoadState.EMPTY.equals(myChildrenLoadState)) {
       initChildren();
       myModel.getCacheLoader().load(this, myModel.getLazyLoadingExpander());
     }
@@ -145,10 +148,7 @@ public class RepositoryTreeNode implements TreeNode, Disposable {
 
   @Nullable
   public DirectoryEntry getSVNDirEntry() {
-    if (myUserObject instanceof DirectoryEntry) {
-      return (DirectoryEntry) myUserObject;
-    }
-    return null;
+    return myUserObject instanceof DirectoryEntry ? (DirectoryEntry)myUserObject : null;
   }
 
   public void dispose() {
@@ -164,35 +164,19 @@ public class RepositoryTreeNode implements TreeNode, Disposable {
 
   @NotNull
   public List<TreeNode> getAllAlreadyLoadedChildren() {
-    if (myChildren != null) {
-      final List<TreeNode> result = new ArrayList<TreeNode>(myChildren.size());
-      for (TreeNode child : myChildren) {
-        result.add(child);
-      }
-      return result;
-    }
-    return Collections.emptyList();
+    return ContainerUtil.newArrayList(myChildren);
   }
 
   @NotNull
   public List<RepositoryTreeNode> getAlreadyLoadedChildren() {
-    if (myChildren != null) {
-      final List<RepositoryTreeNode> result = new ArrayList<RepositoryTreeNode>(myChildren.size());
-      for (TreeNode child : myChildren) {
-        if (child instanceof RepositoryTreeNode) {
-          result.add((RepositoryTreeNode) child);
-        }
-      }
-      return result;
-    }
-    return Collections.emptyList();
+    return ContainerUtil.collect(myChildren.iterator(), FilteringIterator.instanceOf(RepositoryTreeNode.class));
   }
 
   public boolean isDisposed() {
     return myModel.isDisposed();
   }
 
-  public void setChildren(final List<DirectoryEntry> children, final NodeLoadState state) {
+  public void setChildren(@NotNull List<DirectoryEntry> children, @NotNull NodeLoadState state) {
     final List<TreeNode> nodes = new ArrayList<TreeNode>();
     for (final DirectoryEntry entry : children) {
       if (!myModel.isShowFiles() && !entry.isDirectory()) {
@@ -213,19 +197,17 @@ public class RepositoryTreeNode implements TreeNode, Disposable {
   }
 
   public void setAlienChildren(final List<TreeNode> children, final NodeLoadState oldState) {
-    if (myChildren == null) {
-      myChildren = new ArrayList<TreeNode>();
-    } else {
-      myChildren.clear();
-    }
+    myChildren.clear();
 
     for (TreeNode child : children) {
       if (child instanceof RepositoryTreeNode) {
         ((RepositoryTreeNode) child).setParentNode(this);
         myChildren.add(child);
         myChildrenLoadState = oldState;
-      } else if (child instanceof DefaultMutableTreeNode) {
-        myChildren.add(new DefaultMutableTreeNode(((DefaultMutableTreeNode) child).getUserObject()));
+      }
+      else if (child instanceof SimpleTextNode) {
+        SimpleTextNode node = (SimpleTextNode)child;
+        myChildren.add(new SimpleTextNode(node.getText(), node.isError()));
         myChildrenLoadState = oldState;
       }
     }
@@ -233,13 +215,9 @@ public class RepositoryTreeNode implements TreeNode, Disposable {
     myModel.reload(this);
   }
 
-  public void setErrorNode(final String text, final NodeLoadState state) {
-    if (myChildren == null) {
-      myChildren = new ArrayList<TreeNode>();
-    }
+  public void setErrorNode(@NotNull String text) {
     myChildren.clear();
-    myChildren.add(new DefaultMutableTreeNode(text));
-
+    myChildren.add(new SimpleTextNode(text, true));
     myChildrenLoadState = NodeLoadState.ERROR;
     myModel.reload(this);
   }
@@ -257,24 +235,20 @@ public class RepositoryTreeNode implements TreeNode, Disposable {
     return myModel.findByUrl(this);
   }
 
-  public RepositoryTreeModel getModel() {
-    return myModel;
-  }
-
   public NodeLoadState getChildrenLoadState() {
     return myChildrenLoadState;
   }
 
-  public void doOnSubtree(final NotNullFunction<RepositoryTreeNode, Object> function) {
-    final SubTreeWalker walker = new SubTreeWalker(this, function);
-    walker.execute();
+  public void doOnSubtree(@NotNull NotNullFunction<RepositoryTreeNode, Object> function) {
+    new SubTreeWalker(this, function).execute();
   }
 
   private static class SubTreeWalker {
-    private final RepositoryTreeNode myNode;
-    private final NotNullFunction<RepositoryTreeNode, Object> myFunction;
 
-    private SubTreeWalker(final RepositoryTreeNode node, final NotNullFunction<RepositoryTreeNode, Object> function) {
+    @NotNull private final RepositoryTreeNode myNode;
+    @NotNull private final NotNullFunction<RepositoryTreeNode, Object> myFunction;
+
+    private SubTreeWalker(@NotNull RepositoryTreeNode node, @NotNull NotNullFunction<RepositoryTreeNode, Object> function) {
       myNode = node;
       myFunction = function;
     }