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: package org.apache.jetspeed.capabilities.impl;
018:
019: import org.apache.commons.logging.Log;
020: import org.apache.commons.logging.LogFactory;
021: import org.apache.jetspeed.capabilities.CapabilityMap;
022: import org.apache.jetspeed.capabilities.Client;
023: import org.apache.jetspeed.capabilities.Capability;
024: import org.apache.jetspeed.capabilities.MediaType;
025:
026: import java.util.HashMap;
027: import java.util.Iterator;
028: import java.util.Map;
029:
030: import org.apache.jetspeed.capabilities.MimeType;
031:
032: /**
033: * Implementation for capabilityMap interface
034: *
035: * @author <a href="mailto:roger.ruttimann@earthlink.net">Roger Ruttimann</a>
036: * @version $Id: CapabilityMapImpl.java 553014 2007-07-03 23:10:53Z ate $
037: */
038: class CapabilityMapImpl implements CapabilityMap {
039: private static final Log log = LogFactory
040: .getLog(JetspeedCapabilities.class);
041:
042: // Members
043: private String useragent; // User agent for request
044: private Map mimeTypeMap = new HashMap(); // supported Mimetypes for Agent
045: private Map capabilityMap = new HashMap();
046: // supported Capabilities for Agent
047: private Map mediaTypeMap = new HashMap(); // supported MediaTypes for Agent
048: private Client client; // client for Agent
049: private MediaType preferredMediaType; // Preferred MediaType for client.
050:
051: /**
052: Sets the client for the CapabilityMap
053: */
054: public void setClient(Client client) {
055: this .client = client;
056: }
057:
058: /**
059: Returns the Client for the CapabilityMap
060: */
061: public Client getClient() {
062: return this .client;
063: }
064:
065: /**
066: Add capability to the CapabilityMap
067: */
068: public void addCapability(Capability capability) {
069: if (capability != null) // avoid null due to duplicates in database
070: this .capabilityMap.put(capability.getName(), capability);
071: }
072:
073: /**
074: Add Mimetype to the MimetypeMap
075: */
076: public void addMimetype(MimeType mimetype) {
077: if (mimetype != null) // avoid null due to duplicates in database
078: this .mimeTypeMap.put(mimetype.getName(), mimetype);
079: }
080:
081: /**
082: Add MediaType to the MediaTypeMap
083: */
084: public void addMediaType(MediaType mediatype) {
085: if (mediatype != null) // avoid null due to duplicates in database
086: this .mediaTypeMap.put(mediatype.getName(), mediatype);
087: }
088:
089: /**
090: Returns the preferred MIME type for the current user-agent
091: */
092: public MimeType getPreferredType() {
093: // Return the value that matches the preferredMimeType defined in the Client
094: int prefMimeTypeId = this .client.getPreferredMimeTypeId();
095:
096: MimeType mt = null;
097: Iterator e = this .mimeTypeMap.values().iterator();
098: while (e.hasNext()) {
099: mt = (MimeType) e.next();
100:
101: if (mt.getMimetypeId() == prefMimeTypeId)
102: return mt;
103: }
104: log.error("Could not find preferred Mime Type for "
105: + prefMimeTypeId);
106:
107: // Should never reach this point. A preferred value needs to be set
108: return null; // TODO: NEVER RETURN NULL
109: }
110:
111: /**
112: * Sets the preferred MediaType for this CapabilityMap
113: * @param MediaTypeEntry
114: */
115: public void setPreferredMediaType(MediaType type) {
116: this .preferredMediaType = type;
117: }
118:
119: /**
120: Returns the preferred media type for the current user-agent
121: */
122: public MediaType getPreferredMediaType() {
123: return this .preferredMediaType;
124: }
125:
126: /**
127: * Returns an ordered list of supported media-types, from most preferred
128: * to least preferred
129: */
130: public Iterator listMediaTypes() {
131: return mediaTypeMap.values().iterator();
132: }
133:
134: /**
135: Returns the user-agent string
136: */
137: public String getAgent() {
138: return this .useragent;
139: }
140:
141: /**
142: * set userAgent
143: */
144: public void setAgent(String userAgent) {
145: this .useragent = userAgent;
146: }
147:
148: /**
149: * Checks to see if the current agent has the specified capability
150: */
151: public boolean hasCapability(int capability) {
152: Iterator capabilities = capabilityMap.values().iterator();
153: while (capabilities.hasNext()) {
154: if (((Capability) capabilities.next()).getCapabilityId() == capability) {
155: return true;
156: }
157: }
158: return false;
159: }
160:
161: /**
162: * Checks to see if the current agent has the specified capability
163: */
164: public boolean hasCapability(String capability) {
165: Iterator capabilities = capabilityMap.values().iterator();
166: while (capabilities.hasNext()) {
167: if (((Capability) capabilities.next()).getName().equals(
168: capability)) {
169: return true;
170: }
171: }
172: return false;
173: }
174:
175: /**
176: Get the mime types that this CapabilityMap supports.
177: */
178: public Iterator getMimeTypes() {
179: return mimeTypeMap.values().iterator();
180: }
181:
182: /**
183: Return true if this CapabilityMap supports the given MimeType
184: */
185: public boolean supportsMimeType(MimeType mimeType) {
186: Iterator mimetypes = mimeTypeMap.values().iterator();
187: while (mimetypes.hasNext()) {
188: if (((MimeType) mimetypes.next()).getName().equals(
189: mimeType.getName())) {
190: return true;
191: }
192: }
193: return false;
194: }
195:
196: /**
197: * Return true if this CapabilityMap supports the given media type
198: *
199: * @param media the name of a media type registered in the
200: * MediaType registry
201: *
202: * @return true is the capabilities of this agent at least match those
203: * required by the media type
204: */
205: public boolean supportsMediaType(String media) {
206: Iterator mediatypes = mediaTypeMap.values().iterator();
207: while (mediatypes.hasNext()) {
208: if (((MediaType) mediatypes.next()).getName() == media) {
209: return true;
210: }
211: }
212: return false;
213: }
214:
215: /**
216: * Create a map -> string representation
217: */
218: public String toString() {
219: return "";
220: }
221:
222: }
|