1 30 31 32 package org.hsqldb.store; 33 34 import java.sql.Date ; 35 36 48 49 58 public class ValuePoolHashMap extends BaseHashMap { 59 60 public ValuePoolHashMap(int initialCapacity, int maxCapacity, 61 int purgePolicy) throws IllegalArgumentException { 62 63 super(initialCapacity, 1, BaseHashMap.objectKeyOrValue, 64 BaseHashMap.noKeyOrValue, true); 65 66 this.maxCapacity = maxCapacity; 67 this.purgePolicy = purgePolicy; 68 } 69 70 74 public void resetCapacity(int newCapacity, 75 int newPolicy) throws IllegalArgumentException { 76 77 if (newCapacity != 0 && hashIndex.elementCount > newCapacity) { 78 int surplus = hashIndex.elementCount - newCapacity; 79 80 surplus += (surplus >> 5); 81 82 if (surplus > hashIndex.elementCount) { 83 surplus = hashIndex.elementCount; 84 } 85 86 clear(surplus, (surplus >> 6)); 87 } 88 89 if (newCapacity != 0 && newCapacity < threshold) { 90 rehash(newCapacity); 91 92 if (newCapacity < hashIndex.elementCount) { 93 newCapacity = maxCapacity; 94 } 95 } 96 97 this.maxCapacity = newCapacity; 98 this.purgePolicy = newPolicy; 99 } 100 101 protected Integer getOrAddInteger(int intKey) { 102 103 Integer testValue; 104 int index = hashIndex.getHashIndex(intKey); 105 int lookup = hashIndex.hashTable[index]; 106 int lastLookup = -1; 107 108 for (; lookup >= 0; 109 lastLookup = lookup, 110 lookup = hashIndex.getNextLookup(lookup)) { 111 testValue = (Integer ) objectKeyTable[lookup]; 112 113 if (testValue.intValue() == intKey) { 114 if (accessCount == Integer.MAX_VALUE) { 115 resetAccessCount(); 116 } 117 118 accessTable[lookup] = accessCount++; 119 120 return testValue; 121 } 122 } 123 124 if (hashIndex.elementCount >= threshold) { 125 reset(); 126 127 return getOrAddInteger(intKey); 128 } 129 130 lookup = hashIndex.linkNode(index, lastLookup); 131 testValue = new Integer (intKey); 132 objectKeyTable[lookup] = testValue; 133 134 if (accessCount == Integer.MAX_VALUE) { 135 resetAccessCount(); 136 } 137 138 accessTable[lookup] = accessCount++; 139 140 return testValue; 141 } 142 143 protected Long getOrAddLong(long longKey) { 144 145 Long testValue; 146 int index = hashIndex.getHashIndex((int) (longKey 147 ^ (longKey >>> 32))); 148 int lookup = hashIndex.hashTable[index]; 149 int lastLookup = -1; 150 151 for (; lookup >= 0; 152 lastLookup = lookup, 153 lookup = hashIndex.getNextLookup(lookup)) { 154 testValue = (Long ) objectKeyTable[lookup]; 155 156 if (testValue.longValue() == longKey) { 157 if (accessCount == Integer.MAX_VALUE) { 158 resetAccessCount(); 159 } 160 161 accessTable[lookup] = accessCount++; 162 163 return testValue; 164 } 165 } 166 167 if (hashIndex.elementCount >= threshold) { 168 reset(); 169 170 return getOrAddLong(longKey); 171 } 172 173 lookup = hashIndex.linkNode(index, lastLookup); 174 testValue = new Long (longKey); 175 objectKeyTable[lookup] = testValue; 176 177 if (accessCount == Integer.MAX_VALUE) { 178 resetAccessCount(); 179 } 180 181 accessTable[lookup] = accessCount++; 182 183 return testValue; 184 } 185 186 202 protected String getOrAddString(Object key) { 203 204 String testValue; 205 int index = hashIndex.getHashIndex(key.hashCode()); 206 int lookup = hashIndex.hashTable[index]; 207 int lastLookup = -1; 208 209 for (; lookup >= 0; 210 lastLookup = lookup, 211 lookup = hashIndex.getNextLookup(lookup)) { 212 testValue = (String ) objectKeyTable[lookup]; 213 214 if (key.equals(testValue)) { 215 if (accessCount == Integer.MAX_VALUE) { 216 resetAccessCount(); 217 } 218 219 accessTable[lookup] = accessCount++; 220 221 return testValue; 222 } 223 } 224 225 if (hashIndex.elementCount >= threshold) { 226 reset(); 227 228 return getOrAddString(key); 229 } 230 231 testValue = key.toString(); 232 lookup = hashIndex.linkNode(index, lastLookup); 233 objectKeyTable[lookup] = testValue; 234 235 if (accessCount == Integer.MAX_VALUE) { 236 resetAccessCount(); 237 } 238 239 accessTable[lookup] = accessCount++; 240 241 return testValue; 242 } 243 244 protected Date getOrAddDate(long longKey) { 245 246 Date testValue; 247 int hash = (int) longKey ^ (int) (longKey >>> 32); 248 int index = hashIndex.getHashIndex(hash); 249 int lookup = hashIndex.hashTable[index]; 250 int lastLookup = -1; 251 252 for (; lookup >= 0; 253 lastLookup = lookup, 254 lookup = hashIndex.getNextLookup(lookup)) { 255 testValue = (Date ) objectKeyTable[lookup]; 256 257 if (testValue.getTime() == longKey) { 258 if (accessCount == Integer.MAX_VALUE) { 259 resetAccessCount(); 260 } 261 262 accessTable[lookup] = accessCount++; 263 264 return testValue; 265 } 266 } 267 268 if (hashIndex.elementCount >= threshold) { 269 reset(); 270 271 return getOrAddDate(longKey); 272 } 273 274 lookup = hashIndex.linkNode(index, lastLookup); 275 testValue = new Date (longKey); 276 objectKeyTable[lookup] = testValue; 277 278 if (accessCount == Integer.MAX_VALUE) { 279 resetAccessCount(); 280 } 281 282 accessTable[lookup] = accessCount++; 283 284 return testValue; 285 } 286 287 protected Double getOrAddDouble(long longKey) { 288 289 Double testValue; 290 int index = hashIndex.getHashIndex((int) (longKey 291 ^ (longKey >>> 32))); 292 int lookup = hashIndex.hashTable[index]; 293 int lastLookup = -1; 294 295 for (; lookup >= 0; 296 lastLookup = lookup, 297 lookup = hashIndex.getNextLookup(lookup)) { 298 testValue = (Double ) objectKeyTable[lookup]; 299 300 if (Double.doubleToLongBits(testValue.doubleValue()) == longKey) { 301 if (accessCount == Integer.MAX_VALUE) { 302 resetAccessCount(); 303 } 304 305 accessTable[lookup] = accessCount++; 306 307 return testValue; 308 } 309 } 310 311 if (hashIndex.elementCount >= threshold) { 312 reset(); 313 314 return getOrAddDouble(longKey); 315 } 316 317 lookup = hashIndex.linkNode(index, lastLookup); 318 testValue = new Double (Double.longBitsToDouble(longKey)); 319 objectKeyTable[lookup] = testValue; 320 321 if (accessCount == Integer.MAX_VALUE) { 322 resetAccessCount(); 323 } 324 325 accessTable[lookup] = accessCount++; 326 327 return testValue; 328 } 329 330 protected Object getOrAddObject(Object key) { 331 332 Object testValue; 333 int index = hashIndex.getHashIndex(key.hashCode()); 334 int lookup = hashIndex.hashTable[index]; 335 int lastLookup = -1; 336 337 for (; lookup >= 0; 338 lastLookup = lookup, 339 lookup = hashIndex.getNextLookup(lookup)) { 340 testValue = objectKeyTable[lookup]; 341 342 if (testValue.equals(key)) { 343 if (accessCount == Integer.MAX_VALUE) { 344 resetAccessCount(); 345 } 346 347 accessTable[lookup] = accessCount++; 348 349 return testValue; 350 } 351 } 352 353 if (hashIndex.elementCount >= threshold) { 354 reset(); 355 356 return getOrAddObject(key); 357 } 358 359 lookup = hashIndex.linkNode(index, lastLookup); 360 objectKeyTable[lookup] = key; 361 362 if (accessCount == Integer.MAX_VALUE) { 363 resetAccessCount(); 364 } 365 366 accessTable[lookup] = accessCount++; 367 368 return key; 369 } 370 425 } 426 | Popular Tags |