1/*
2 * Copyright (C) 2007 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
17package com.google.common.collect;
18
19import com.google.common.annotations.GwtCompatible;
20import com.google.common.annotations.GwtIncompatible;
21
22import java.io.IOException;
23import java.io.ObjectInputStream;
24import java.io.ObjectOutputStream;
25import java.util.HashMap;
26import java.util.Map;
27
28import javax.annotation.Nullable;
29
30/**
31 * A {@link BiMap} backed by two {@link HashMap} instances. This implementation
32 * allows null keys and values. A {@code HashBiMap} and its inverse are both
33 * serializable.
34 *
35 * @author Mike Bostock
36 * @since 2.0 (imported from Google Collections Library)
37 */
38@GwtCompatible(emulated = true)
39public final class HashBiMap<K, V> extends AbstractBiMap<K, V> {
40
41  /**
42   * Returns a new, empty {@code HashBiMap} with the default initial capacity
43   * (16).
44   */
45  public static <K, V> HashBiMap<K, V> create() {
46    return new HashBiMap<K, V>();
47  }
48
49  /**
50   * Constructs a new, empty bimap with the specified expected size.
51   *
52   * @param expectedSize the expected number of entries
53   * @throws IllegalArgumentException if the specified expected size is
54   *     negative
55   */
56  public static <K, V> HashBiMap<K, V> create(int expectedSize) {
57    return new HashBiMap<K, V>(expectedSize);
58  }
59
60  /**
61   * Constructs a new bimap containing initial values from {@code map}. The
62   * bimap is created with an initial capacity sufficient to hold the mappings
63   * in the specified map.
64   */
65  public static <K, V> HashBiMap<K, V> create(
66      Map<? extends K, ? extends V> map) {
67    HashBiMap<K, V> bimap = create(map.size());
68    bimap.putAll(map);
69    return bimap;
70  }
71
72  private HashBiMap() {
73    super(new HashMap<K, V>(), new HashMap<V, K>());
74  }
75
76  private HashBiMap(int expectedSize) {
77    super(
78        Maps.<K, V>newHashMapWithExpectedSize(expectedSize),
79        Maps.<V, K>newHashMapWithExpectedSize(expectedSize));
80  }
81
82  // Override these two methods to show that keys and values may be null
83
84  @Override public V put(@Nullable K key, @Nullable V value) {
85    return super.put(key, value);
86  }
87
88  @Override public V forcePut(@Nullable K key, @Nullable V value) {
89    return super.forcePut(key, value);
90  }
91
92  /**
93   * @serialData the number of entries, first key, first value, second key,
94   *     second value, and so on.
95   */
96  @GwtIncompatible("java.io.ObjectOutputStream")
97  private void writeObject(ObjectOutputStream stream) throws IOException {
98    stream.defaultWriteObject();
99    Serialization.writeMap(this, stream);
100  }
101
102  @GwtIncompatible("java.io.ObjectInputStream")
103  private void readObject(ObjectInputStream stream)
104      throws IOException, ClassNotFoundException {
105    stream.defaultReadObject();
106    int size = Serialization.readCount(stream);
107    setDelegates(Maps.<K, V>newHashMapWithExpectedSize(size),
108        Maps.<V, K>newHashMapWithExpectedSize(size));
109    Serialization.populateMap(this, stream, size);
110  }
111
112  @GwtIncompatible("Not needed in emulated source")
113  private static final long serialVersionUID = 0;
114}
115