// ========================================================================
// $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 net.lightbody.bmp.proxy.jetty.http;
import net.lightbody.bmp.proxy.jetty.log.LogFactory;
import net.lightbody.bmp.proxy.jetty.util.LazyList;
import net.lightbody.bmp.proxy.jetty.util.SingletonList;
import net.lightbody.bmp.proxy.jetty.util.StringMap;
import org.apache.commons.logging.Log;
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("net.lightbody.bmp.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;
}
}
}