1 /* 2 * Copyright (C) 2010 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 17 package com.google.common.collect; 18 19 import com.google.common.annotations.Beta; 20 import com.google.common.annotations.GwtCompatible; 21 import com.google.common.annotations.GwtIncompatible; 22 import com.google.common.base.Equivalence; 23 import com.google.common.base.Function; 24 import com.google.common.base.Objects; 25 import com.google.common.collect.MapMaker.RemovalListener; 26 import com.google.common.collect.MapMaker.RemovalNotification; 27 28 import java.util.concurrent.ConcurrentMap; 29 import java.util.concurrent.TimeUnit; 30 31 /** 32 * A class exactly like {@link MapMaker}, except restricted in the types of maps it can build. 33 * For the most part, you should probably just ignore the existence of this class. 34 * 35 * @paramthe base type for all key types of maps built by this map maker 36 * @param the base type for all value types of maps built by this map maker 37 * @author Kevin Bourrillion 38 * @since 7.0 39 */ 40 @Beta 41 @GwtCompatible(emulated = true) 42 public abstract class GenericMapMaker<K0, V0> { 43 @GwtIncompatible("To be supported") 44 enum NullListener implements RemovalListener<Object, Object> { 45 INSTANCE; 46 47 @Override 48 public void onRemoval(RemovalNotification<Object, Object> notification) {} 49 } 50 51 // Set by MapMaker, but sits in this class to preserve the type relationship 52 @GwtIncompatible("To be supported") 53 RemovalListener<K0, V0> removalListener; 54 55 // No subclasses but our own 56 GenericMapMaker() {} 57 58 /** 59 * See {@link MapMaker#keyEquivalence}. 60 */ 61 @GwtIncompatible("To be supported") 62 abstract GenericMapMaker<K0, V0> keyEquivalence(Equivalence<Object> equivalence); 63 64 /** 65 * See {@link MapMaker#valueEquivalence}. 66 */ 67 @GwtIncompatible("To be supported") 68 abstract GenericMapMaker<K0, V0> valueEquivalence(Equivalence<Object> equivalence); 69 70 /** 71 * See {@link MapMaker#initialCapacity}. 72 */ 73 public abstract GenericMapMaker<K0, V0> initialCapacity(int initialCapacity); 74 75 /** 76 * See {@link MapMaker#maximumSize}. 77 */ 78 abstract GenericMapMaker<K0, V0> maximumSize(int maximumSize); 79 80 /** 81 * See {@link MapMaker#strongKeys}. 82 */ 83 abstract GenericMapMaker<K0, V0> strongKeys(); 84 85 /** 86 * See {@link MapMaker#concurrencyLevel}. 87 */ 88 public abstract GenericMapMaker<K0, V0> concurrencyLevel(int concurrencyLevel); 89 90 /** 91 * See {@link MapMaker#weakKeys}. 92 */ 93 @GwtIncompatible("java.lang.ref.WeakReference") 94 public abstract GenericMapMaker<K0, V0> weakKeys(); 95 96 /** 97 * See {@link MapMaker#strongValues}. 98 */ 99 abstract GenericMapMaker<K0, V0> strongValues(); 100 101 /** 102 * See {@link MapMaker#softKeys}. 103 */ 104 @Deprecated 105 @GwtIncompatible("java.lang.ref.SoftReference") 106 public abstract GenericMapMaker<K0, V0> softKeys(); 107 108 /** 109 * See {@link MapMaker#weakValues}. 110 */ 111 @GwtIncompatible("java.lang.ref.WeakReference") 112 public abstract GenericMapMaker<K0, V0> weakValues(); 113 114 /** 115 * See {@link MapMaker#softValues}. 116 */ 117 @GwtIncompatible("java.lang.ref.SoftReference") 118 public abstract GenericMapMaker<K0, V0> softValues(); 119 120 /** 121 * See {@link MapMaker#expiration}. 122 */ 123 @Deprecated 124 public 125 abstract GenericMapMaker<K0, V0> expiration(long duration, TimeUnit unit); 126 127 /** 128 * See {@link MapMaker#expireAfterWrite}. 129 */ 130 abstract GenericMapMaker<K0, V0> expireAfterWrite(long duration, TimeUnit unit); 131 132 /** 133 * See {@link MapMaker#expireAfterAccess}. 134 */ 135 @GwtIncompatible("To be supported") 136 abstract GenericMapMaker<K0, V0> expireAfterAccess(long duration, TimeUnit unit); 137 138 /* 139 * Note that MapMaker's removalListener() is not here, because once you're interacting with a 140 * GenericMapMaker you've already called that, and shouldn't be calling it again. 141 */ 142 143 @SuppressWarnings("unchecked") // safe covariant cast 144 @GwtIncompatible("To be supported") 145 <K extends K0, V extends V0> RemovalListener<K, V> getRemovalListener() { 146 return (RemovalListener<K, V>) Objects.firstNonNull(removalListener, NullListener.INSTANCE); 147 } 148 149 /** 150 * See {@link MapMaker#makeMap}. 151 */ 152 public abstract <K extends K0, V extends V0> ConcurrentMap<K, V> makeMap(); 153 154 /** 155 * See {@link MapMaker#makeCustomMap}. 156 */ 157 @GwtIncompatible("MapMakerInternalMap") 158 abstract <K, V> MapMakerInternalMap<K, V> makeCustomMap(); 159 160 /** 161 * See {@link MapMaker#makeComputingMap}. 162 */ 163 @Deprecated 164 public abstract <K extends K0, V extends V0> ConcurrentMap<K, V> makeComputingMap( 165 Function<? super K, ? extends V> computingFunction); 166 } 167
