Java tutorial
// ======================================================================== // $Id: PathMap.java,v 1.25 2005/08/13 00:01:24 gregwilkins Exp $ // Copyright 1999-2004 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // http://www.apache.org/licenses/LICENSE-2.0 // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // ======================================================================== package org.browsermob.proxy.jetty.http; import org.apache.commons.logging.Log; import org.browsermob.proxy.jetty.log.LogFactory; import org.browsermob.proxy.jetty.util.LazyList; import org.browsermob.proxy.jetty.util.SingletonList; import org.browsermob.proxy.jetty.util.StringMap; import java.io.Externalizable; import java.util.*; /* ------------------------------------------------------------ */ /** URI path map to Object. * This mapping implements the path specification recommended * in the 2.2 Servlet API. * * Path specifications can be of the following forms:<PRE> * /foo/bar - an exact path specification. * /foo/* - a prefix path specification (must end '/*'). * *.ext - a suffix path specification. * / - the default path specification. * </PRE> * Matching is performed in the following order <NL> * <LI>Exact match. * <LI>Longest prefix match. * <LI>Longest suffix match. * <LI>default. * </NL> * Multiple path specifications can be mapped by providing a list of * specifications. The list is separated by the characters specified * in the "org.mortbay.http.PathMap.separators" System property, which * defaults to : * <P> * Note that this is a very different mapping to that provided by PathMap * in Jetty2. * <P> * This class is not synchronized for get's. If concurrent modifications are * possible then it should be synchronized at a higher level. * * @version $Id: PathMap.java,v 1.25 2005/08/13 00:01:24 gregwilkins Exp $ * @author Greg Wilkins (gregw) */ public class PathMap extends HashMap implements Externalizable { private static Log log = LogFactory.getLog(PathMap.class); /* ------------------------------------------------------------ */ private static String __pathSpecSeparators = System .getProperty("org.browsermob.proxy.jetty.http.PathMap.separators", ":,"); /* ------------------------------------------------------------ */ /** Set the path spec separator. * Multiple path specification may be included in a single string * if they are separated by the characters set in this string. * The default value is ":," or whatever has been set by the * system property org.mortbay.http.PathMap.separators * @param s separators */ public static void setPathSpecSeparators(String s) { __pathSpecSeparators = s; } /* --------------------------------------------------------------- */ StringMap _prefixMap = new StringMap(); StringMap _suffixMap = new StringMap(); StringMap _exactMap = new StringMap(); List _defaultSingletonList = null; Map.Entry _prefixDefault = null; Map.Entry _default = null; Set _entrySet; boolean _nodefault = false; /* --------------------------------------------------------------- */ /** Construct empty PathMap. */ public PathMap() { super(11); _entrySet = entrySet(); } /* --------------------------------------------------------------- */ /** Construct empty PathMap. */ public PathMap(boolean nodefault) { super(11); _entrySet = entrySet(); _nodefault = nodefault; } /* --------------------------------------------------------------- */ /** Construct empty PathMap. */ public PathMap(int capacity) { super(capacity); _entrySet = entrySet(); } /* --------------------------------------------------------------- */ /** Construct from dictionary PathMap. */ public PathMap(Map m) { putAll(m); _entrySet = entrySet(); } /* ------------------------------------------------------------ */ public void writeExternal(java.io.ObjectOutput out) throws java.io.IOException { HashMap map = new HashMap(this); out.writeObject(map); } /* ------------------------------------------------------------ */ public void readExternal(java.io.ObjectInput in) throws java.io.IOException, ClassNotFoundException { HashMap map = (HashMap) in.readObject(); this.putAll(map); } /* --------------------------------------------------------------- */ /** Add a single path match to the PathMap. * @param pathSpec The path specification, or comma separated list of * path specifications. * @param object The object the path maps to */ public synchronized Object put(Object pathSpec, Object object) { StringTokenizer tok = new StringTokenizer(pathSpec.toString(), __pathSpecSeparators); Object old = null; while (tok.hasMoreTokens()) { String spec = tok.nextToken(); if (!spec.startsWith("/") && !spec.startsWith("*.")) { log.warn("PathSpec " + spec + ". must start with '/' or '*.'"); spec = "/" + spec; } old = super.put(spec, object); // Make entry that was just created. Entry entry = new Entry(spec, object); if (entry.getKey().equals(spec)) { if (spec.equals("/*")) _prefixDefault = entry; else if (spec.endsWith("/*")) { _prefixMap.put(spec.substring(0, spec.length() - 2), entry); _exactMap.put(spec.substring(0, spec.length() - 1), entry); _exactMap.put(spec.substring(0, spec.length() - 2), entry); } else if (spec.startsWith("*.")) _suffixMap.put(spec.substring(2), entry); else if (spec.equals("/")) { if (_nodefault) _exactMap.put(spec, entry); else { _default = entry; _defaultSingletonList = SingletonList.newSingletonList(_default); } } else _exactMap.put(spec, entry); } } return old; } /* ------------------------------------------------------------ */ /** Get object matched by the path. * @param path the path. * @return Best matched object or null. */ public Object match(String path) { Map.Entry entry = getMatch(path); if (entry != null) return entry.getValue(); return null; } /* --------------------------------------------------------------- */ /** Get the entry mapped by the best specification. * @param path the path. * @return Map.Entry of the best matched or null. */ public Map.Entry getMatch(String path) { Map.Entry entry; if (path == null) return null; int l = path.indexOf(';'); if (l < 0) { l = path.indexOf('?'); if (l < 0) l = path.length(); } // try exact match entry = _exactMap.getEntry(path, 0, l); if (entry != null) return (Map.Entry) entry.getValue(); // prefix search int i = l; while ((i = path.lastIndexOf('/', i - 1)) >= 0) { entry = _prefixMap.getEntry(path, 0, i); if (entry != null) return (Map.Entry) entry.getValue(); } // Prefix Default if (_prefixDefault != null) return _prefixDefault; // Extension search i = 0; while ((i = path.indexOf('.', i + 1)) > 0) { entry = _suffixMap.getEntry(path, i + 1, l - i - 1); if (entry != null) return (Map.Entry) entry.getValue(); } // Default return _default; } /* --------------------------------------------------------------- */ /** Get all entries matched by the path. * Best match first. * @param path Path to match * @return List of Map.Entry instances key=pathSpec */ public List getMatches(String path) { Map.Entry entry; Object entries = null; if (path == null) return LazyList.getList(entries); int l = path.indexOf(';'); if (l < 0) { l = path.indexOf('?'); if (l < 0) l = path.length(); } // try exact match entry = _exactMap.getEntry(path, 0, l); if (entry != null) entries = LazyList.add(entries, entry.getValue()); // prefix search int i = l - 1; while ((i = path.lastIndexOf('/', i - 1)) >= 0) { entry = _prefixMap.getEntry(path, 0, i); if (entry != null) entries = LazyList.add(entries, entry.getValue()); } // Prefix Default if (_prefixDefault != null) entries = LazyList.add(entries, _prefixDefault); // Extension search i = 0; while ((i = path.indexOf('.', i + 1)) > 0) { entry = _suffixMap.getEntry(path, i + 1, l - i - 1); if (entry != null) entries = LazyList.add(entries, entry.getValue()); } // Default if (_default != null) { // Optimization for just the default if (entries == null) return _defaultSingletonList; entries = LazyList.add(entries, _default); } return LazyList.getList(entries); } /* --------------------------------------------------------------- */ public synchronized Object remove(Object pathSpec) { if (pathSpec != null) { String spec = (String) pathSpec; if (spec.equals("/*")) _prefixDefault = null; else if (spec.endsWith("/*")) { _prefixMap.remove(spec.substring(0, spec.length() - 2)); _exactMap.remove(spec.substring(0, spec.length() - 1)); _exactMap.remove(spec.substring(0, spec.length() - 2)); } else if (spec.startsWith("*.")) _suffixMap.remove(spec.substring(2)); else if (spec.equals("/")) { _default = null; _defaultSingletonList = null; } else _exactMap.remove(spec); } return super.remove(pathSpec); } /* --------------------------------------------------------------- */ public void clear() { _exactMap = new StringMap(); _prefixMap = new StringMap(); _suffixMap = new StringMap(); _default = null; _defaultSingletonList = null; super.clear(); } /* --------------------------------------------------------------- */ /** * @return true if match. */ public static boolean match(String pathSpec, String path) throws IllegalArgumentException { char c = pathSpec.charAt(0); if (c == '/') { if (pathSpec.length() == 1 || pathSpec.equals(path)) return true; if (pathSpec.endsWith("/*") && pathSpec.regionMatches(0, path, 0, pathSpec.length() - 2)) return true; if (path.startsWith(pathSpec) && path.charAt(pathSpec.length()) == ';') return true; } else if (c == '*') return path.regionMatches(path.length() - pathSpec.length() + 1, pathSpec, 1, pathSpec.length() - 1); return false; } /* --------------------------------------------------------------- */ /** * @return true if match. */ public static boolean match(String pathSpec, String path, boolean noDefault) throws IllegalArgumentException { char c = pathSpec.charAt(0); if (c == '/') { if (!noDefault && pathSpec.length() == 1 || pathSpec.equals(path)) return true; if (pathSpec.endsWith("/*") && pathSpec.regionMatches(0, path, 0, pathSpec.length() - 2)) return true; if (path.startsWith(pathSpec) && path.charAt(pathSpec.length()) == ';') return true; } else if (c == '*') return path.regionMatches(path.length() - pathSpec.length() + 1, pathSpec, 1, pathSpec.length() - 1); return false; } /* --------------------------------------------------------------- */ /** Return the portion of a path that matches a path spec. * @return null if no match at all. */ public static String pathMatch(String pathSpec, String path) { char c = pathSpec.charAt(0); if (c == '/') { if (pathSpec.length() == 1) return path; if (pathSpec.equals(path)) return path; if (pathSpec.endsWith("/*") && pathSpec.regionMatches(0, path, 0, pathSpec.length() - 2)) return path.substring(0, pathSpec.length() - 2); if (path.startsWith(pathSpec) && path.charAt(pathSpec.length()) == ';') return path; } else if (c == '*') { if (path.regionMatches(path.length() - (pathSpec.length() - 1), pathSpec, 1, pathSpec.length() - 1)) return path; } return null; } /* --------------------------------------------------------------- */ /** Return the portion of a path that is after a path spec. * @return The path info string */ public static String pathInfo(String pathSpec, String path) { char c = pathSpec.charAt(0); if (c == '/') { if (pathSpec.length() == 1) return null; if (pathSpec.equals(path)) return null; if (pathSpec.endsWith("/*") && pathSpec.regionMatches(0, path, 0, pathSpec.length() - 2)) { if (path.length() == pathSpec.length() - 2) return null; return path.substring(pathSpec.length() - 2); } } return null; } /* ------------------------------------------------------------ */ /** Relative path. * @param base The base the path is relative to. * @param pathSpec The spec of the path segment to ignore. * @param path the additional path * @return base plus path with pathspec removed */ public static String relativePath(String base, String pathSpec, String path) { String info = pathInfo(pathSpec, path); if (info == null) info = path; if (info.startsWith("./")) info = info.substring(2); if (base.endsWith("/")) if (info.startsWith("/")) path = base + info.substring(1); else path = base + info; else if (info.startsWith("/")) path = base + info; else path = base + "/" + info; return path; } /* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */ private static class Entry implements Map.Entry { private Object key; private Object value; private transient String string; Entry(Object key, Object value) { this.key = key; this.value = value; } public Object getKey() { return key; } public Object getValue() { return value; } public Object setValue(Object o) { throw new UnsupportedOperationException(); } public String toString() { if (string == null) string = key + "=" + value; return string; } } }