replaced <code></code> with more concise {@code}
[idea/community.git] / platform / platform-impl / src / com / intellij / openapi / wm / impl / ActiveStack.java
1 /*
2  * Copyright 2000-2009 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.intellij.openapi.wm.impl;
17
18 import com.intellij.util.containers.Stack;
19 import org.jetbrains.annotations.NotNull;
20
21 import java.util.Iterator;
22
23 /**
24  * Actually this class represent two stacks.
25  * 1. Stack of {@code id}s of active tool windows. This stack is used for reactivation of tool window
26  * after the another tool window was closed. This stack is cleared every time you active the editor.
27  * 2. Permanent stack. It is the same as the first one, but it's not cleared when editor is being
28  * activated. It used to provide id of last active tool window.
29  *
30  * @author Vladimir Kondratyev
31  */
32 final class ActiveStack {
33   /**
34    * Contains {@code id}s of tool window that were activated. This stack
35    * is cleared each time when editor is being activated.
36    */
37   private final Stack<String> myStack;
38   /**
39    * This stack is not cleared when editor is being activated. It means its "long"
40    * persistence.
41    */
42   private final Stack<String> myPersistentStack;
43
44   /**
45    * Creates enabled window stack.
46    */
47   ActiveStack() {
48     myStack = new Stack<>();
49     myPersistentStack = new Stack<>();
50   }
51
52   /**
53    * Clears stack but doesn't affect long persistence stack.
54    */
55   void clear() {
56     myStack.clear();
57   }
58
59   /**
60    * Return whether the stack of active (not persistent) {@code id}s is empty or not.
61    */
62   boolean isEmpty() {
63     return myStack.isEmpty();
64   }
65
66   @NotNull
67   String pop() {
68     return myStack.pop();
69   }
70
71   @NotNull
72   String peek() {
73     return myStack.peek();
74   }
75
76   int getSize() {
77     return myStack.size();
78   }
79
80   @NotNull
81   private String peek(int i) {
82     return myStack.get(getSize() - i - 1);
83   }
84
85   @NotNull
86   String[] getStack() {
87     String[] result = new String[getSize()];
88     for (int i = 0; i < getSize(); i++) {
89       result[i] = peek(i);
90     }
91     return result;
92   }
93
94   @NotNull
95   String[] getPersistentStack() {
96     String[] result = new String[getPersistentSize()];
97     for (int i = 0; i < getPersistentSize(); i++) {
98       result[i] = peekPersistent(i);  
99     }
100     return result;
101   }
102
103   void push(@NotNull String id) {
104     remove(id, true);
105     myStack.push(id);
106     myPersistentStack.push(id);
107   }
108
109   int getPersistentSize() {
110     return myPersistentStack.size();
111   }
112
113   /**
114    * Peeks element at the persistent stack. {@code 0} means the top of the stack.
115    */
116   @NotNull
117   String peekPersistent(final int index) {
118     return myPersistentStack.get(myPersistentStack.size() - index - 1);
119   }
120
121   /**
122    * Removes specified {@code ID} from stack.
123    *
124    * @param id                   {@code ID} to be removed.
125    * @param removePersistentAlso if {@code true} then clears last active {@code ID}
126    *                             if it's the last active {@code ID}.
127    */
128   void remove(@NotNull String id, final boolean removePersistentAlso) {
129     for (Iterator i = myStack.iterator(); i.hasNext();) {
130       if (id.equals(i.next())) {
131         i.remove();
132       }
133     }
134     if (removePersistentAlso) {
135       for (Iterator i = myPersistentStack.iterator(); i.hasNext();) {
136         if (id.equals(i.next())) {
137           i.remove();
138         }
139       }
140     }
141   }
142 }