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 }