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.deploy;
018:
019: import org.apache.catalina.util.RequestUtil;
020: import java.io.Serializable;
021:
022: /**
023: * Representation of a filter mapping for a web application, as represented
024: * in a <code><filter-mapping></code> element in the deployment
025: * descriptor. Each filter mapping must contain a filter name plus either
026: * a URL pattern or a servlet name.
027: *
028: * @author Craig R. McClanahan
029: * @version $Revision: 1.7 $ $Date: 2004/05/13 20:40:49 $
030: */
031:
032: public class FilterMap implements Serializable {
033:
034: // ------------------------------------------------------------- Properties
035:
036: /**
037: * The name of this filter to be executed when this mapping matches
038: * a particular request.
039: */
040:
041: public static final int ERROR = 1;
042: public static final int FORWARD = 2;
043: public static final int FORWARD_ERROR = 3;
044: public static final int INCLUDE = 4;
045: public static final int INCLUDE_ERROR = 5;
046: public static final int INCLUDE_ERROR_FORWARD = 6;
047: public static final int INCLUDE_FORWARD = 7;
048: public static final int REQUEST = 8;
049: public static final int REQUEST_ERROR = 9;
050: public static final int REQUEST_ERROR_FORWARD = 10;
051: public static final int REQUEST_ERROR_FORWARD_INCLUDE = 11;
052: public static final int REQUEST_ERROR_INCLUDE = 12;
053: public static final int REQUEST_FORWARD = 13;
054: public static final int REQUEST_INCLUDE = 14;
055: public static final int REQUEST_FORWARD_INCLUDE = 15;
056:
057: // represents nothing having been set. This will be seen
058: // as equal to a REQUEST
059: private static final int NOT_SET = -1;
060:
061: private int dispatcherMapping = NOT_SET;
062:
063: private String filterName = null;
064:
065: public String getFilterName() {
066: return (this .filterName);
067: }
068:
069: public void setFilterName(String filterName) {
070: this .filterName = filterName;
071: }
072:
073: /**
074: * The servlet name this mapping matches.
075: */
076: private String servletName = null;
077:
078: public String getServletName() {
079: return (this .servletName);
080: }
081:
082: public void setServletName(String servletName) {
083: this .servletName = servletName;
084: }
085:
086: /**
087: * The URL pattern this mapping matches.
088: */
089: private String urlPattern = null;
090:
091: public String getURLPattern() {
092: return (this .urlPattern);
093: }
094:
095: public void setURLPattern(String urlPattern) {
096: this .urlPattern = RequestUtil.URLDecode(urlPattern);
097: }
098:
099: /**
100: *
101: * This method will be used to set the current state of the FilterMap
102: * representing the state of when filters should be applied:
103: *
104: * ERROR
105: * FORWARD
106: * FORWARD_ERROR
107: * INCLUDE
108: * INCLUDE_ERROR
109: * INCLUDE_ERROR_FORWARD
110: * REQUEST
111: * REQUEST_ERROR
112: * REQUEST_ERROR_INCLUDE
113: * REQUEST_ERROR_FORWARD_INCLUDE
114: * REQUEST_INCLUDE
115: * REQUEST_FORWARD,
116: * REQUEST_FORWARD_INCLUDE
117: *
118: */
119: public void setDispatcher(String dispatcherString) {
120: String dispatcher = dispatcherString.toUpperCase();
121:
122: if (dispatcher.equals("FORWARD")) {
123:
124: // apply FORWARD to the global dispatcherMapping.
125: switch (dispatcherMapping) {
126: case NOT_SET:
127: dispatcherMapping = FORWARD;
128: break;
129: case ERROR:
130: dispatcherMapping = FORWARD_ERROR;
131: break;
132: case INCLUDE:
133: dispatcherMapping = INCLUDE_FORWARD;
134: break;
135: case INCLUDE_ERROR:
136: dispatcherMapping = INCLUDE_ERROR_FORWARD;
137: break;
138: case REQUEST:
139: dispatcherMapping = REQUEST_FORWARD;
140: break;
141: case REQUEST_ERROR:
142: dispatcherMapping = REQUEST_ERROR_FORWARD;
143: break;
144: case REQUEST_ERROR_INCLUDE:
145: dispatcherMapping = REQUEST_ERROR_FORWARD_INCLUDE;
146: break;
147: case REQUEST_INCLUDE:
148: dispatcherMapping = REQUEST_FORWARD_INCLUDE;
149: break;
150: }
151: } else if (dispatcher.equals("INCLUDE")) {
152: // apply INCLUDE to the global dispatcherMapping.
153: switch (dispatcherMapping) {
154: case NOT_SET:
155: dispatcherMapping = INCLUDE;
156: break;
157: case ERROR:
158: dispatcherMapping = INCLUDE_ERROR;
159: break;
160: case FORWARD:
161: dispatcherMapping = INCLUDE_FORWARD;
162: break;
163: case FORWARD_ERROR:
164: dispatcherMapping = INCLUDE_ERROR_FORWARD;
165: break;
166: case REQUEST:
167: dispatcherMapping = REQUEST_INCLUDE;
168: break;
169: case REQUEST_ERROR:
170: dispatcherMapping = REQUEST_ERROR_INCLUDE;
171: break;
172: case REQUEST_ERROR_FORWARD:
173: dispatcherMapping = REQUEST_ERROR_FORWARD_INCLUDE;
174: break;
175: case REQUEST_FORWARD:
176: dispatcherMapping = REQUEST_FORWARD_INCLUDE;
177: break;
178: }
179: } else if (dispatcher.equals("REQUEST")) {
180: // apply REQUEST to the global dispatcherMapping.
181: switch (dispatcherMapping) {
182: case NOT_SET:
183: dispatcherMapping = REQUEST;
184: break;
185: case ERROR:
186: dispatcherMapping = REQUEST_ERROR;
187: break;
188: case FORWARD:
189: dispatcherMapping = REQUEST_FORWARD;
190: break;
191: case FORWARD_ERROR:
192: dispatcherMapping = REQUEST_ERROR_FORWARD;
193: break;
194: case INCLUDE:
195: dispatcherMapping = REQUEST_INCLUDE;
196: break;
197: case INCLUDE_ERROR:
198: dispatcherMapping = REQUEST_ERROR_INCLUDE;
199: break;
200: case INCLUDE_FORWARD:
201: dispatcherMapping = REQUEST_FORWARD_INCLUDE;
202: break;
203: case INCLUDE_ERROR_FORWARD:
204: dispatcherMapping = REQUEST_ERROR_FORWARD_INCLUDE;
205: break;
206: }
207: } else if (dispatcher.equals("ERROR")) {
208: // apply ERROR to the global dispatcherMapping.
209: switch (dispatcherMapping) {
210: case NOT_SET:
211: dispatcherMapping = ERROR;
212: break;
213: case FORWARD:
214: dispatcherMapping = FORWARD_ERROR;
215: break;
216: case INCLUDE:
217: dispatcherMapping = INCLUDE_ERROR;
218: break;
219: case INCLUDE_FORWARD:
220: dispatcherMapping = INCLUDE_ERROR_FORWARD;
221: break;
222: case REQUEST:
223: dispatcherMapping = REQUEST_ERROR;
224: break;
225: case REQUEST_INCLUDE:
226: dispatcherMapping = REQUEST_ERROR_INCLUDE;
227: break;
228: case REQUEST_FORWARD:
229: dispatcherMapping = REQUEST_ERROR_FORWARD;
230: break;
231: case REQUEST_FORWARD_INCLUDE:
232: dispatcherMapping = REQUEST_ERROR_FORWARD_INCLUDE;
233: break;
234: }
235: }
236: }
237:
238: public int getDispatcherMapping() {
239: // per the SRV.6.2.5 absence of any dispatcher elements is
240: // equivelant to a REQUEST value
241: if (dispatcherMapping == NOT_SET)
242: return REQUEST;
243: else
244: return dispatcherMapping;
245: }
246:
247: // --------------------------------------------------------- Public Methods
248:
249: /**
250: * Render a String representation of this object.
251: */
252: public String toString() {
253:
254: StringBuffer sb = new StringBuffer("FilterMap[");
255: sb.append("filterName=");
256: sb.append(this .filterName);
257: if (servletName != null) {
258: sb.append(", servletName=");
259: sb.append(servletName);
260: }
261: if (urlPattern != null) {
262: sb.append(", urlPattern=");
263: sb.append(urlPattern);
264: }
265: sb.append("]");
266: return (sb.toString());
267:
268: }
269:
270: }
|