001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017:
018: package org.apache.catalina.util;
019:
020: import java.util.HashMap;
021: import java.util.Map;
022:
023: /**
024: * Extended implementation of <strong>HashMap</strong> that includes a
025: * <code>locked</code> property. This class can be used to safely expose
026: * Catalina internal parameter map objects to user classes without having
027: * to clone them in order to avoid modifications. When first created, a
028: * <code>ParmaeterMap</code> instance is not locked.
029: *
030: * @author Craig R. McClanahan
031: * @version $Revision: 467222 $ $Date: 2006-10-24 05:17:11 +0200 (mar., 24 oct. 2006) $
032: */
033:
034: public final class ParameterMap extends HashMap {
035:
036: // ----------------------------------------------------------- Constructors
037:
038: /**
039: * Construct a new, empty map with the default initial capacity and
040: * load factor.
041: */
042: public ParameterMap() {
043:
044: super ();
045:
046: }
047:
048: /**
049: * Construct a new, empty map with the specified initial capacity and
050: * default load factor.
051: *
052: * @param initialCapacity The initial capacity of this map
053: */
054: public ParameterMap(int initialCapacity) {
055:
056: super (initialCapacity);
057:
058: }
059:
060: /**
061: * Construct a new, empty map with the specified initial capacity and
062: * load factor.
063: *
064: * @param initialCapacity The initial capacity of this map
065: * @param loadFactor The load factor of this map
066: */
067: public ParameterMap(int initialCapacity, float loadFactor) {
068:
069: super (initialCapacity, loadFactor);
070:
071: }
072:
073: /**
074: * Construct a new map with the same mappings as the given map.
075: *
076: * @param map Map whose contents are dupliated in the new map
077: */
078: public ParameterMap(Map map) {
079:
080: super (map);
081:
082: }
083:
084: // ------------------------------------------------------------- Properties
085:
086: /**
087: * The current lock state of this parameter map.
088: */
089: private boolean locked = false;
090:
091: /**
092: * Return the locked state of this parameter map.
093: */
094: public boolean isLocked() {
095:
096: return (this .locked);
097:
098: }
099:
100: /**
101: * Set the locked state of this parameter map.
102: *
103: * @param locked The new locked state
104: */
105: public void setLocked(boolean locked) {
106:
107: this .locked = locked;
108:
109: }
110:
111: /**
112: * The string manager for this package.
113: */
114: private static final StringManager sm = StringManager
115: .getManager("org.apache.catalina.util");
116:
117: // --------------------------------------------------------- Public Methods
118:
119: /**
120: * Remove all mappings from this map.
121: *
122: * @exception IllegalStateException if this map is currently locked
123: */
124: public void clear() {
125:
126: if (locked)
127: throw new IllegalStateException(sm
128: .getString("parameterMap.locked"));
129: super .clear();
130:
131: }
132:
133: /**
134: * Associate the specified value with the specified key in this map. If
135: * the map previously contained a mapping for this key, the old value is
136: * replaced.
137: *
138: * @param key Key with which the specified value is to be associated
139: * @param value Value to be associated with the specified key
140: *
141: * @return The previous value associated with the specified key, or
142: * <code>null</code> if there was no mapping for key
143: *
144: * @exception IllegalStateException if this map is currently locked
145: */
146: public Object put(Object key, Object value) {
147:
148: if (locked)
149: throw new IllegalStateException(sm
150: .getString("parameterMap.locked"));
151: return (super .put(key, value));
152:
153: }
154:
155: /**
156: * Copy all of the mappings from the specified map to this one. These
157: * mappings replace any mappings that this map had for any of the keys
158: * currently in the specified Map.
159: *
160: * @param map Mappings to be stored into this map
161: *
162: * @exception IllegalStateException if this map is currently locked
163: */
164: public void putAll(Map map) {
165:
166: if (locked)
167: throw new IllegalStateException(sm
168: .getString("parameterMap.locked"));
169: super .putAll(map);
170:
171: }
172:
173: /**
174: * Remove the mapping for this key from the map if present.
175: *
176: * @param key Key whose mapping is to be removed from the map
177: *
178: * @return The previous value associated with the specified key, or
179: * <code>null</code> if there was no mapping for that key
180: *
181: * @exception IllegalStateException if this map is currently locked
182: */
183: public Object remove(Object key) {
184:
185: if (locked)
186: throw new IllegalStateException(sm
187: .getString("parameterMap.locked"));
188: return (super.remove(key));
189:
190: }
191:
192: }
|