src/main/java/org/apache/felix/webconsole/WebConsoleUtil.java - felix-dev - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you 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.apache.felix.webconsole;


 import java.io.IOException;
 import java.lang.reflect.Array;
 import java.net.URLDecoder;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;

 import javax.servlet.ServletRequest;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;

 import org.apache.commons.fileupload.FileItem;
 import org.apache.commons.fileupload.FileUploadBase;
 import org.apache.commons.fileupload.FileUploadException;
 import org.apache.commons.fileupload.disk.DiskFileItemFactory;
 import org.apache.commons.fileupload.servlet.ServletFileUpload;
 import org.apache.commons.fileupload.servlet.ServletRequestContext;
 import org.json.JSONException;
 import org.json.JSONWriter;


 /**
  * The <code>WebConsoleUtil</code> provides various utility methods for use
  * by Web Console plugins.
  */
 public final class WebConsoleUtil
 {

     private WebConsoleUtil()
     {
         /* no instantiation */
     }

     /**
      * Returns the {@link VariableResolver} for the given request.
      * <p>
      * If no resolver has yet be created for the requests, an instance of the
      * {@link DefaultVariableResolver} is created with preset properties,
      * placed into the request and returned. The preset properties are
      * <code>appRoot</code> set to the value of the
      * {@link WebConsoleConstants#ATTR_APP_ROOT} request attribute and
      * <code>pluginRoot</code> set to the value of the
      * {@link WebConsoleConstants#ATTR_PLUGIN_ROOT} request attribute.
      * <p>
      * <b>Note</b>: An object not implementing the {@link VariableResolver}
      * interface already stored as the
      * {@link WebConsoleConstants#ATTR_CONSOLE_VARIABLE_RESOLVER} attribute
      * will silently be replaced by the {@link DefaultVariableResolver}
      * instance.
      *
      * @param request The request whose attribute is returned (or set)
      *
      * @return The {@link VariableResolver} for the given request.
      */
     public static VariableResolver getVariableResolver( final ServletRequest request )
     {
         final Object resolverObj = request.getAttribute( WebConsoleConstants.ATTR_CONSOLE_VARIABLE_RESOLVER );
         if ( resolverObj instanceof VariableResolver )
         {
             return ( VariableResolver ) resolverObj;
         }

         final DefaultVariableResolver resolver = new DefaultVariableResolver();
         // FIXME: don't we need a constant for the values below?
         resolver.put( "appRoot", request.getAttribute( WebConsoleConstants.ATTR_APP_ROOT ) ); //$NON-NLS-1$
         resolver.put( "pluginRoot", request.getAttribute( WebConsoleConstants.ATTR_PLUGIN_ROOT ) ); //$NON-NLS-1$
         setVariableResolver( request, resolver );
         return resolver;
     }


     /**
      * Sets the {@link VariableResolver} as the
      * {@link WebConsoleConstants#ATTR_CONSOLE_VARIABLE_RESOLVER}
      * attribute in the given request. An attribute of that name already
      * existing is silently replaced.
      *
      * @param request The request whose attribute is set
      * @param resolver The {@link VariableResolver} to place into the request
      */
     public static void setVariableResolver( final ServletRequest request, final VariableResolver resolver )
     {
         request.setAttribute( WebConsoleConstants.ATTR_CONSOLE_VARIABLE_RESOLVER, resolver );
     }


     /**
      * An utility method, that is used to filter out simple parameter from file
      * parameter when multipart transfer encoding is used.
      *
      * This method processes the request and sets a request attribute
      * {@link AbstractWebConsolePlugin#ATTR_FILEUPLOAD}. The attribute value is a {@link Map}
      * where the key is a String specifying the field name and the value
      * is a {@link org.apache.commons.fileupload.FileItem}.
      *
      * @param request the HTTP request coming from the user
      * @param name the name of the parameter
      * @return if not multipart transfer encoding is used - the value is the
      *  parameter value or <code>null</code> if not set. If multipart is used,
      *  and the specified parameter is field - then the value of the parameter
      *  is returned.
      */
     public static final String getParameter( HttpServletRequest request, String name )
     {
         // just get the parameter if not a multipart/form-data POST
         if ( !FileUploadBase.isMultipartContent( new ServletRequestContext( request ) ) )
         {
             return request.getParameter( name );
         }

         // check, whether we already have the parameters
         Map params = ( Map ) request.getAttribute( AbstractWebConsolePlugin.ATTR_FILEUPLOAD );
         if ( params == null )
         {
             // parameters not read yet, read now
             // Create a factory for disk-based file items
             DiskFileItemFactory factory = new DiskFileItemFactory();
             factory.setSizeThreshold( 256000 );

             // Create a new file upload handler
             ServletFileUpload upload = new ServletFileUpload( factory );
             upload.setSizeMax( -1 );

             // Parse the request
             params = new HashMap();
             try
             {
                 List items = upload.parseRequest( request );
                 for ( Iterator fiter = items.iterator(); fiter.hasNext(); )
                 {
                     FileItem fi = ( FileItem ) fiter.next();
                     FileItem[] current = ( FileItem[] ) params.get( fi.getFieldName() );
                     if ( current == null )
                     {
                         current = new FileItem[]
                             { fi };
                     }
                     else
                     {
                         FileItem[] newCurrent = new FileItem[current.length + 1];
                         System.arraycopy( current, 0, newCurrent, 0, current.length );
                         newCurrent[current.length] = fi;
                         current = newCurrent;
                     }
                     params.put( fi.getFieldName(), current );
                 }
             }
             catch ( FileUploadException fue )
             {
                 // TODO: log
             }
             request.setAttribute( AbstractWebConsolePlugin.ATTR_FILEUPLOAD, params );
         }

         FileItem[] param = ( FileItem[] ) params.get( name );
         if ( param != null )
         {
             for ( int i = 0; i < param.length; i++ )
             {
                 if ( param[i].isFormField() )
                 {
                     return param[i].getString();
                 }
             }
         }

         // no valid string parameter, fail
         return null;
     }

     /**
      * Utility method to handle relative redirects.
      * Some application servers like Web Sphere handle relative redirects differently
      * therefore we should make an absolute URL before invoking send redirect.
      *
      * @param request the HTTP request coming from the user
      * @param response the HTTP response, where data is rendered
      * @param redirectUrl the redirect URI.
      * @throws IOException If an input or output exception occurs
      * @throws IllegalStateException   If the response was committed or if a partial
      *  URL is given and cannot be converted into a valid URL
      */
     public static final void sendRedirect(final HttpServletRequest request,
                                 final HttpServletResponse response,
                                 String redirectUrl) throws IOException {
         // check for relative URL
         if ( !redirectUrl.startsWith("/") ) { //$NON-NLS-1$
             String base = request.getContextPath() + request.getServletPath() + request.getPathInfo();
             int i = base.lastIndexOf('/');
             if (i > -1) {
                 base = base.substring(0, i);
             } else {
                 i = base.indexOf(':');
                 base = (i > -1) ? base.substring(i + 1, base.length()) : ""; //$NON-NLS-1$
             }
             if (!base.startsWith("/")) { //$NON-NLS-1$
                 base = '/' + base;
             }
             redirectUrl = base + '/' + redirectUrl;

         }
         response.sendRedirect(redirectUrl);
     }

     /**
      * Sets response headers to force the client to not cache the response
      * sent back. This method must be called before the response is committed
      * otherwise it will have no effect.
      * <p>
      * This method sets the <code>Cache-Control</code>, <code>Expires</code>,
      * and <code>Pragma</code> headers.
      *
      * @param response The response for which to set the cache prevention
      */
     public static final void setNoCache(final HttpServletResponse response) {
         response.setHeader("Cache-Control", "no-cache"); //$NON-NLS-1$ //$NON-NLS-2$
         response.addHeader("Cache-Control", "no-store"); //$NON-NLS-1$ //$NON-NLS-2$
         response.addHeader("Cache-Control", "must-revalidate"); //$NON-NLS-1$ //$NON-NLS-2$
         response.addHeader("Cache-Control", "max-age=0"); //$NON-NLS-1$ //$NON-NLS-2$
         response.setHeader("Expires", "Thu, 01 Jan 1970 01:00:00 GMT"); //$NON-NLS-1$ //$NON-NLS-2$
         response.setHeader("Pragma", "no-cache"); //$NON-NLS-1$ //$NON-NLS-2$
     }

     /**
      * Escapes HTML special chars like: <>&\r\n and space
      *
      *
      * @param text the text to escape
      * @return the escaped text
      */
     public static final String escapeHtml(String text)
     {
         StringBuffer sb = new StringBuffer(text.length() * 4 / 3);
         synchronized (sb) // faster buffer operations
         {
             char ch, oldch = '_';
             for (int i = 0; i < text.length(); i++)
             {
                 switch (ch = text.charAt(i))
                 {
                     case '<':
                         sb.append("&lt;"); //$NON-NLS-1$
                         break;
                     case '>':
                         sb.append("&gt;"); //$NON-NLS-1$
                         break;
                     case '&':
                         sb.append("&amp;"); //$NON-NLS-1$
                         break;
                     case ' ':
                         sb.append("&nbsp;"); //$NON-NLS-1$
                         break;
                     case '\r':
                     case '\n':
                         if (oldch != '\r' && oldch != '\n') // don't add twice <br>
                             sb.append("<br/>\n"); //$NON-NLS-1$
                         break;
                     default:
                         sb.append(ch);
                 }
                 oldch = ch;
             }

             return sb.toString();
         }
     }

     /**
      * Retrieves a request parameter and converts it to int.
      *
      * @param request the HTTP request
      * @param name the name of the request parameter
      * @param _default the default value returned if the parameter is not set or is not a valid integer.
      * @return the request parameter if set and is valid integer, or the default value
      */
     public static final int getParameterInt(HttpServletRequest request, String name,
         int _default)
     {
         int ret = _default;
         String param = request.getParameter(name);
         try
         {
             if (param != null)
                 ret = Integer.parseInt(param);
         }
         catch (NumberFormatException nfe)
         {
             // don't care, will return default
         }

         return ret;
     }

     /**
      * Writes a key-value pair in a JSON writer. Write is performed only if both key and
      * value are not null.
      *
      * @param jw the writer, where to write the data
      * @param key the key value, stored under 'key'
      * @param value the value stored under 'value'
      * @throws JSONException if the value cannot be serialized.
      */
     public static final void keyVal(JSONWriter jw, String key, Object value)
         throws JSONException
     {
         if (key != null && value != null)
         {
             jw.object();
             jw.key("key"); //$NON-NLS-1$
             jw.value(key);
             jw.key("value"); //$NON-NLS-1$
             jw.value(value);
             jw.endObject();
         }
     }


     /**
      * Decode the given value expected to be URL encoded.
      * <p>
      * This method first tries to use the Java 1.4 method
      * <code>URLDecoder.decode(String, String)</code> method and falls back to
      * the now deprecated <code>URLDecoder.decode(String, String)</code>
      * which uses the platform character set to decode the string. This is
      * because the platforms before 1.4 and most notably some OSGi Execution
      * Environments (such as Minimum EE) do not provide the newer method.
      *
      * @param value the value to decode
      * @return the decoded string
      */
     public static String urlDecode( final String value )
     {
         // shortcut for empty or missing values
         if ( value == null || value.length() == 0 )
         {
             return value;
         }

         try
         {
             return URLDecoder.decode( value, "UTF-8" ); //$NON-NLS-1$
         }
         catch ( Throwable t )
         {
             // expected NoSuchMethodError: if platform does not support it
             // expected UnsupportedEncoding (not really: UTF-8 is required)
             return URLDecoder.decode( value );
         }
     }

     /**
      * This method will stringify a Java object. It is mostly used to print the values
      * of unknown properties. This method will correctly handle if the passed object
      * is array and will property display it.
      *
      * If the value is byte[] the elements are shown as Hex
      *
      * @param value the value to convert
      * @return the string representation of the value
      */
     public static final String toString(Object value)
     {
         if (value == null)
         {
             return "n/a"; //$NON-NLS-1$
         }
         else if (value.getClass().isArray())
         {
             final StringBuffer sb = new StringBuffer();
             final int len = Array.getLength(value);
             synchronized (sb)
             { // it's faster to synchronize ALL loop calls
                 sb.append('[');
                 for (int i = 0; i < len; i++)
                 {
                     final Object element = Array.get(value, i);
                     if (element instanceof Byte)
                     {
                         // convert byte[] to hex string
                         sb.append("0x"); //$NON-NLS-1$
                         final String x = Integer.toHexString(((Byte) element).intValue() & 0xff);
                         if (1 == x.length())
                         {
                             sb.append('0');
                         }
                         sb.append(x);
                     }
                     else
                     {
                         sb.append(toString(element));
                     }

                     if (i < len - 1)
                     {
                         sb.append(", "); //$NON-NLS-1$
                     }
                 }
                 return sb.append(']').toString();
             }
         }
         else
         {
             return value.toString();
         }

     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you 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.apache.felix.webconsole;


	import java.io.IOException;
	import java.lang.reflect.Array;
	import java.net.URLDecoder;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;

	import javax.servlet.ServletRequest;
	import javax.servlet.http.HttpServletRequest;
	import javax.servlet.http.HttpServletResponse;

	import org.apache.commons.fileupload.FileItem;
	import org.apache.commons.fileupload.FileUploadBase;
	import org.apache.commons.fileupload.FileUploadException;
	import org.apache.commons.fileupload.disk.DiskFileItemFactory;
	import org.apache.commons.fileupload.servlet.ServletFileUpload;
	import org.apache.commons.fileupload.servlet.ServletRequestContext;
	import org.json.JSONException;
	import org.json.JSONWriter;


	/**
	* The <code>WebConsoleUtil</code> provides various utility methods for use
	* by Web Console plugins.
	*/
	public final class WebConsoleUtil
	{

	private WebConsoleUtil()
	{
	/* no instantiation */
	}

	/**
	* Returns the {@link VariableResolver} for the given request.
	* <p>
	* If no resolver has yet be created for the requests, an instance of the
	* {@link DefaultVariableResolver} is created with preset properties,
	* placed into the request and returned. The preset properties are
	* <code>appRoot</code> set to the value of the
	* {@link WebConsoleConstants#ATTR_APP_ROOT} request attribute and
	* <code>pluginRoot</code> set to the value of the
	* {@link WebConsoleConstants#ATTR_PLUGIN_ROOT} request attribute.
	* <p>
	* <b>Note</b>: An object not implementing the {@link VariableResolver}
	* interface already stored as the
	* {@link WebConsoleConstants#ATTR_CONSOLE_VARIABLE_RESOLVER} attribute
	* will silently be replaced by the {@link DefaultVariableResolver}
	* instance.
	*
	* @param request The request whose attribute is returned (or set)
	*
	* @return The {@link VariableResolver} for the given request.
	*/
	public static VariableResolver getVariableResolver( final ServletRequest request )
	{
	final Object resolverObj = request.getAttribute( WebConsoleConstants.ATTR_CONSOLE_VARIABLE_RESOLVER );
	if ( resolverObj instanceof VariableResolver )
	{
	return ( VariableResolver ) resolverObj;
	}

	final DefaultVariableResolver resolver = new DefaultVariableResolver();
	// FIXME: don't we need a constant for the values below?
	resolver.put( "appRoot", request.getAttribute( WebConsoleConstants.ATTR_APP_ROOT ) ); //$NON-NLS-1$
	resolver.put( "pluginRoot", request.getAttribute( WebConsoleConstants.ATTR_PLUGIN_ROOT ) ); //$NON-NLS-1$
	setVariableResolver( request, resolver );
	return resolver;
	}


	/**
	* Sets the {@link VariableResolver} as the
	* {@link WebConsoleConstants#ATTR_CONSOLE_VARIABLE_RESOLVER}
	* attribute in the given request. An attribute of that name already
	* existing is silently replaced.
	*
	* @param request The request whose attribute is set
	* @param resolver The {@link VariableResolver} to place into the request
	*/
	public static void setVariableResolver( final ServletRequest request, final VariableResolver resolver )
	{
	request.setAttribute( WebConsoleConstants.ATTR_CONSOLE_VARIABLE_RESOLVER, resolver );
	}


	/**
	* An utility method, that is used to filter out simple parameter from file
	* parameter when multipart transfer encoding is used.
	*
	* This method processes the request and sets a request attribute
	* {@link AbstractWebConsolePlugin#ATTR_FILEUPLOAD}. The attribute value is a {@link Map}
	* where the key is a String specifying the field name and the value
	* is a {@link org.apache.commons.fileupload.FileItem}.
	*
	* @param request the HTTP request coming from the user
	* @param name the name of the parameter
	* @return if not multipart transfer encoding is used - the value is the
	* parameter value or <code>null</code> if not set. If multipart is used,
	* and the specified parameter is field - then the value of the parameter
	* is returned.
	*/
	public static final String getParameter( HttpServletRequest request, String name )
	{
	// just get the parameter if not a multipart/form-data POST
	if ( !FileUploadBase.isMultipartContent( new ServletRequestContext( request ) ) )
	{
	return request.getParameter( name );
	}

	// check, whether we already have the parameters
	Map params = ( Map ) request.getAttribute( AbstractWebConsolePlugin.ATTR_FILEUPLOAD );
	if ( params == null )
	{
	// parameters not read yet, read now
	// Create a factory for disk-based file items
	DiskFileItemFactory factory = new DiskFileItemFactory();
	factory.setSizeThreshold( 256000 );

	// Create a new file upload handler
	ServletFileUpload upload = new ServletFileUpload( factory );
	upload.setSizeMax( -1 );

	// Parse the request
	params = new HashMap();
	try
	{
	List items = upload.parseRequest( request );
	for ( Iterator fiter = items.iterator(); fiter.hasNext(); )
	{
	FileItem fi = ( FileItem ) fiter.next();
	FileItem[] current = ( FileItem[] ) params.get( fi.getFieldName() );
	if ( current == null )
	{
	current = new FileItem[]
	{ fi };
	}
	else
	{
	FileItem[] newCurrent = new FileItem[current.length + 1];
	System.arraycopy( current, 0, newCurrent, 0, current.length );
	newCurrent[current.length] = fi;
	current = newCurrent;
	}
	params.put( fi.getFieldName(), current );
	}
	}
	catch ( FileUploadException fue )
	{
	// TODO: log
	}
	request.setAttribute( AbstractWebConsolePlugin.ATTR_FILEUPLOAD, params );
	}

	FileItem[] param = ( FileItem[] ) params.get( name );
	if ( param != null )
	{
	for ( int i = 0; i < param.length; i++ )
	{
	if ( param[i].isFormField() )
	{
	return param[i].getString();
	}
	}
	}

	// no valid string parameter, fail
	return null;
	}

	/**
	* Utility method to handle relative redirects.
	* Some application servers like Web Sphere handle relative redirects differently
	* therefore we should make an absolute URL before invoking send redirect.
	*
	* @param request the HTTP request coming from the user
	* @param response the HTTP response, where data is rendered
	* @param redirectUrl the redirect URI.
	* @throws IOException If an input or output exception occurs
	* @throws IllegalStateException If the response was committed or if a partial
	* URL is given and cannot be converted into a valid URL
	*/
	public static final void sendRedirect(final HttpServletRequest request,
	final HttpServletResponse response,
	String redirectUrl) throws IOException {
	// check for relative URL
	if ( !redirectUrl.startsWith("/") ) { //$NON-NLS-1$
	String base = request.getContextPath() + request.getServletPath() + request.getPathInfo();
	int i = base.lastIndexOf('/');
	if (i > -1) {
	base = base.substring(0, i);
	} else {
	i = base.indexOf(':');
	base = (i > -1) ? base.substring(i + 1, base.length()) : ""; //$NON-NLS-1$
	}
	if (!base.startsWith("/")) { //$NON-NLS-1$
	base = '/' + base;
	}
	redirectUrl = base + '/' + redirectUrl;

	}
	response.sendRedirect(redirectUrl);
	}

	/**
	* Sets response headers to force the client to not cache the response
	* sent back. This method must be called before the response is committed
	* otherwise it will have no effect.
	* <p>
	* This method sets the <code>Cache-Control</code>, <code>Expires</code>,
	* and <code>Pragma</code> headers.
	*
	* @param response The response for which to set the cache prevention
	*/
	public static final void setNoCache(final HttpServletResponse response) {
	response.setHeader("Cache-Control", "no-cache"); //$NON-NLS-1$ //$NON-NLS-2$
	response.addHeader("Cache-Control", "no-store"); //$NON-NLS-1$ //$NON-NLS-2$
	response.addHeader("Cache-Control", "must-revalidate"); //$NON-NLS-1$ //$NON-NLS-2$
	response.addHeader("Cache-Control", "max-age=0"); //$NON-NLS-1$ //$NON-NLS-2$
	response.setHeader("Expires", "Thu, 01 Jan 1970 01:00:00 GMT"); //$NON-NLS-1$ //$NON-NLS-2$
	response.setHeader("Pragma", "no-cache"); //$NON-NLS-1$ //$NON-NLS-2$
	}

	/**
	* Escapes HTML special chars like: <>&\r\n and space
	*
	*
	* @param text the text to escape
	* @return the escaped text
	*/
	public static final String escapeHtml(String text)
	{
	StringBuffer sb = new StringBuffer(text.length() * 4 / 3);
	synchronized (sb) // faster buffer operations
	{
	char ch, oldch = '_';
	for (int i = 0; i < text.length(); i++)
	{
	switch (ch = text.charAt(i))
	{
	case '<':
	sb.append("<"); //$NON-NLS-1$
	break;
	case '>':
	sb.append(">"); //$NON-NLS-1$
	break;
	case '&':
	sb.append("&"); //$NON-NLS-1$
	break;
	case ' ':
	sb.append(" "); //$NON-NLS-1$
	break;
	case '\r':
	case '\n':
	if (oldch != '\r' && oldch != '\n') // don't add twice <br>
	sb.append("<br/>\n"); //$NON-NLS-1$
	break;
	default:
	sb.append(ch);
	}
	oldch = ch;
	}

	return sb.toString();
	}
	}

	/**
	* Retrieves a request parameter and converts it to int.
	*
	* @param request the HTTP request
	* @param name the name of the request parameter
	* @param _default the default value returned if the parameter is not set or is not a valid integer.
	* @return the request parameter if set and is valid integer, or the default value
	*/
	public static final int getParameterInt(HttpServletRequest request, String name,
	int _default)
	{
	int ret = _default;
	String param = request.getParameter(name);
	try
	{
	if (param != null)
	ret = Integer.parseInt(param);
	}
	catch (NumberFormatException nfe)
	{
	// don't care, will return default
	}

	return ret;
	}

	/**
	* Writes a key-value pair in a JSON writer. Write is performed only if both key and
	* value are not null.
	*
	* @param jw the writer, where to write the data
	* @param key the key value, stored under 'key'
	* @param value the value stored under 'value'
	* @throws JSONException if the value cannot be serialized.
	*/
	public static final void keyVal(JSONWriter jw, String key, Object value)
	throws JSONException
	{
	if (key != null && value != null)
	{
	jw.object();
	jw.key("key"); //$NON-NLS-1$
	jw.value(key);
	jw.key("value"); //$NON-NLS-1$
	jw.value(value);
	jw.endObject();
	}
	}


	/**
	* Decode the given value expected to be URL encoded.
	* <p>
	* This method first tries to use the Java 1.4 method
	* <code>URLDecoder.decode(String, String)</code> method and falls back to
	* the now deprecated <code>URLDecoder.decode(String, String)</code>
	* which uses the platform character set to decode the string. This is
	* because the platforms before 1.4 and most notably some OSGi Execution
	* Environments (such as Minimum EE) do not provide the newer method.
	*
	* @param value the value to decode
	* @return the decoded string
	*/
	public static String urlDecode( final String value )
	{
	// shortcut for empty or missing values
	if ( value == null \|\| value.length() == 0 )
	{
	return value;
	}

	try
	{
	return URLDecoder.decode( value, "UTF-8" ); //$NON-NLS-1$
	}
	catch ( Throwable t )
	{
	// expected NoSuchMethodError: if platform does not support it
	// expected UnsupportedEncoding (not really: UTF-8 is required)
	return URLDecoder.decode( value );
	}
	}

	/**
	* This method will stringify a Java object. It is mostly used to print the values
	* of unknown properties. This method will correctly handle if the passed object
	* is array and will property display it.
	*
	* If the value is byte[] the elements are shown as Hex
	*
	* @param value the value to convert
	* @return the string representation of the value
	*/
	public static final String toString(Object value)
	{
	if (value == null)
	{
	return "n/a"; //$NON-NLS-1$
	}
	else if (value.getClass().isArray())
	{
	final StringBuffer sb = new StringBuffer();
	final int len = Array.getLength(value);
	synchronized (sb)
	{ // it's faster to synchronize ALL loop calls
	sb.append('[');
	for (int i = 0; i < len; i++)
	{
	final Object element = Array.get(value, i);
	if (element instanceof Byte)
	{
	// convert byte[] to hex string
	sb.append("0x"); //$NON-NLS-1$
	final String x = Integer.toHexString(((Byte) element).intValue() & 0xff);
	if (1 == x.length())
	{
	sb.append('0');
	}
	sb.append(x);
	}
	else
	{
	sb.append(toString(element));
	}

	if (i < len - 1)
	{
	sb.append(", "); //$NON-NLS-1$
	}
	}
	return sb.append(']').toString();
	}
	}
	else
	{
	return value.toString();
	}

	}
	}