001: /*
002: * Copyright 2002-2007 the original author or authors.
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.springframework.ui;
018:
019: import java.util.Collection;
020: import java.util.Iterator;
021: import java.util.LinkedHashMap;
022: import java.util.Map;
023:
024: import org.springframework.core.Conventions;
025: import org.springframework.util.Assert;
026:
027: /**
028: * Implementation of {@link java.util.Map} for use when building model data for use
029: * with UI tools. Supports chained calls and generation of model attribute names.
030: *
031: * <p>This class serves as generic model holder for both Servlet and Portlet MVC,
032: * but is not tied to either of those.
033: *
034: * @author Rob Harrop
035: * @author Juergen Hoeller
036: * @since 2.0
037: * @see Conventions#getVariableName
038: * @see org.springframework.web.servlet.ModelAndView
039: * @see org.springframework.web.portlet.ModelAndView
040: */
041: public class ModelMap extends LinkedHashMap {
042:
043: /**
044: * Construct a new, empty <code>ModelMap</code>.
045: */
046: public ModelMap() {
047: }
048:
049: /**
050: * Construct a new <code>ModelMap</code> containing the supplied attribute
051: * under the supplied name.
052: * @see #addAttribute(String, Object)
053: */
054: public ModelMap(String attributeName, Object attributeValue) {
055: addAttribute(attributeName, attributeValue);
056: }
057:
058: /**
059: * Construct a new <code>ModelMap</code> containing the supplied attribute.
060: * Uses attribute name generation to generate the key for the supplied model
061: * object.
062: * @see #addAttribute(Object)
063: */
064: public ModelMap(Object attributeValue) {
065: addAttribute(attributeValue);
066: }
067:
068: /**
069: * Add the supplied attribute under the supplied name.
070: * @param attributeName the name of the model attribute (never <code>null</code>)
071: * @param attributeValue the model attribute value (can be <code>null</code>)
072: */
073: public ModelMap addAttribute(String attributeName,
074: Object attributeValue) {
075: Assert.notNull(attributeName,
076: "Model attribute name must not be null");
077: put(attributeName, attributeValue);
078: return this ;
079: }
080:
081: /**
082: * Add the supplied attribute to this <code>Map</code> using a
083: * {@link org.springframework.core.Conventions#getVariableName generated name}.
084: * <p/><emphasis>Note: Empty {@link Collection Collections} are not added to
085: * the model when using this method because we cannot correctly determine
086: * the true convention name. View code should check for <code>null</code> rather
087: * than for empty collections as is already done by JSTL tags.</emphasis>
088: * @param attributeValue the model attribute value (never <code>null</code>)
089: */
090: public ModelMap addAttribute(Object attributeValue) {
091: Assert.notNull(attributeValue, "Model object must not be null");
092: if (attributeValue instanceof Collection
093: && ((Collection) attributeValue).isEmpty()) {
094: return this ;
095: }
096: return addAttribute(
097: Conventions.getVariableName(attributeValue),
098: attributeValue);
099: }
100:
101: /**
102: * Copy all attributes in the supplied <code>Collection</code> into this
103: * <code>Map</code>, using attribute name generation for each element.
104: * @see #addAttribute(Object)
105: */
106: public ModelMap addAllAttributes(Collection attributeValues) {
107: if (attributeValues != null) {
108: for (Iterator it = attributeValues.iterator(); it.hasNext();) {
109: addAttribute(it.next());
110: }
111: }
112: return this ;
113: }
114:
115: /**
116: * Copy all attributes in the supplied <code>Map</code> into this <code>Map</code>.
117: * @see #addAttribute(String, Object)
118: */
119: public ModelMap addAllAttributes(Map attributes) {
120: if (attributes != null) {
121: putAll(attributes);
122: }
123: return this ;
124: }
125:
126: /**
127: * Copy all attributes in the supplied <code>Map</code> into this <code>Map</code>,
128: * with existing objects of the same name taking precedence (i.e. not getting
129: * replaced).
130: */
131: public ModelMap mergeAttributes(Map attributes) {
132: if (attributes != null) {
133: for (Iterator it = keySet().iterator(); it.hasNext();) {
134: Object key = it.next();
135: if (!containsKey(key)) {
136: put(key, attributes.get(key));
137: }
138: }
139: }
140: return this ;
141: }
142:
143: /**
144: * @deprecated as of Spring 2.5, in favor of {@link #addAttribute(String, Object)}
145: */
146: public ModelMap addObject(String modelName, Object modelObject) {
147: return addAttribute(modelName, modelObject);
148: }
149:
150: /**
151: * @deprecated as of Spring 2.5, in favor of {@link #addAttribute(Object)}
152: */
153: public ModelMap addObject(Object modelObject) {
154: return addAttribute(modelObject);
155: }
156:
157: /**
158: * @deprecated as of Spring 2.5, in favor of {@link #addAllAttributes(Collection)}
159: */
160: public ModelMap addAllObjects(Collection objects) {
161: return addAllAttributes(objects);
162: }
163:
164: /**
165: * @deprecated as of Spring 2.5, in favor of {@link #addAllAttributes(Map)}
166: */
167: public ModelMap addAllObjects(Map objects) {
168: return addAllAttributes(objects);
169: }
170:
171: }
|