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