Subversion Repositories general

package ak.backpath;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.util.Arrays;

import java.util.List;

import java.util.Iterator;

import java.util.Map;

import java.util.ArrayList;

import java.util.Set;

import java.util.TreeSet;

import java.util.Collections;

import java.util.zip.Deflater;

import java.util.zip.Inflater;

import java.util.zip.DeflaterOutputStream;

import java.util.zip.InflaterInputStream;

import java.net.URL;

import java.net.URLEncoder;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

public class BackPath

{

	private static Log log = LogFactory.getLog(BackPath.class);

	public static final String   DEFAULT_KEY            = BackPath.class.getName();

	public static final String   DEFAULT_PARAM          = "backpath";

	public static final String   OUT_CHARSET            = "UTF-8";

	public static final String   URL_CHARSET            = "UTF-8";

	public static final String   IGNORES_DELIMITER      = "\\s*;\\s*";

	public static final boolean  DEFAULT_ZIP            = true;

	public static final String[] METHODS_TO_SAVE_PARAMS = {"GET"};

	public static final char     URL_PARAM_START        = '?';

	public static final char     URL_PARAM_SEPARATOR    = '&';

	public static final char     URL_PARAM_VALUE        = '=';

	public static final char     URL_PARAM_VALUE_SEP    = ',';

	protected static final byte   URL_DELIMITER         = 0;

	protected static final int    BUFFER_SIZE           = 1024;

	protected static final int    INIT_STREAM_SIZE_COEF = 100;

	protected static final String URL_PARAM_START_STR   = "" + URL_PARAM_START;

	protected static Set methodsToSaveParams;

	// List(String)

	protected List     stack = new ArrayList();

	protected String   param = DEFAULT_PARAM;

    protected String[] ignoreParams = null;

	/** zip the stack */

	protected boolean zip = DEFAULT_ZIP;

	// string cache

	protected String  forwardParams;

	protected boolean forwardParamsFormed  = false;

	protected String  currentParams;

	protected boolean currentParamsFormed  = false;

	protected String  currentUrl;

	protected boolean currentUrlFormed     = false;

	protected String  backwardParams;

	protected boolean backwardParamsFormed = false;

	protected String  backwardUrl;

	protected boolean backwardUrlFormed    = false;

    static {

		methodsToSaveParams = Collections.unmodifiableSet(

			new TreeSet(Arrays.asList(METHODS_TO_SAVE_PARAMS)));

    }

	protected static Deflater deflater = new Deflater();

	protected static Inflater inflater = new Inflater();

	public static BackPath findBackPath(HttpServletRequest request)

		throws Exception

	{

		return findBackPath(request, DEFAULT_KEY, DEFAULT_PARAM, (String)null, DEFAULT_ZIP);

	}

	public static BackPath findBackPath(HttpServletRequest request, String backPathKey,

			String backPathParam, String backPathIgnore, boolean zip)

		throws Exception

	{

		String[] ignores = null;

        if(backPathIgnore != null)

          	ignores = backPathIgnore.trim().split(IGNORES_DELIMITER);

		return findBackPath(request, backPathKey, backPathParam, ignores, zip);

	}

	public static BackPath findBackPath(HttpServletRequest request, String backPathKey,

			String backPathParam, String[] ignores, boolean zip)

		throws Exception

	{

		Object backPathObj = request.getAttribute(backPathKey);

		if(backPathObj == null) {

			BackPath backPath;

			backPath = new BackPath(request, backPathParam, ignores, zip);

			request.setAttribute(backPathKey, backPath);

			return backPath;

		}

		else if(backPathObj instanceof BackPath) {

			return (BackPath)backPathObj;

		}

		else {

			throw new Exception("An object under key " + backPathKey

				+ " is not a " + BackPath.class.getName());

		}

	}

	public BackPath(HttpServletRequest request, String param, String[] ignoreParams, boolean zip)

	{

		this.zip          = zip;

		this.param        = param;

		this.ignoreParams = ignoreParams;

		init(request);

	}

	public boolean getZip()

	{

		return zip;

	}

	public void setZip(boolean zip)

	{

		this.zip = zip;

		resetCachedStrings();

	}

	public String getParam()

	{

		return param;

	}

	public void setParam(String param)

	{

		this.param = param;

		resetCachedStrings();

	}

	public String[] getIgnoreParams()

	{

		return ignoreParams;

	}

	public void setIgnoreParams(String[] ignoreParams)

	{

		this.ignoreParams = ignoreParams;

		resetCachedStrings();

	}

	public boolean getHasBack()

	{

		return (stack.size() > 1);

	}

	// List(String)

	public List getStack()

	{

		return Collections.unmodifiableList(stack);

	}

	public String getForwardParams()

	{

		if(!forwardParamsFormed) {

			forwardParams       = formForwardParams();

			forwardParamsFormed = true;

		}

		return forwardParams;

	}

	protected String formForwardParams()

	{

		try {

			return encode(stack, zip, 0);

		}

		catch(IOException ex) {

			log.error("Cannot form forward params", ex);

			return null;

		}

	}

	public String getBackwardParams()

	{

		if(!backwardParamsFormed) {

			backwardParams       = formBackwardParams();

			backwardParamsFormed = true;

		}

		return backwardParams;

	}

	protected String formBackwardParams()

	{

		try {

			if(stack.size() <= 2)

				return null;

			else

				return encode(stack, zip, 2);

		}

		catch(IOException ex) {

			log.error("Cannot form backward params", ex);

			return null;

		}

	}

	public String getBackwardUrl()

	{

		if(!backwardParamsFormed) {

			backwardUrl       = formBackwardUrl();

			backwardUrlFormed = true;

		}

		return backwardUrl;

	}

	protected String formBackwardUrl()

	{

		if(stack.size() < 2) return null;

		try {

			StringBuffer url = new StringBuffer((String)stack.get(stack.size()-2));

			if(stack.size() > 2) {

				String s = encode(stack, zip, 2);

				if(url.indexOf(URL_PARAM_START_STR) >= 0) url.append(URL_PARAM_SEPARATOR);

				else                                      url.append(URL_PARAM_START);

				url.append(param).append(URL_PARAM_VALUE).append(s);

			}

			return url.toString();

		}

		catch(IOException ex) {

			log.error("Cannot form backward url", ex);

			return null;

		}

	}

	public String getCurrentParams()

	{

		if(!currentParamsFormed) {

			currentParams       = formCurrentParams();

			currentParamsFormed = true;

		}

		return currentParams;

	}

	protected String formCurrentParams()

	{

		try {

			if(stack.size() <= 1)

				return null;

			else

				return encode(stack, zip, 1);

		}

		catch(IOException ex) {

			log.error("Cannot form current params", ex);

			return null;

		}

	}

	public String getCurrentUrl()

	{

		if(!currentParamsFormed) {

			currentUrl       = formCurrentUrl();

			currentUrlFormed = true;

		}

		return currentUrl;

	}

	protected String formCurrentUrl()

	{

		if(stack.size() < 1) return null;

		try {

			StringBuffer url = new StringBuffer((String)stack.get(stack.size()-1));

			if(stack.size() > 1) {

				String s = encode(stack, zip, 1);

				if(url.indexOf(URL_PARAM_START_STR) >= 0) url.append(URL_PARAM_SEPARATOR);

				else                                      url.append(URL_PARAM_START);

				url.append(param).append(URL_PARAM_VALUE).append(s);

			}

			return url.toString();

		}

		catch(IOException ex) {

			log.error("Cannot form current url", ex);

			return null;

		}

	}

	public void init(HttpServletRequest request)

	{

		try {

			resetCachedStrings();

			// get old

			decode(stack, request.getParameter(param), zip);

			// add new

			String url = (new URL(request.getRequestURL().toString())).getPath();

			if(methodsToSaveParams.contains(request.getMethod())) {

				// to ignore

				Set ignore = new TreeSet();

				if(ignoreParams != null) {

					for(int i = 0; i < ignoreParams.length; i++)

						ignore.add(ignoreParams[i]);

				}

				ignore.add(param);

				// form query string

				StringBuffer query = new StringBuffer();

				Map requestParams = request.getParameterMap();

				for(Iterator i = requestParams.keySet().iterator(); i.hasNext(); ) {

					String name = (String)i.next();

					if(ignore.contains(name)) continue;

					if(query.length() == 0)

						query.append(URL_PARAM_START);

					else

						query.append(URL_PARAM_SEPARATOR);

					query.append(URLEncoder.encode(name, URL_CHARSET));

					query.append(URL_PARAM_VALUE);

					String[] values = (String[])requestParams.get(name);

					for(int j = 0; j < values.length; j++) {

						if(j > 0) query.append(URL_PARAM_VALUE_SEP);

						query.append(URLEncoder.encode(values[j], URL_CHARSET));

					}

				}

				// form url

				if(query.length() > 0) url = query.insert(0, url).toString();

			}

			stack.add(url);

		}

		catch(IOException ex) {

			log.error("Cannot init", ex);

		}

	}

	/**

	 * @param stack List(String)

	 */

	protected String encode(List stack, boolean zip, int suffix)

		throws IOException

	{

		ByteArrayOutputStream buf = new ByteArrayOutputStream(stack.size()*INIT_STREAM_SIZE_COEF);

		Object lock = (zip ? (Object)BackPath.class : this);

		synchronized(lock) {

			OutputStream out;

			if(zip) {

				deflater.reset();

				out = new DeflaterOutputStream(new Base64.OutputStream(buf), deflater);

			}

			else {

				out = new Base64.OutputStream(buf);

			}

			for(int i = 0; i < stack.size()-suffix; i++) {

				String s = (String)stack.get(i);

				if(i > 0) out.write(URL_DELIMITER);

				out.write(s.getBytes(URL_CHARSET));

			}

			out.close();

		}

		return buf.toString(OUT_CHARSET);

	}

	/**

	 * @param stack List(String)

	 */

	protected void decode(List stack, String path, boolean zip)

		throws IOException

	{

		stack.clear();

		if(path == null || path.equals("")) return;

		ByteArrayOutputStream dec = new ByteArrayOutputStream(stack.size()*INIT_STREAM_SIZE_COEF);

		Object lock = (zip ? (Object)BackPath.class : this);

		synchronized(lock) {

			ByteArrayInputStream enc = new ByteArrayInputStream(path.getBytes(OUT_CHARSET));

			InputStream in;

			if(zip) {

				inflater.reset();

				in = new InflaterInputStream(new Base64.InputStream(enc), inflater);

			}

			else {

				in = new Base64.InputStream(enc);

			}

			byte[] tmp = new byte[BUFFER_SIZE];

			int    l;

			while((l = in.read(tmp, 0, tmp.length)) > 0) {

				dec.write(tmp, 0, l);

			}

		}

		try {

			byte[] buf = dec.toByteArray();

			for(int start = 0, end = 0; end <= buf.length; end++) {

				if(end == buf.length || buf[end] == URL_DELIMITER) {

					stack.add(new String(buf, start, end-start, URL_CHARSET));

					start = end+1;

				}

			}

		}

		catch(Exception ex) {  // if some mistake in stack, then ignore it completely

			stack.clear();

			log.info("Cannot parse stack", ex);

		}

	}

	protected void resetCachedStrings()

	{

		forwardParams        = null;

		forwardParamsFormed  = false;

		currentParams        = null;

		currentParamsFormed  = false;

		currentUrl           = null;

		currentUrlFormed     = false;

		backwardParams       = null;

		backwardParamsFormed = false;

		backwardUrl          = null;

		backwardUrlFormed    = false;

	}

}