001: /*
002: * Copyright 2005-2007 Noelios Consulting.
003: *
004: * The contents of this file are subject to the terms of the Common Development
005: * and Distribution License (the "License"). You may not use this file except in
006: * compliance with the License.
007: *
008: * You can obtain a copy of the license at
009: * http://www.opensource.org/licenses/cddl1.txt See the License for the specific
010: * language governing permissions and limitations under the License.
011: *
012: * When distributing Covered Code, include this CDDL HEADER in each file and
013: * include the License file at http://www.opensource.org/licenses/cddl1.txt If
014: * applicable, add the following below this CDDL HEADER, with the fields
015: * enclosed by brackets "[]" replaced with your own identifying information:
016: * Portions Copyright [yyyy] [name of copyright owner]
017: */
018:
019: package org.restlet;
020:
021: import java.util.Map;
022: import java.util.TreeMap;
023: import java.util.logging.Logger;
024:
025: import org.restlet.data.Form;
026: import org.restlet.data.Parameter;
027: import org.restlet.util.Series;
028:
029: /**
030: * Contextual data and services provided to a Restlet. The context is the means
031: * by which a Restlet may access the software environment within the framework.
032: * It is typically provided by the immediate parent Restlet (Component and
033: * Application are the most common cases).
034: *
035: * @author Jerome Louvel (contact@noelios.com)
036: */
037: public class Context {
038: /** The modifiable attributes map. */
039: private Map<String, Object> attributes;
040:
041: /** The modifiable series of parameters. */
042: private Series<Parameter> parameters;
043:
044: /** The logger instance to use. */
045: private Logger logger;
046:
047: /**
048: * Constructor. Writes log messages to "org.restlet".
049: */
050: public Context() {
051: this ("org.restlet");
052: }
053:
054: /**
055: * Constructor.
056: *
057: * @param logger
058: * The logger instance of use.
059: */
060: public Context(Logger logger) {
061: this .logger = logger;
062: }
063:
064: /**
065: * Constructor.
066: *
067: * @param loggerName
068: * The name of the logger to use.
069: */
070: public Context(String loggerName) {
071: this (Logger.getLogger(loggerName));
072: }
073:
074: /**
075: * Returns a modifiable attributes map that can be used by developers to
076: * save information relative to the context. This is a convenient mean to
077: * provide common objects to all the Restlets and Resources composing an
078: * Application.<br/> <br/>
079: *
080: * In addition, this map is a shared space between the developer and the
081: * Restlet implementation. For this purpose, all attribute names starting
082: * with "org.restlet" are reserved. Currently the following attributes are
083: * used: <table>
084: * <tr>
085: * <th>Attribute name</th>
086: * <th>Class name</th>
087: * <th>Description</th>
088: * </tr>
089: * <tr>
090: * <td>org.restlet.application</td>
091: * <td>org.restlet.Application</td>
092: * <td>The parent application providing this context, if any. </td>
093: * </tr>
094: * </table></td>
095: *
096: * @return The modifiable attributes map.
097: */
098: public Map<String, Object> getAttributes() {
099: if (this .attributes == null) {
100: this .attributes = new TreeMap<String, Object>();
101: }
102:
103: return this .attributes;
104: }
105:
106: /**
107: * Returns a request dispatcher to available client connectors. When you ask
108: * the dispatcher to handle a request, it will automatically select the best
109: * client connector for your request, based on the request.protocol property
110: * or on the resource URI's scheme. This call is blocking and will return an
111: * updated response object.
112: *
113: * @return A request dispatcher to available client connectors.
114: */
115: public Uniform getDispatcher() {
116: return null;
117: }
118:
119: /**
120: * Returns the logger.
121: *
122: * @return The logger.
123: */
124: public Logger getLogger() {
125: return this .logger;
126: }
127:
128: /**
129: * Returns the modifiable series of parameters. A parameter is a pair
130: * composed of a name and a value and is typically used for configuration
131: * purpose, like Java properties. Note that multiple parameters with the
132: * same name can be declared and accessed.
133: *
134: * @return The modifiable series of parameters.
135: */
136: public Series<Parameter> getParameters() {
137: if (this .parameters == null)
138: this .parameters = new Form();
139: return this .parameters;
140: }
141:
142: /**
143: * Sets the logger.
144: *
145: * @param logger
146: * The logger.
147: */
148: public void setLogger(Logger logger) {
149: this.logger = logger;
150: }
151:
152: }
|