drop memory caches only when is dirty
[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       if (myMap.isDirty()) {
112         myMap.dropMemoryCaches();
113       }
114     }
115     else {
116       myMap.force();
117     }
118   }
119
120   @Override
121   public Collection<K> keyCollection() {
122     try {
123       return myMap.getAllKeysWithExistingMapping();
124     }
125     catch (IOException e) {
126       throw new RuntimeException(e);
127     }
128   }
129
130   @Override
131   public Collection<Map.Entry<K, V>> entrySet() {
132     final Collection<Map.Entry<K, V>> result = new LinkedList<Map.Entry<K, V>>();
133
134     try {
135       for (final K key : myMap.getAllKeysWithExistingMapping()) {
136         final V value = myMap.get(key);
137
138         final Map.Entry<K, V> entry = new Map.Entry<K, V>() {
139           @Override
140           public K getKey() {
141             return key;
142           }
143
144           @Override
145           public V getValue() {
146             return value;
147           }
148
149           @Override
150           public V setValue(V value) {
151             return null;
152           }
153         };
154
155         result.add(entry);
156       }
157
158       return result;
159     }
160     catch (IOException e) {
161       throw new RuntimeException(e);
162     }
163   }
164 }