speedup: call force() only at the end of the build, between chunk builds drop only...
[idea/community.git] / jps / model / src / org / jetbrains / ether / dependencyView / PersistentMaplet.java
1 /*
2  * Copyright 2000-2011 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 org.jetbrains.ether.dependencyView;
17
18 import com.intellij.util.io.DataExternalizer;
19 import com.intellij.util.io.KeyDescriptor;
20 import com.intellij.util.io.PersistentHashMap;
21
22 import java.io.File;
23 import java.io.IOException;
24 import java.util.Collection;
25 import java.util.LinkedList;
26 import java.util.Map;
27
28 /**
29  * Created by IntelliJ IDEA.
30  * User: db
31  * Date: 05.11.11
32  * Time: 0:05
33  * To change this template use File | Settings | File Templates.
34  */
35 public class PersistentMaplet<K, V> implements Maplet<K, V> {
36   private final PersistentHashMap<K, V> myMap;
37
38   public PersistentMaplet(final File file, final KeyDescriptor<K> k, final DataExternalizer<V> v) {
39     try {
40       myMap = new PersistentHashMap<K, V>(file, k, v);
41     }
42     catch (IOException e) {
43       throw new RuntimeException(e);
44     }
45   }
46
47   @Override
48   public boolean containsKey(final Object key) {
49     try {
50       return myMap.containsMapping((K)key);
51     }
52     catch (IOException e) {
53       throw new RuntimeException(e);
54     }
55   }
56
57   @Override
58   public V get(final Object key) {
59     try {
60       return myMap.get((K)key);
61     }
62     catch (IOException e) {
63       throw new RuntimeException(e);
64     }
65   }
66
67   @Override
68   public void put(final K key, final V value) {
69     try {
70       myMap.put(key, value);
71     }
72     catch (IOException e) {
73       throw new RuntimeException(e);
74     }
75   }
76
77   @Override
78   public void putAll(final Maplet<K, V> m) {
79     try {
80       for (Map.Entry<K, V> e : m.entrySet()) {
81         myMap.put(e.getKey(), e.getValue());
82       }
83     }
84     catch (IOException e) {
85       throw new RuntimeException(e);
86     }
87   }
88
89   @Override
90   public void remove(final Object key) {
91     try {
92       myMap.remove((K)key);
93     }
94     catch (IOException e) {
95       throw new RuntimeException(e);
96     }
97   }
98
99   @Override
100   public void close() {
101     try {
102       myMap.close();
103     }
104     catch (IOException e) {
105       throw new RuntimeException(e);
106     }
107   }
108
109   public void flush(boolean memoryCachesOnly) {
110     if (memoryCachesOnly) {
111       myMap.dropMemoryCaches();
112     }
113     else {
114       myMap.force();
115     }
116   }
117
118   @Override
119   public Collection<K> keyCollection() {
120     try {
121       return myMap.getAllKeysWithExistingMapping();
122     }
123     catch (IOException e) {
124       throw new RuntimeException(e);
125     }
126   }
127
128   @Override
129   public Collection<Map.Entry<K, V>> entrySet() {
130     final Collection<Map.Entry<K, V>> result = new LinkedList<Map.Entry<K, V>>();
131
132     try {
133       for (final K key : myMap.getAllKeysWithExistingMapping()) {
134         final V value = myMap.get(key);
135
136         final Map.Entry<K, V> entry = new Map.Entry<K, V>() {
137           @Override
138           public K getKey() {
139             return key;
140           }
141
142           @Override
143           public V getValue() {
144             return value;
145           }
146
147           @Override
148           public V setValue(V value) {
149             return null;
150           }
151         };
152
153         result.add(entry);
154       }
155
156       return result;
157     }
158     catch (IOException e) {
159       throw new RuntimeException(e);
160     }
161   }
162 }