KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > sun > xml > fastinfoset > util > KeyIntMap


1 /*
2  * Fast Infoset ver. 0.1 software ("Software")
3  *
4  * Copyright, 2004-2005 Sun Microsystems, Inc. All Rights Reserved.
5  *
6  * Software is licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License. You may
8  * obtain a copy of the License at:
9  *
10  * http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
14  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
15  * License for the specific language governing permissions and limitations.
16  *
17  * Sun supports and benefits from the global community of open source
18  * developers, and thanks the community for its important contributions and
19  * open standards-based technology, which Sun has adopted into many of its
20  * products.
21  *
22  * Please note that portions of Software may be provided with notices and
23  * open source licenses from such communities and third parties that govern the
24  * use of those portions, and any licenses granted hereunder do not alter any
25  * rights and obligations you may have under such open source licenses,
26  * however, the disclaimer of warranty and limitation of liability provisions
27  * in this License will apply to all Software in this distribution.
28  *
29  * You acknowledge that the Software is not designed, licensed or intended
30  * for use in the design, construction, operation or maintenance of any nuclear
31  * facility.
32  *
33  * Apache License
34  * Version 2.0, January 2004
35  * http://www.apache.org/licenses/
36  *
37  */
38
39
40 package com.sun.xml.fastinfoset.util;
41 import com.sun.xml.fastinfoset.CommonResourceBundle;
42
43 public abstract class KeyIntMap {
44     public static final int NOT_PRESENT = -1;
45     
46     /**
47      * The default initial capacity - MUST be a power of two.
48      */
49     static final int DEFAULT_INITIAL_CAPACITY = 16;
50
51     /**
52      * The maximum capacity, used if a higher value is implicitly specified
53      * by either of the constructors with arguments.
54      * MUST be a power of two <= 1<<30.
55      */
56     static final int MAXIMUM_CAPACITY = 1 << 20;
57
58     /**
59      * The load factor used when none specified in constructor.
60      **/
61     static final float DEFAULT_LOAD_FACTOR = 0.75f;
62     
63     int _readOnlyMapSize;
64     
65     /**
66      * The number of key-value mappings contained in this identity hash map.
67      */
68     int _size;
69   
70     int _capacity;
71     
72     /**
73      * The next size value at which to resize (capacity * load factor).
74      */
75     int _threshold;
76   
77     /**
78      * The load factor for the hash table.
79      */
80     final float _loadFactor;
81
82     static class BaseEntry {
83         final int _hash;
84         final int _value;
85
86         public BaseEntry(int hash, int value) {
87             _hash = hash;
88             _value = value;
89         }
90     }
91  
92     public KeyIntMap(int initialCapacity, float loadFactor) {
93         if (initialCapacity < 0)
94             throw new IllegalArgumentException JavaDoc(CommonResourceBundle.getInstance().
95                     getString("message.illegalInitialCapacity", new Object JavaDoc[]{new Integer JavaDoc(initialCapacity)}));
96         if (initialCapacity > MAXIMUM_CAPACITY)
97             initialCapacity = MAXIMUM_CAPACITY;
98         if (loadFactor <= 0 || Float.isNaN(loadFactor))
99             throw new IllegalArgumentException JavaDoc(CommonResourceBundle.getInstance().
100                     getString("message.illegalLoadFactor", new Object JavaDoc[]{new Float JavaDoc(loadFactor)}));
101
102         // Find a power of 2 >= initialCapacity
103 if (initialCapacity != DEFAULT_INITIAL_CAPACITY) {
104             _capacity = 1;
105             while (_capacity < initialCapacity)
106                 _capacity <<= 1;
107
108             _loadFactor = loadFactor;
109             _threshold = (int)(_capacity * _loadFactor);
110         } else {
111             _capacity = DEFAULT_INITIAL_CAPACITY;
112             _loadFactor = DEFAULT_LOAD_FACTOR;
113             _threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
114         }
115     }
116     
117     public KeyIntMap(int initialCapacity) {
118         this(initialCapacity, DEFAULT_LOAD_FACTOR);
119     }
120
121     public KeyIntMap() {
122         _capacity = DEFAULT_INITIAL_CAPACITY;
123         _loadFactor = DEFAULT_LOAD_FACTOR;
124         _threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
125     }
126
127     public final int size() {
128         return _size + _readOnlyMapSize;
129     }
130
131     public abstract void clear();
132     
133     public abstract void setReadOnlyMap(KeyIntMap readOnlyMap, boolean clear);
134
135     
136     public static final int hashHash(int h) {
137         h += ~(h << 9);
138         h ^= (h >>> 14);
139         h += (h << 4);
140         h ^= (h >>> 10);
141         return h;
142     }
143
144     public static final int indexFor(int h, int length) {
145         return h & (length-1);
146     }
147
148 }
149
Popular Tags