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.cocoon.components.treeprocessor.variables;
018:
019: import java.util.Collections;
020: import java.util.HashMap;
021: import java.util.Iterator;
022: import java.util.Map;
023:
024: import org.apache.avalon.framework.parameters.Parameters;
025: import org.apache.cocoon.components.treeprocessor.InvokeContext;
026: import org.apache.cocoon.sitemap.PatternException;
027: import org.apache.cocoon.sitemap.SitemapParameters;
028: import org.apache.cocoon.util.location.Locatable;
029: import org.apache.cocoon.util.location.Location;
030:
031: /**
032: * Utility class for handling {...} pattern substitutions in sitemap statements.
033: *
034: * @author <a href="mailto:sylvain@apache.org">Sylvain Wallez</a>
035: * @version CVS $Id: VariableResolver.java 433543 2006-08-22 06:22:54Z crossley $
036: */
037: public abstract class VariableResolver {
038:
039: public static final Map EMPTY_MAP = Collections
040: .unmodifiableMap(new java.util.HashMap(0));
041:
042: protected final String originalExpr;
043:
044: protected VariableResolver(String expr) {
045: this .originalExpr = expr;
046: }
047:
048: public final String toString() {
049: return this .originalExpr;
050: }
051:
052: /**
053: * Compare two VariableResolvers
054: */
055: public boolean equals(Object object) {
056: if (object instanceof VariableResolver) {
057: VariableResolver other = (VariableResolver) object;
058: return (this .originalExpr == null && other.originalExpr == null)
059: || (this .originalExpr.equals(other.originalExpr));
060: } else {
061: return false;
062: }
063: }
064:
065: /**
066: * generate HashCode
067: * needed to determine uniqueness within hashtables
068: */
069: public int hashCode() {
070: return this .originalExpr == null ? 0 : this .originalExpr
071: .hashCode();
072: }
073:
074: /**
075: * Resolve all {...} patterns using the values given in the object model.
076: */
077: public String resolve(Map objectModel) throws PatternException {
078: return resolve(null, objectModel);
079: }
080:
081: /**
082: * Resolve all {...} patterns using the values given in the list of maps and the object model.
083: */
084: public abstract String resolve(InvokeContext context,
085: Map objectModel) throws PatternException;
086:
087: /**
088: * Build a <code>Parameters</code> object from a Map of named <code>VariableResolver</code>s and
089: * a list of Maps used for resolution.
090: *
091: * @return a fully resolved <code>Parameters</code>.
092: */
093: public static Parameters buildParameters(Map expressions,
094: InvokeContext context, Map objectModel)
095: throws PatternException {
096: Location location;
097: if (expressions instanceof Locatable) {
098: location = ((Locatable) expressions).getLocation();
099: } else {
100: location = Location.UNKNOWN;
101: }
102:
103: if (expressions == null || expressions.size() == 0
104: && location.equals(Location.UNKNOWN)) {
105: return Parameters.EMPTY_PARAMETERS;
106: }
107:
108: SitemapParameters result = new SitemapParameters(location);
109:
110: Iterator iter = expressions.entrySet().iterator();
111: while (iter.hasNext()) {
112: Map.Entry entry = (Map.Entry) iter.next();
113: result.setParameter(((VariableResolver) entry.getKey())
114: .resolve(context, objectModel),
115: ((VariableResolver) entry.getValue()).resolve(
116: context, objectModel));
117: }
118:
119: return result;
120: }
121:
122: /**
123: * Build a <code>Map</code> from a Map of named <code>ListOfMapResolver</code>s and
124: * a list of Maps used for resolution.
125: *
126: * @return a fully resolved <code>Map</code>.
127: */
128: public static Map buildMap(Map expressions, InvokeContext context,
129: Map objectModel) throws PatternException {
130: int size;
131: if (expressions == null || (size = expressions.size()) == 0) {
132: return EMPTY_MAP;
133: }
134:
135: Map result;
136: if (expressions instanceof Locatable) {
137: result = new SitemapParameters.LocatedHashMap(
138: ((Locatable) expressions).getLocation(), size);
139: } else {
140: result = new HashMap(size);
141: }
142:
143: Iterator iter = expressions.entrySet().iterator();
144: while (iter.hasNext()) {
145: Map.Entry entry = (Map.Entry) iter.next();
146: result.put(((VariableResolver) entry.getKey()).resolve(
147: context, objectModel), ((VariableResolver) entry
148: .getValue()).resolve(context, objectModel));
149: }
150:
151: return result;
152: }
153:
154: // /**
155: // * Release a <code>Map</code> of expressions.
156: // */
157: // public static void release(Map expressions) {
158: // Iterator iter = expressions.entrySet().iterator();
159: // while (iter.hasNext()) {
160: // Map.Entry entry = (Map.Entry)iter.next();
161: // ((VariableResolver)entry.getKey()).release();
162: // ((VariableResolver)entry.getValue()).release();
163: // }
164: // }
165: }
|