KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > eclipse > jdt > internal > compiler > codegen > MethodNameAndTypeCache


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