Coverage Summary for Class: JdkBackedImmutableBiMap (com.google.common.collect)

1 /*
2  * Copyright (C) 2018 The Guava Authors
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.google.common.collect;
17 
18 import com.google.common.annotations.GwtCompatible;
19 import com.google.common.annotations.VisibleForTesting;
20 import com.google.errorprone.annotations.concurrent.LazyInit;
21 import com.google.j2objc.annotations.RetainedWith;
22 import com.google.j2objc.annotations.WeakOuter;
23 import java.util.Map;
24 import org.checkerframework.checker.nullness.qual.Nullable;
25 
26 /**
27  * Implementation of ImmutableBiMap backed by a pair of JDK HashMaps, which have smartness
28  * protecting against hash flooding.
29  */
30 @GwtCompatible(emulated = true)
31 final class JdkBackedImmutableBiMap<K, V> extends ImmutableBiMap<K, V> {
32   @VisibleForTesting
33   static <K, V> ImmutableBiMap<K, V> create(int n, Entry<K, V>[] entryArray) {
34     Map<K, V> forwardDelegate = Maps.newHashMapWithExpectedSize(n);
35     Map<V, K> backwardDelegate = Maps.newHashMapWithExpectedSize(n);
36     for (int i = 0; i < n; i++) {
37       Entry<K, V> e = RegularImmutableMap.makeImmutable(entryArray[i]);
38       entryArray[i] = e;
39       V oldValue = forwardDelegate.putIfAbsent(e.getKey(), e.getValue());
40       if (oldValue != null) {
41         throw conflictException("key", e.getKey() + "=" + oldValue, entryArray[i]);
42       }
43       K oldKey = backwardDelegate.putIfAbsent(e.getValue(), e.getKey());
44       if (oldKey != null) {
45         throw conflictException("value", oldKey + "=" + e.getValue(), entryArray[i]);
46       }
47     }
48     ImmutableList<Entry<K, V>> entryList = ImmutableList.asImmutableList(entryArray, n);
49     return new JdkBackedImmutableBiMap<>(entryList, forwardDelegate, backwardDelegate);
50   }
51 
52   private final transient ImmutableList<Entry<K, V>> entries;
53   private final Map<K, V> forwardDelegate;
54   private final Map<V, K> backwardDelegate;
55 
56   private JdkBackedImmutableBiMap(
57       ImmutableList<Entry<K, V>> entries, Map<K, V> forwardDelegate, Map<V, K> backwardDelegate) {
58     this.entries = entries;
59     this.forwardDelegate = forwardDelegate;
60     this.backwardDelegate = backwardDelegate;
61   }
62 
63   @Override
64   public int size() {
65     return entries.size();
66   }
67 
68   @LazyInit @RetainedWith private transient JdkBackedImmutableBiMap<V, K> inverse;
69 
70   @Override
71   public ImmutableBiMap<V, K> inverse() {
72     JdkBackedImmutableBiMap<V, K> result = inverse;
73     if (result == null) {
74       inverse =
75           result =
76               new JdkBackedImmutableBiMap<V, K>(
77                   new InverseEntries(), backwardDelegate, forwardDelegate);
78       result.inverse = this;
79     }
80     return result;
81   }
82 
83   @WeakOuter
84   private final class InverseEntries extends ImmutableList<Entry<V, K>> {
85     @Override
86     public Entry<V, K> get(int index) {
87       Entry<K, V> entry = entries.get(index);
88       return Maps.immutableEntry(entry.getValue(), entry.getKey());
89     }
90 
91     @Override
92     boolean isPartialView() {
93       return false;
94     }
95 
96     @Override
97     public int size() {
98       return entries.size();
99     }
100   }
101 
102   @Override
103   public V get(@Nullable Object key) {
104     return forwardDelegate.get(key);
105   }
106 
107   @Override
108   ImmutableSet<Entry<K, V>> createEntrySet() {
109     return new ImmutableMapEntrySet.RegularEntrySet<K, V>(this, entries);
110   }
111 
112   @Override
113   ImmutableSet<K> createKeySet() {
114     return new ImmutableMapKeySet<K, V>(this);
115   }
116 
117   @Override
118   boolean isPartialView() {
119     return false;
120   }
121 }