vcs: Removed unused "RevisionChangesNotSupportedException"
[idea/community.git] / plugins / svn4idea / src / org / jetbrains / idea / svn / SmallMapSerializer.java
1 /*
2  * Copyright 2000-2016 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.idea.svn;
17
18 import com.intellij.openapi.Forceable;
19 import com.intellij.openapi.diagnostic.Logger;
20 import com.intellij.openapi.util.io.BufferExposingByteArrayOutputStream;
21 import com.intellij.openapi.util.io.FileUtil;
22 import com.intellij.util.io.DataExternalizer;
23 import com.intellij.util.io.DataOutputStream;
24 import com.intellij.util.io.KeyDescriptor;
25 import com.intellij.util.io.UnsyncByteArrayInputStream;
26 import org.jetbrains.annotations.NotNull;
27
28 import java.io.*;
29 import java.util.ArrayList;
30 import java.util.Collection;
31 import java.util.HashMap;
32 import java.util.Map;
33
34 /**
35  * @author irengrig
36  */
37 public class SmallMapSerializer<K,V> implements Forceable {
38   private final Map<KeyWrapper<K>,V> myMap;
39   private final File myFile;
40   private final KeyDescriptor<K> myKeyDescriptor;
41   private final DataExternalizer<V> myValueExternalizer;
42   private boolean myDirty;
43   private Logger LOG = Logger.getInstance(SmallMapSerializer.class);
44
45   public SmallMapSerializer(final File file, final KeyDescriptor<K> keyDescriptor, final DataExternalizer<V> valueExternalizer) {
46     myFile = file;
47     myKeyDescriptor = keyDescriptor;
48     myValueExternalizer = valueExternalizer;
49     myMap = new HashMap<>();
50     init();
51   }
52
53   private void init() {
54     try {
55       final byte[] bytes = FileUtil.loadFileBytes(myFile);
56       final DataInputStream dis = new DataInputStream(new UnsyncByteArrayInputStream(bytes));
57       final int size = dis.readInt();
58       for (int i = 0; i < size; i++) {
59         final KeyWrapper<K> keyWrapper = new KeyWrapper<>(myKeyDescriptor, myKeyDescriptor.read(dis));
60         final V value = myValueExternalizer.read(dis);
61         myMap.put(keyWrapper, value);
62       }
63     } catch (FileNotFoundException ignore) {
64     } catch (IOException e) {
65       LOG.error(e);
66     }
67   }
68
69   public void put(final K key, final V value) {
70     myMap.put(new KeyWrapper<>(myKeyDescriptor, key), value);
71     myDirty = true;
72   }
73
74   public V get(final K key) {
75     return myMap.get(new KeyWrapper<>(myKeyDescriptor, key));
76   }
77
78   @Override
79   public void force() {
80     if (! myDirty) return;
81     try{
82       final BufferExposingByteArrayOutputStream bos = new BufferExposingByteArrayOutputStream();
83       final DataOutput out = new DataOutputStream(bos);
84       out.writeInt(myMap.size());
85       for (Map.Entry<KeyWrapper<K>, V> entry : myMap.entrySet()) {
86         myKeyDescriptor.save(out, entry.getKey().myKey);
87         myValueExternalizer.save(out, entry.getValue());
88       }
89       FileUtil.writeToFile(myFile, bos.getInternalBuffer(), 0, bos.size());
90     } catch (IOException e) {
91       LOG.error(e);
92     } finally {
93       myDirty = false;
94     }
95   }
96
97   @Override
98   public boolean isDirty() {
99     return myDirty;
100   }
101
102   private static class KeyWrapper<K> {
103     private final K myKey;
104     private final KeyDescriptor<K> myDescriptor;
105
106     private KeyWrapper(@NotNull final KeyDescriptor<K> descriptor, final K key) {
107       myDescriptor = descriptor;
108       myKey = key;
109     }
110
111     @Override
112     public boolean equals(Object o) {
113       if (this == o) return true;
114       if (o == null || getClass() != o.getClass()) return false;
115
116       final KeyWrapper<K> that = (KeyWrapper) o;
117
118       return myDescriptor.isEqual(this.myKey, that.myKey);
119     }
120
121     @Override
122     public int hashCode() {
123       return myDescriptor.getHashCode(myKey);
124     }
125   }
126
127   public Collection<K> keySet() {
128     final ArrayList<K> result = new ArrayList<>(myMap.size());
129     for (KeyWrapper<K> keyWrapper : myMap.keySet()) {
130       result.add(keyWrapper.myKey);
131     }
132     return result;
133   }
134 }