001: /*
002: * Copyright 2005-2006 The Kuali Foundation.
003: *
004: * Licensed under the Educational Community License, Version 1.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.opensource.org/licenses/ecl1.php
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: package org.kuali.core.util;
017:
018: import java.util.Collection;
019: import java.util.Map;
020: import java.util.Properties;
021: import java.util.Set;
022:
023: import org.kuali.core.util.properties.PropertyTree;
024:
025: /**
026: * This class implements the Map interface for a Properties instance. Exports all properties from the given Properties instance as
027: * constants, usable from jstl. Implements the Map interface (by delegating everything to the PropertyTree, which really implements
028: * the Map methods directly) so that jstl can translate ${Constants.a} into a call to ConfigConstants.get( "a" ).
029: * <p>
030: * The contents of this Map cannot be changed once it has been initialized. Any calls to any of the Map methods made before the
031: * propertyTree has been initialized (i.e. before setProperties has been called) will throw an IllegalStateException.
032: * <p>
033: * Jstl converts ${Constants.a.b.c} into get("a").get("b").get("c"), so the properties are stored in a PropertyTree, which converts
034: * the initial set( "a.b.c", "value" ) into construction of the necessary tree structure to support get("a").get("b").get("c").
035: * <p>
036: * Implicitly relies on the assumption that the JSP will be calling toString() on the result of the final <code>get</code>, since
037: * <code>get</code> can only return one type, and that type must be the complex one so that further dereferencing will be
038: * possible.
039: *
040: *
041: */
042:
043: public abstract class JstlPropertyHolder implements Map {
044: private PropertyTree propertyTree;
045:
046: /**
047: * Default constructor
048: */
049: public JstlPropertyHolder() {
050: propertyTree = null;
051: }
052:
053: /**
054: * Creates a propertyTree to store the given properties
055: *
056: * @param properties
057: */
058: protected void setProperties(Properties properties) {
059: propertyTree = new PropertyTree(properties);
060: }
061:
062: /**
063: * Copies in the given propertyTree rather than building its own. Reasonably dangerous, since that tree might presumably be
064: * modified, violating the readonlyness of this datastructure.
065: *
066: * @param properties
067: */
068: protected void setPropertyTree(PropertyTree tree) {
069: propertyTree = tree;
070: }
071:
072: // delegated methods
073: /**
074: * @see org.kuali.core.util.properties.PropertyTree#get(java.lang.Object)
075: */
076: public Object get(Object key) {
077: if (propertyTree == null) {
078: throw new IllegalStateException(
079: "propertyTree has not been initialized");
080: }
081: return this .propertyTree.get(key);
082: }
083:
084: /**
085: * @see org.kuali.core.util.properties.PropertyTree#size()
086: */
087: public int size() {
088: if (propertyTree == null) {
089: throw new IllegalStateException(
090: "propertyTree has not been initialized");
091: }
092: return this .propertyTree.size();
093: }
094:
095: /**
096: * @see org.kuali.core.util.properties.PropertyTree#clear()
097: */
098: public void clear() {
099: if (propertyTree == null) {
100: throw new IllegalStateException(
101: "propertyTree has not been initialized");
102: }
103: this .propertyTree.clear();
104: }
105:
106: /**
107: * @see org.kuali.core.util.properties.PropertyTree#isEmpty()
108: */
109: public boolean isEmpty() {
110: if (propertyTree == null) {
111: throw new IllegalStateException(
112: "propertyTree has not been initialized");
113: }
114: return this .propertyTree.isEmpty();
115: }
116:
117: /**
118: * @see org.kuali.core.util.properties.PropertyTree#containsKey(java.lang.Object)
119: */
120: public boolean containsKey(Object key) {
121: if (propertyTree == null) {
122: throw new IllegalStateException(
123: "propertyTree has not been initialized");
124: }
125: return this .propertyTree.containsKey(key);
126: }
127:
128: /**
129: * @see org.kuali.core.util.properties.PropertyTree#containsValue(java.lang.Object)
130: */
131: public boolean containsValue(Object value) {
132: if (propertyTree == null) {
133: throw new IllegalStateException(
134: "propertyTree has not been initialized");
135: }
136: return this .propertyTree.containsValue(value);
137: }
138:
139: /**
140: * @see org.kuali.core.util.properties.PropertyTree#values()
141: */
142: public Collection values() {
143: if (propertyTree == null) {
144: throw new IllegalStateException(
145: "propertyTree has not been initialized");
146: }
147: return this .propertyTree.values();
148: }
149:
150: /**
151: * @see org.kuali.core.util.properties.PropertyTree#putAll(java.util.Map)
152: */
153: public void putAll(Map m) {
154: if (propertyTree == null) {
155: throw new IllegalStateException(
156: "propertyTree has not been initialized");
157: }
158: this .propertyTree.putAll(m);
159: }
160:
161: /**
162: * @see org.kuali.core.util.properties.PropertyTree#entrySet()
163: */
164: public Set entrySet() {
165: if (propertyTree == null) {
166: throw new IllegalStateException(
167: "propertyTree has not been initialized");
168: }
169: return this .propertyTree.entrySet();
170: }
171:
172: /**
173: * @see org.kuali.core.util.properties.PropertyTree#keySet()
174: */
175: public Set keySet() {
176: if (propertyTree == null) {
177: throw new IllegalStateException(
178: "propertyTree has not been initialized");
179: }
180: return this .propertyTree.keySet();
181: }
182:
183: /**
184: * @see org.kuali.core.util.properties.PropertyTree#remove(java.lang.Object)
185: */
186: public Object remove(Object key) {
187: if (propertyTree == null) {
188: throw new IllegalStateException(
189: "propertyTree has not been initialized");
190: }
191: return this .propertyTree.remove(key);
192: }
193:
194: /**
195: * @see org.kuali.core.util.properties.PropertyTree#put(java.lang.Object, java.lang.Object)
196: */
197: public Object put(Object key, Object value) {
198: if (propertyTree == null) {
199: throw new IllegalStateException(
200: "propertyTree has not been initialized");
201: }
202: return this.propertyTree.put(key, value);
203: }
204: }
|