platform/util/src/com/intellij/openapi/util/MultiValuesMap.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.util;
  17
  18 import org.jetbrains.annotations.Nullable;
  19
  20 import java.util.*;
  21
  22 public class MultiValuesMap<K, V>{
  23   private final Map<K, Collection<V>> myBaseMap;
  24   private final boolean myOrdered;
  25
  26   public MultiValuesMap() {
  27     this(false);
  28   }
  29
  30   public MultiValuesMap(boolean ordered) {
  31     myOrdered = ordered;
  32     myBaseMap = ordered ? new LinkedHashMap<K, Collection<V>>() : new HashMap<K, Collection<V>>();
  33   }
  34
  35   public void putAll(K key, Collection<V> values) {
  36     for (V value : values) {
  37       put(key, value);
  38     }
  39   }
  40
  41   public void putAll(K key, V... values) {
  42     for (V value : values) {
  43       put(key, value);
  44     }
  45   }
  46
  47   public void put(K key, V value) {
  48     if (!myBaseMap.containsKey(key)) {
  49       myBaseMap.put(key, myOrdered ? new LinkedHashSet<V>() : new HashSet<V>());
  50     }
  51
  52     myBaseMap.get(key).add(value);
  53   }
  54
  55   @Nullable
  56   public Collection<V> get(K key){
  57     return myBaseMap.get(key);
  58   }
  59
  60   public Set<K> keySet() {
  61     return myBaseMap.keySet();
  62   }
  63
  64   public Collection<V> values() {
  65     Set<V> result = myOrdered ? new LinkedHashSet<V>() : new HashSet<V>();
  66     for (final Collection<V> values : myBaseMap.values()) {
  67       result.addAll(values);
  68     }
  69
  70     return result;
  71   }
  72
  73   public void remove(K key, V value) {
  74     if (myBaseMap.get(key) == null) return;
  75     final Collection<V> values = myBaseMap.get(key);
  76     values.remove(value);
  77     if (values.isEmpty()) {
  78       myBaseMap.remove(key);
  79     }
  80   }
  81
  82   public void clear() {
  83     myBaseMap.clear();
  84   }
  85
  86   @Nullable
  87   public Collection<V> removeAll(final K key) {
  88     return myBaseMap.remove(key);
  89   }
  90
  91   public Set<Map.Entry<K, Collection<V>>> entrySet() {
  92     return myBaseMap.entrySet();
  93   }
  94
  95   public boolean isEmpty() {
  96     return myBaseMap.isEmpty();
  97   }
  98
  99   public boolean containsKey(final K key) {
 100     return myBaseMap.containsKey(key);
 101   }
 102
 103   public Collection<V> collectValues() {
 104     Collection<V> result = new HashSet<V>();
 105     for (Collection<V> v : myBaseMap.values()) {
 106       result.addAll(v);
 107     }
 108
 109     return result;
 110   }
 111
 112   @Nullable
 113   public V getFirst(final K key) {
 114     Collection<V> values = myBaseMap.get(key);
 115     return values == null || values.isEmpty() ? null : values.iterator().next();
 116   }
 117
 118
 119 }