misc changes
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / codegen / LongCache.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2001, 2002 International Business Machines Corp. and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v0.5 
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v05.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  ******************************************************************************/
11 package net.sourceforge.phpdt.internal.compiler.codegen;
12
13 public class LongCache {
14         public long keyTable[];
15         public int valueTable[]; 
16         int elementSize;
17         int threshold;
18 /**
19  * Constructs a new, empty hashtable. A default capacity and
20  * load factor is used. Note that the hashtable will automatically 
21  * grow when it gets full.
22  */
23 public LongCache() {
24         this(13);
25 }
26 /**
27  * Constructs a new, empty hashtable with the specified initial
28  * capacity.
29  * @param initialCapacity int
30  *  the initial number of buckets
31  */
32 public LongCache(int initialCapacity) {
33         elementSize = 0;
34         threshold = (int) (initialCapacity * 0.66);
35         keyTable = new long[initialCapacity];
36         valueTable = new int[initialCapacity];
37 }
38 /**
39  * Clears the hash table so that it has no more elements in it.
40  */
41 public void clear() {
42         for (int i = keyTable.length; --i >= 0;) {
43                 keyTable[i] = 0;
44                 valueTable[i] = 0;
45         }
46         elementSize = 0;
47 }
48 /** Returns true if the collection contains an element for the key.
49  *
50  * @param key <CODE>long</CODE> the key that we are looking for
51  * @return boolean
52  */
53 public boolean containsKey(long key) {
54         int index = hash(key);
55         while ((keyTable[index] != 0) || ((keyTable[index] == 0) &&(valueTable[index] != 0))) {
56                 if (keyTable[index] == key)
57                         return true;
58                 index = (index + 1) % keyTable.length;
59         }
60         return false;
61 }
62 /** Gets the object associated with the specified key in the
63  * hashtable.
64  * @param key <CODE>long</CODE> the specified key
65  * @return int the element for the key or -1 if the key is not
66  *  defined in the hash table.
67  */
68 public int get(long key) {
69         int index = hash(key);
70         while ((keyTable[index] != 0) || ((keyTable[index] == 0) &&(valueTable[index] != 0))) {
71                 if (keyTable[index] == key)
72                         return valueTable[index];
73                 index = (index + 1) % keyTable.length;
74         }
75         return -1;
76 }
77 /**
78  * Return a hashcode for the value of the key parameter.
79  * @param key long
80  * @return int the hash code corresponding to the key value
81  */
82 public int hash(long key) {
83         return ((int) key & 0x7FFFFFFF) % keyTable.length;
84 }
85 /**
86  * Puts the specified element into the hashtable, using the specified
87  * key.  The element may be retrieved by doing a get() with the same key.
88  * 
89  * @param key <CODE>long</CODE> the specified key in the hashtable
90  * @param value <CODE>int</CODE> the specified element
91  * @return int value
92  */
93 public int put(long key, int value) {
94         int index = hash(key);
95         while ((keyTable[index] != 0) || ((keyTable[index] == 0) && (valueTable[index] != 0))) {
96                 if (keyTable[index] == key)
97                         return valueTable[index] = value;
98                 index = (index + 1) % keyTable.length;
99         }
100         keyTable[index] = key;
101         valueTable[index] = value;
102
103         // assumes the threshold is never equal to the size of the table
104         if (++elementSize > threshold) {
105                 rehash();
106         }
107         return value;
108 }
109 /**
110  * Rehashes the content of the table into a bigger table.
111  * This method is called automatically when the hashtable's
112  * size exceeds the threshold.
113  */
114 private void rehash() {
115         LongCache newHashtable = new LongCache(keyTable.length * 2);
116         for (int i = keyTable.length; --i >= 0;) {
117                 long key = keyTable[i];
118                 int value = valueTable[i];
119                 if ((key != 0) || ((key == 0) && (value != 0))) {
120                         newHashtable.put(key, value);
121                 }
122         }
123         this.keyTable = newHashtable.keyTable;
124         this.valueTable = newHashtable.valueTable;
125         this.threshold = newHashtable.threshold;
126 }
127 /**
128  * Returns the number of elements contained in the hashtable.
129  *
130  * @return <CODE>int</CODE> The size of the table
131  */
132 public int size() {
133         return elementSize;
134 }
135 /**
136  * Converts to a rather lengthy String.
137  *
138  * @return String the ascii representation of the receiver
139  */
140 public String toString() {
141         int max = size();
142         StringBuffer buf = new StringBuffer();
143         buf.append("{"); //$NON-NLS-1$
144         for (int i = 0; i < max; ++i) {
145                 if ((keyTable[i] != 0) || ((keyTable[i] == 0) && (valueTable[i] != 0))) {
146                         buf.append(keyTable[i]).append("->").append(valueTable[i]); //$NON-NLS-1$
147                 }
148                 if (i < max) {
149                         buf.append(", "); //$NON-NLS-1$
150                 }
151         }
152         buf.append("}"); //$NON-NLS-1$
153         return buf.toString();
154 }
155 }